@rxflow/manhattan 0.0.1-alpha.0 → 0.0.1-alpha.2

package/cjs/geometry/collision.d.ts

@@ -0,0 +1,15 @@
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+/**
+ * Check if a line segment intersects with a rectangle
+ */
+export declare function lineSegmentIntersectsRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if a line segment crosses through a rectangle (not just touching edges)
+ */
+export declare function lineSegmentCrossesRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if two line segments intersect
+ */
+export declare function lineSegmentsIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean;
+//# sourceMappingURL=collision.d.ts.map

package/cjs/geometry/collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/geometry/collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAwBxF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAsBrF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAgBzF"}

package/cjs/geometry/collision.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lineSegmentCrossesRect = lineSegmentCrossesRect;
+exports.lineSegmentIntersectsRect = lineSegmentIntersectsRect;
+exports.lineSegmentsIntersect = lineSegmentsIntersect;
+var _Point = require("./Point");
+/**
+ * Check if a line segment intersects with a rectangle
+ */
+function lineSegmentIntersectsRect(p1, p2, rect) {
+  // Check if either endpoint is inside the rectangle
+  if (rect.containsPoint(p1) || rect.containsPoint(p2)) {
+    return true;
+  }
+
+  // Check if line segment intersects any of the rectangle's edges
+  const rectPoints = [new _Point.Point(rect.x, rect.y), new _Point.Point(rect.x + rect.width, rect.y), new _Point.Point(rect.x + rect.width, rect.y + rect.height), new _Point.Point(rect.x, rect.y + rect.height)];
+  for (let i = 0; i < 4; i++) {
+    const r1 = rectPoints[i];
+    const r2 = rectPoints[(i + 1) % 4];
+    if (lineSegmentsIntersect(p1, p2, r1, r2)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a line segment crosses through a rectangle (not just touching edges)
+ */
+function lineSegmentCrossesRect(p1, p2, rect) {
+  const tolerance = 1;
+
+  // Check if segment passes through the interior of the rectangle
+  // We sample points along the segment and check if any are strictly inside
+  const steps = 10;
+  for (let i = 1; i < steps; i++) {
+    const t = i / steps;
+    const x = p1.x + (p2.x - p1.x) * t;
+    const y = p1.y + (p2.y - p1.y) * t;
+    if (x > rect.x + tolerance && x < rect.x + rect.width - tolerance && y > rect.y + tolerance && y < rect.y + rect.height - tolerance) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if two line segments intersect
+ */
+function lineSegmentsIntersect(p1, p2, p3, p4) {
+  const d1 = direction(p3, p4, p1);
+  const d2 = direction(p3, p4, p2);
+  const d3 = direction(p1, p2, p3);
+  const d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return true;
+  }
+  if (d1 === 0 && onSegment(p3, p1, p4)) return true;
+  if (d2 === 0 && onSegment(p3, p2, p4)) return true;
+  if (d3 === 0 && onSegment(p1, p3, p2)) return true;
+  if (d4 === 0 && onSegment(p1, p4, p2)) return true;
+  return false;
+}
+
+/**
+ * Calculate direction of point p3 relative to line p1-p2
+ */
+function direction(p1, p2, p3) {
+  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+}
+
+/**
+ * Check if point p2 is on line segment p1-p3
+ */
+function onSegment(p1, p2, p3) {
+  return p2.x >= Math.min(p1.x, p3.x) && p2.x <= Math.max(p1.x, p3.x) && p2.y >= Math.min(p1.y, p3.y) && p2.y <= Math.max(p1.y, p3.y);
+}

package/cjs/geometry/index.d.ts

@@ -1,4 +1,5 @@
 export { Point } from './Point';
 export { Rectangle } from './Rectangle';
 export { Line } from './Line';
+export { lineSegmentIntersectsRect, lineSegmentCrossesRect, lineSegmentsIntersect } from './collision';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/cjs/geometry/index.js

@@ -21,6 +21,25 @@ Object.defineProperty(exports, "Rectangle", {
     return _Rectangle.Rectangle;
   }
 });
+Object.defineProperty(exports, "lineSegmentCrossesRect", {
+  enumerable: true,
+  get: function () {
+    return _collision.lineSegmentCrossesRect;
+  }
+});
+Object.defineProperty(exports, "lineSegmentIntersectsRect", {
+  enumerable: true,
+  get: function () {
+    return _collision.lineSegmentIntersectsRect;
+  }
+});
+Object.defineProperty(exports, "lineSegmentsIntersect", {
+  enumerable: true,
+  get: function () {
+    return _collision.lineSegmentsIntersect;
+  }
+});
 var _Point = require("./Point");
 var _Rectangle = require("./Rectangle");
-var _Line = require("./Line");
+var _Line = require("./Line");
+var _collision = require("./collision");

package/cjs/getManHattanPath.d.ts

@@ -1,3 +1,4 @@
+import { Position } from '@xyflow/react';
 import type { ManhattanRouterOptions, NodeLookup } from './options';
 /**
  * Parameters for getManHattanPath function
@@ -11,20 +12,12 @@ export interface GetManHattanPathParams {
      * Target node ID
      */
     targetNodeId: string;
-    /**
-     * Source anchor position (where the edge starts)
-     */
-    sourcePosition: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Target anchor position (where the edge ends)
-     */
-    targetPosition: {
-        x: number;
-        y: number;
-    };
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
     /**
      * ReactFlow node lookup map
      */

package/cjs/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAOnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;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,CA4PvE"}
+{"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"}

package/cjs/getManHattanPath.js

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getManHattanPath = getManHattanPath;
+var _react = require("@xyflow/react");
 var _geometry = require("./geometry");
-var _options = require("./options");
 var _obstacle = require("./obstacle");
+var _options = require("./options");
 var _pathfinder = require("./pathfinder");
 var _svg = require("./svg");
 var _utils = require("./utils");
@@ -16,10 +17,10 @@ var _utils = require("./utils");
 
 /**
  * Generate Manhattan-routed path for ReactFlow edges
- * 
+ *
  * @param params - Path generation parameters
  * @returns SVG path string that can be used with ReactFlow's BaseEdge
- * 
+ *
  * @example
  * ```typescript
  * const path = getManHattanPath({
@@ -43,6 +44,10 @@ function getManHattanPath(params) {
     sourcePosition,
     targetPosition,
     nodeLookup,
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
     options: userOptions = {}
   } = params;
 
@@ -55,8 +60,8 @@ function getManHattanPath(params) {
   if (!sourceNode || !targetNode) {
     // Fallback to simple straight line if nodes not found
     console.warn('Source or target node not found in nodeLookup');
-    const start = new _geometry.Point(sourcePosition.x, sourcePosition.y);
-    const end = new _geometry.Point(targetPosition.x, targetPosition.y);
+    const start = new _geometry.Point(sourceX, sourceY);
+    const end = new _geometry.Point(targetX, targetY);
     return (0, _svg.pointsToPath)([start, end], options.precision);
   }
 
@@ -73,8 +78,29 @@ function getManHattanPath(params) {
   const targetBBox = new _geometry.Rectangle(targetPos.x, targetPos.y, targetDimensions.width, targetDimensions.height);
 
   // Create anchor points
-  const sourceAnchor = new _geometry.Point(sourcePosition.x, sourcePosition.y);
-  const targetAnchor = new _geometry.Point(targetPosition.x, targetPosition.y);
+  const sourceAnchor = new _geometry.Point(sourceX, sourceY);
+  const targetAnchor = new _geometry.Point(targetX, targetY);
+
+  // Try ReactFlow's getSmoothStepPath first
+  const [smoothStepPath] = (0, _react.getSmoothStepPath)({
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition,
+    borderRadius: options.borderRadius
+  });
+
+  // Parse the smooth step path to extract points
+  const smoothStepPoints = (0, _svg.parseSVGPath)(smoothStepPath);
+
+  // Check if smooth step path intersects with any obstacles
+  if (smoothStepPoints.length > 0 && !(0, _utils.pathIntersectsObstacles)(smoothStepPoints, nodeLookup, sourceNodeId, targetNodeId)) {
+    console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
+    return smoothStepPath;
+  }
+  console.log('[getManHattanPath] SmoothStepPath intersects obstacles, using Manhattan routing');
 
   // Build obstacle map with anchor information
   const obstacleMap = new _obstacle.ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
@@ -249,37 +275,9 @@ function getManHattanPath(params) {
   }
 
   // Simplify path by removing collinear points
-  finalRoute = simplifyPath(finalRoute);
+  finalRoute = (0, _svg.simplifyPath)(finalRoute);
   console.log('[getManHattanPath] Simplified route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
 
   // Convert to SVG path string
   return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
-}
-
-/**
- * Simplify path by removing collinear intermediate points
- */
-function simplifyPath(points) {
-  if (points.length <= 2) {
-    return points;
-  }
-  const simplified = [points[0]];
-  for (let i = 1; i < points.length - 1; i++) {
-    const prev = simplified[simplified.length - 1];
-    const current = points[i];
-    const next = points[i + 1];
-
-    // Check if current point is collinear with prev and next
-    const isHorizontalLine = prev.y === current.y && current.y === next.y;
-    const isVerticalLine = prev.x === current.x && current.x === next.x;
-
-    // Only keep the point if it's not collinear (i.e., it's a corner)
-    if (!isHorizontalLine && !isVerticalLine) {
-      simplified.push(current);
-    }
-  }
-
-  // Always add the last point
-  simplified.push(points[points.length - 1]);
-  return simplified;
 }

package/cjs/svg/index.d.ts

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

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

@@ -1 +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"}
+{"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

@@ -3,16 +3,29 @@
 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 _pathConverter = require("./pathConverter");
+var _pathParser = require("./pathParser");

package/cjs/svg/pathParser.d.ts

@@ -0,0 +1,11 @@
+import { Point } from '../geometry';
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+export declare function parseSVGPath(pathString: string): Point[];
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+export declare function simplifyPath(points: Point[]): Point[];
+//# sourceMappingURL=pathParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA0CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}

package/cjs/svg/pathParser.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSVGPath = parseSVGPath;
+exports.simplifyPath = simplifyPath;
+var _geometry = require("../geometry");
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+function parseSVGPath(pathString) {
+  const points = [];
+  const commands = pathString.match(/[MLQ][^MLQ]*/g);
+  if (!commands) return points;
+  for (const command of commands) {
+    const type = command[0];
+    const coords = command.slice(1).trim().split(/[\s,]+/).map(Number);
+    if (type === 'M' || type === 'L') {
+      // MoveTo or LineTo: x, y
+      if (coords.length >= 2) {
+        points.push(new _geometry.Point(coords[0], coords[1]));
+      }
+    } else if (type === 'Q') {
+      // Quadratic Bezier: cx, cy, x, y
+      // We sample points along the curve for collision detection
+      if (coords.length >= 4) {
+        const prevPoint = points[points.length - 1];
+        if (prevPoint) {
+          const cx = coords[0];
+          const cy = coords[1];
+          const x = coords[2];
+          const y = coords[3];
+
+          // Sample 5 points along the bezier curve
+          for (let t = 0.2; t <= 1; t += 0.2) {
+            const bx = (1 - t) * (1 - t) * prevPoint.x + 2 * (1 - t) * t * cx + t * t * x;
+            const by = (1 - t) * (1 - t) * prevPoint.y + 2 * (1 - t) * t * cy + t * t * y;
+            points.push(new _geometry.Point(bx, by));
+          }
+        }
+      }
+    }
+  }
+  return points;
+}
+
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+function simplifyPath(points) {
+  if (points.length <= 2) {
+    return points;
+  }
+  const simplified = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = simplified[simplified.length - 1];
+    const current = points[i];
+    const next = points[i + 1];
+
+    // Check if current point is collinear with prev and next
+    const isHorizontalLine = prev.y === current.y && current.y === next.y;
+    const isVerticalLine = prev.x === current.x && current.x === next.x;
+
+    // Only keep the point if it's not collinear (i.e., it's a corner)
+    if (!isHorizontalLine && !isVerticalLine) {
+      simplified.push(current);
+    }
+  }
+
+  // Always add the last point
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}

package/cjs/utils/index.d.ts

@@ -3,4 +3,5 @@ export * from './direction';
 export * from './rect';
 export * from './route';
 export * from './node';
+export * from './pathValidation';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA"}

package/cjs/utils/index.js

@@ -57,4 +57,15 @@ Object.keys(_node).forEach(function (key) {
       return _node[key];
     }
   });
+});
+var _pathValidation = require("./pathValidation");
+Object.keys(_pathValidation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pathValidation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pathValidation[key];
+    }
+  });
 });

package/cjs/utils/pathValidation.d.ts

@@ -0,0 +1,7 @@
+import { Point } from '../geometry';
+import type { NodeLookup } from '../options';
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ */
+export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string): boolean;
+//# sourceMappingURL=pathValidation.d.ts.map

package/cjs/utils/pathValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA8E5C;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,KAAK,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CA2BT"}

package/cjs/utils/pathValidation.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathIntersectsObstacles = pathIntersectsObstacles;
+var _geometry = require("../geometry");
+var _collision = require("../geometry/collision");
+var _node = require("./node");
+/**
+ * Get node bounding box
+ */
+function getNodeBBox(nodeId, nodeLookup) {
+  const node = nodeLookup.get(nodeId);
+  if (!node) return null;
+  const dimensions = (0, _node.getNodeDimensions)(node);
+  const position = (0, _node.getNodePosition)(node);
+  return new _geometry.Rectangle(position.x, position.y, dimensions.width, dimensions.height);
+}
+
+/**
+ * Check if a point is strictly inside a rectangle (not on edge)
+ */
+function isPointStrictlyInside(point, rect, tolerance = 1) {
+  return point.x > rect.x + tolerance && point.x < rect.x + rect.width - tolerance && point.y > rect.y + tolerance && point.y < rect.y + rect.height - tolerance;
+}
+
+/**
+ * Check if a point intersects with a node
+ */
+function checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode) {
+  if (isTerminalNode) {
+    // For source/target nodes, only check if point is strictly inside (not on edge)
+    if (isPointStrictlyInside(point, nodeBBox)) {
+      console.log(`[pathIntersectsObstacles] Point (${point.x}, ${point.y}) is inside terminal node ${nodeId}`);
+      return true;
+    }
+  } else {
+    // For other nodes, check if point is inside or on edge
+    if (nodeBBox.containsPoint(point)) {
+      console.log(`[pathIntersectsObstacles] Point (${point.x}, ${point.y}) intersects node ${nodeId}`);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a line segment intersects with a node
+ */
+function checkSegmentIntersection(p1, p2, nodeId, nodeBBox, isTerminalNode) {
+  if (isTerminalNode) {
+    // For source/target nodes, check if segment crosses through (not just touching edge)
+    if ((0, _collision.lineSegmentCrossesRect)(p1, p2, nodeBBox)) {
+      console.log(`[pathIntersectsObstacles] Segment crosses terminal node ${nodeId}`);
+      return true;
+    }
+  } else {
+    // For other nodes, check normal intersection
+    if ((0, _collision.lineSegmentIntersectsRect)(p1, p2, nodeBBox)) {
+      console.log(`[pathIntersectsObstacles] Segment intersects node ${nodeId}`);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ */
+function pathIntersectsObstacles(pathPoints, nodeLookup, sourceNodeId, targetNodeId) {
+  // Iterate through all nodes
+  for (const [nodeId, node] of nodeLookup) {
+    const nodeBBox = getNodeBBox(nodeId, nodeLookup);
+    if (!nodeBBox) continue;
+    const isTerminalNode = nodeId === sourceNodeId || nodeId === targetNodeId;
+
+    // Check each point
+    for (let i = 0; i < pathPoints.length; i++) {
+      const point = pathPoints[i];
+      if (checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode)) {
+        return true;
+      }
+
+      // Check line segment to next point
+      if (i < pathPoints.length - 1) {
+        const nextPoint = pathPoints[i + 1];
+        if (checkSegmentIntersection(point, nextPoint, nodeId, nodeBBox, isTerminalNode)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}

package/esm/geometry/collision.d.ts

@@ -0,0 +1,15 @@
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+/**
+ * Check if a line segment intersects with a rectangle
+ */
+export declare function lineSegmentIntersectsRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if a line segment crosses through a rectangle (not just touching edges)
+ */
+export declare function lineSegmentCrossesRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if two line segments intersect
+ */
+export declare function lineSegmentsIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean;
+//# sourceMappingURL=collision.d.ts.map

package/esm/geometry/collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/geometry/collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAwBxF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAsBrF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAgBzF"}

package/esm/geometry/collision.js

@@ -0,0 +1,73 @@
+import { Point } from "./Point";
+/**
+ * Check if a line segment intersects with a rectangle
+ */
+export function lineSegmentIntersectsRect(p1, p2, rect) {
+  // Check if either endpoint is inside the rectangle
+  if (rect.containsPoint(p1) || rect.containsPoint(p2)) {
+    return true;
+  }
+
+  // Check if line segment intersects any of the rectangle's edges
+  var rectPoints = [new Point(rect.x, rect.y), new Point(rect.x + rect.width, rect.y), new Point(rect.x + rect.width, rect.y + rect.height), new Point(rect.x, rect.y + rect.height)];
+  for (var i = 0; i < 4; i++) {
+    var r1 = rectPoints[i];
+    var r2 = rectPoints[(i + 1) % 4];
+    if (lineSegmentsIntersect(p1, p2, r1, r2)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a line segment crosses through a rectangle (not just touching edges)
+ */
+export function lineSegmentCrossesRect(p1, p2, rect) {
+  var tolerance = 1;
+
+  // Check if segment passes through the interior of the rectangle
+  // We sample points along the segment and check if any are strictly inside
+  var steps = 10;
+  for (var i = 1; i < steps; i++) {
+    var t = i / steps;
+    var x = p1.x + (p2.x - p1.x) * t;
+    var y = p1.y + (p2.y - p1.y) * t;
+    if (x > rect.x + tolerance && x < rect.x + rect.width - tolerance && y > rect.y + tolerance && y < rect.y + rect.height - tolerance) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if two line segments intersect
+ */
+export function lineSegmentsIntersect(p1, p2, p3, p4) {
+  var d1 = direction(p3, p4, p1);
+  var d2 = direction(p3, p4, p2);
+  var d3 = direction(p1, p2, p3);
+  var d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return true;
+  }
+  if (d1 === 0 && onSegment(p3, p1, p4)) return true;
+  if (d2 === 0 && onSegment(p3, p2, p4)) return true;
+  if (d3 === 0 && onSegment(p1, p3, p2)) return true;
+  if (d4 === 0 && onSegment(p1, p4, p2)) return true;
+  return false;
+}
+
+/**
+ * Calculate direction of point p3 relative to line p1-p2
+ */
+function direction(p1, p2, p3) {
+  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+}
+
+/**
+ * Check if point p2 is on line segment p1-p3
+ */
+function onSegment(p1, p2, p3) {
+  return p2.x >= Math.min(p1.x, p3.x) && p2.x <= Math.max(p1.x, p3.x) && p2.y >= Math.min(p1.y, p3.y) && p2.y <= Math.max(p1.y, p3.y);
+}

package/esm/geometry/index.d.ts

@@ -1,4 +1,5 @@
 export { Point } from './Point';
 export { Rectangle } from './Rectangle';
 export { Line } from './Line';
+export { lineSegmentIntersectsRect, lineSegmentCrossesRect, lineSegmentsIntersect } from './collision';
 //# sourceMappingURL=index.d.ts.map

package/esm/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/esm/geometry/index.js

@@ -1,3 +1,4 @@
 export { Point } from "./Point";
 export { Rectangle } from "./Rectangle";
-export { Line } from "./Line";
+export { Line } from "./Line";
+export { lineSegmentIntersectsRect, lineSegmentCrossesRect, lineSegmentsIntersect } from "./collision";

package/esm/getManHattanPath.d.ts

@@ -1,3 +1,4 @@
+import { Position } from '@xyflow/react';
 import type { ManhattanRouterOptions, NodeLookup } from './options';
 /**
  * Parameters for getManHattanPath function
@@ -11,20 +12,12 @@ export interface GetManHattanPathParams {
      * Target node ID
      */
     targetNodeId: string;
-    /**
-     * Source anchor position (where the edge starts)
-     */
-    sourcePosition: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Target anchor position (where the edge ends)
-     */
-    targetPosition: {
-        x: number;
-        y: number;
-    };
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
     /**
      * ReactFlow node lookup map
      */

package/esm/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAOnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;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,CA4PvE"}
+{"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"}

package/esm/getManHattanPath.js

@@ -1,15 +1,20 @@
 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 _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 _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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _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; }
+import { getSmoothStepPath } from '@xyflow/react';
 import { Point, Rectangle } from "./geometry";
-import { resolveOptions } from "./options";
 import { ObstacleMap } from "./obstacle";
+import { resolveOptions } from "./options";
 import { findRoute } from "./pathfinder";
-import { pointsToPath, snapPathToGrid } from "./svg";
-import { getNodeDimensions, getNodePosition } from "./utils";
+import { pointsToPath, snapPathToGrid, parseSVGPath, simplifyPath } from "./svg";
+import { getNodeDimensions, getNodePosition, pathIntersectsObstacles } from "./utils";
 
 /**
  * Parameters for getManHattanPath function
@@ -17,10 +22,10 @@ import { getNodeDimensions, getNodePosition } from "./utils";
 
 /**
  * Generate Manhattan-routed path for ReactFlow edges
- * 
+ *
  * @param params - Path generation parameters
  * @returns SVG path string that can be used with ReactFlow's BaseEdge
- * 
+ *
  * @example
  * ```typescript
  * const path = getManHattanPath({
@@ -43,6 +48,10 @@ export function getManHattanPath(params) {
     sourcePosition = params.sourcePosition,
     targetPosition = params.targetPosition,
     nodeLookup = params.nodeLookup,
+    sourceX = params.sourceX,
+    sourceY = params.sourceY,
+    targetX = params.targetX,
+    targetY = params.targetY,
     _params$options = params.options,
     userOptions = _params$options === void 0 ? {} : _params$options;
 
@@ -55,8 +64,8 @@ export function getManHattanPath(params) {
   if (!sourceNode || !targetNode) {
     // Fallback to simple straight line if nodes not found
     console.warn('Source or target node not found in nodeLookup');
-    var start = new Point(sourcePosition.x, sourcePosition.y);
-    var end = new Point(targetPosition.x, targetPosition.y);
+    var start = new Point(sourceX, sourceY);
+    var end = new Point(targetX, targetY);
     return pointsToPath([start, end], options.precision);
   }
 
@@ -73,8 +82,31 @@ export function getManHattanPath(params) {
   var targetBBox = new Rectangle(targetPos.x, targetPos.y, targetDimensions.width, targetDimensions.height);
 
   // Create anchor points
-  var sourceAnchor = new Point(sourcePosition.x, sourcePosition.y);
-  var targetAnchor = new Point(targetPosition.x, targetPosition.y);
+  var sourceAnchor = new Point(sourceX, sourceY);
+  var targetAnchor = new Point(targetX, targetY);
+
+  // Try ReactFlow's getSmoothStepPath first
+  var _getSmoothStepPath = getSmoothStepPath({
+      sourceX: sourceX,
+      sourceY: sourceY,
+      targetX: targetX,
+      targetY: targetY,
+      sourcePosition: sourcePosition,
+      targetPosition: targetPosition,
+      borderRadius: options.borderRadius
+    }),
+    _getSmoothStepPath2 = _slicedToArray(_getSmoothStepPath, 1),
+    smoothStepPath = _getSmoothStepPath2[0];
+
+  // Parse the smooth step path to extract points
+  var smoothStepPoints = parseSVGPath(smoothStepPath);
+
+  // Check if smooth step path intersects with any obstacles
+  if (smoothStepPoints.length > 0 && !pathIntersectsObstacles(smoothStepPoints, nodeLookup, sourceNodeId, targetNodeId)) {
+    console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
+    return smoothStepPath;
+  }
+  console.log('[getManHattanPath] SmoothStepPath intersects obstacles, using Manhattan routing');
 
   // Build obstacle map with anchor information
   var obstacleMap = new ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
@@ -260,32 +292,4 @@ export function getManHattanPath(params) {
 
   // Convert to SVG path string
   return pointsToPath(finalRoute, options.precision, options.borderRadius);
-}
-
-/**
- * Simplify path by removing collinear intermediate points
- */
-function simplifyPath(points) {
-  if (points.length <= 2) {
-    return points;
-  }
-  var simplified = [points[0]];
-  for (var i = 1; i < points.length - 1; i++) {
-    var prev = simplified[simplified.length - 1];
-    var current = points[i];
-    var next = points[i + 1];
-
-    // Check if current point is collinear with prev and next
-    var isHorizontalLine = prev.y === current.y && current.y === next.y;
-    var isVerticalLine = prev.x === current.x && current.x === next.x;
-
-    // Only keep the point if it's not collinear (i.e., it's a corner)
-    if (!isHorizontalLine && !isVerticalLine) {
-      simplified.push(current);
-    }
-  }
-
-  // Always add the last point
-  simplified.push(points[points.length - 1]);
-  return simplified;
 }

package/esm/svg/index.d.ts

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

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

@@ -1 +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"}
+{"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/esm/svg/index.js

@@ -1 +1,2 @@
-export { pointsToPath, snapPathToGrid } from "./pathConverter";
+export { pointsToPath, snapPathToGrid } from "./pathConverter";
+export { parseSVGPath, simplifyPath } from "./pathParser";

package/esm/svg/pathParser.d.ts

@@ -0,0 +1,11 @@
+import { Point } from '../geometry';
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+export declare function parseSVGPath(pathString: string): Point[];
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+export declare function simplifyPath(points: Point[]): Point[];
+//# sourceMappingURL=pathParser.d.ts.map

package/esm/svg/pathParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA0CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}

package/esm/svg/pathParser.js

@@ -0,0 +1,81 @@
+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; }
+import { Point } from "../geometry";
+
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+export function parseSVGPath(pathString) {
+  var points = [];
+  var commands = pathString.match(/[MLQ][^MLQ]*/g);
+  if (!commands) return points;
+  var _iterator = _createForOfIteratorHelper(commands),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var command = _step.value;
+      var type = command[0];
+      var coords = command.slice(1).trim().split(/[\s,]+/).map(Number);
+      if (type === 'M' || type === 'L') {
+        // MoveTo or LineTo: x, y
+        if (coords.length >= 2) {
+          points.push(new Point(coords[0], coords[1]));
+        }
+      } else if (type === 'Q') {
+        // Quadratic Bezier: cx, cy, x, y
+        // We sample points along the curve for collision detection
+        if (coords.length >= 4) {
+          var prevPoint = points[points.length - 1];
+          if (prevPoint) {
+            var cx = coords[0];
+            var cy = coords[1];
+            var x = coords[2];
+            var y = coords[3];
+
+            // Sample 5 points along the bezier curve
+            for (var t = 0.2; t <= 1; t += 0.2) {
+              var bx = (1 - t) * (1 - t) * prevPoint.x + 2 * (1 - t) * t * cx + t * t * x;
+              var by = (1 - t) * (1 - t) * prevPoint.y + 2 * (1 - t) * t * cy + t * t * y;
+              points.push(new Point(bx, by));
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return points;
+}
+
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+export function simplifyPath(points) {
+  if (points.length <= 2) {
+    return points;
+  }
+  var simplified = [points[0]];
+  for (var i = 1; i < points.length - 1; i++) {
+    var prev = simplified[simplified.length - 1];
+    var current = points[i];
+    var next = points[i + 1];
+
+    // Check if current point is collinear with prev and next
+    var isHorizontalLine = prev.y === current.y && current.y === next.y;
+    var isVerticalLine = prev.x === current.x && current.x === next.x;
+
+    // Only keep the point if it's not collinear (i.e., it's a corner)
+    if (!isHorizontalLine && !isVerticalLine) {
+      simplified.push(current);
+    }
+  }
+
+  // Always add the last point
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}

package/esm/utils/index.d.ts

@@ -3,4 +3,5 @@ export * from './direction';
 export * from './rect';
 export * from './route';
 export * from './node';
+export * from './pathValidation';
 //# sourceMappingURL=index.d.ts.map

package/esm/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA"}

package/esm/utils/index.js

@@ -2,4 +2,5 @@ export * from "./grid";
 export * from "./direction";
 export * from "./rect";
 export * from "./route";
-export * from "./node";
+export * from "./node";
+export * from "./pathValidation";

package/esm/utils/pathValidation.d.ts

@@ -0,0 +1,7 @@
+import { Point } from '../geometry';
+import type { NodeLookup } from '../options';
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ */
+export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string): boolean;
+//# sourceMappingURL=pathValidation.d.ts.map

package/esm/utils/pathValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA8E5C;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,KAAK,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CA2BT"}

package/esm/utils/pathValidation.js

@@ -0,0 +1,109 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _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; }
+import { Rectangle } from "../geometry";
+import { lineSegmentIntersectsRect, lineSegmentCrossesRect } from "../geometry/collision";
+import { getNodeDimensions, getNodePosition } from "./node";
+
+/**
+ * Get node bounding box
+ */
+function getNodeBBox(nodeId, nodeLookup) {
+  var node = nodeLookup.get(nodeId);
+  if (!node) return null;
+  var dimensions = getNodeDimensions(node);
+  var position = getNodePosition(node);
+  return new Rectangle(position.x, position.y, dimensions.width, dimensions.height);
+}
+
+/**
+ * Check if a point is strictly inside a rectangle (not on edge)
+ */
+function isPointStrictlyInside(point, rect) {
+  var tolerance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  return point.x > rect.x + tolerance && point.x < rect.x + rect.width - tolerance && point.y > rect.y + tolerance && point.y < rect.y + rect.height - tolerance;
+}
+
+/**
+ * Check if a point intersects with a node
+ */
+function checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode) {
+  if (isTerminalNode) {
+    // For source/target nodes, only check if point is strictly inside (not on edge)
+    if (isPointStrictlyInside(point, nodeBBox)) {
+      console.log("[pathIntersectsObstacles] Point (".concat(point.x, ", ").concat(point.y, ") is inside terminal node ").concat(nodeId));
+      return true;
+    }
+  } else {
+    // For other nodes, check if point is inside or on edge
+    if (nodeBBox.containsPoint(point)) {
+      console.log("[pathIntersectsObstacles] Point (".concat(point.x, ", ").concat(point.y, ") intersects node ").concat(nodeId));
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a line segment intersects with a node
+ */
+function checkSegmentIntersection(p1, p2, nodeId, nodeBBox, isTerminalNode) {
+  if (isTerminalNode) {
+    // For source/target nodes, check if segment crosses through (not just touching edge)
+    if (lineSegmentCrossesRect(p1, p2, nodeBBox)) {
+      console.log("[pathIntersectsObstacles] Segment crosses terminal node ".concat(nodeId));
+      return true;
+    }
+  } else {
+    // For other nodes, check normal intersection
+    if (lineSegmentIntersectsRect(p1, p2, nodeBBox)) {
+      console.log("[pathIntersectsObstacles] Segment intersects node ".concat(nodeId));
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ */
+export function pathIntersectsObstacles(pathPoints, nodeLookup, sourceNodeId, targetNodeId) {
+  // Iterate through all nodes
+  var _iterator = _createForOfIteratorHelper(nodeLookup),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        nodeId = _step$value[0],
+        node = _step$value[1];
+      var nodeBBox = getNodeBBox(nodeId, nodeLookup);
+      if (!nodeBBox) continue;
+      var isTerminalNode = nodeId === sourceNodeId || nodeId === targetNodeId;
+
+      // Check each point
+      for (var i = 0; i < pathPoints.length; i++) {
+        var point = pathPoints[i];
+        if (checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode)) {
+          return true;
+        }
+
+        // Check line segment to next point
+        if (i < pathPoints.length - 1) {
+          var nextPoint = pathPoints[i + 1];
+          if (checkSegmentIntersection(point, nextPoint, nodeId, nodeBBox, isTerminalNode)) {
+            return true;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflow/manhattan",
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1-alpha.2",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",