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

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

@@ -1 +1 @@
-{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AA2BD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAWD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}

package/esm/utils/grid.js

@@ -8,23 +8,9 @@ import { Point } from "../geometry";
  * Get grid dimension for a single axis
  */
 function getGridDimension(diff, step) {
-  // Return step if diff = 0
-  if (!diff) {
-    return step;
-  }
-  var abs = Math.abs(diff);
-  var count = Math.round(abs / step);
-
-  // Return abs if less than one step apart
-  if (!count) {
-    return abs;
-  }
-
-  // Otherwise, return corrected step
-  var roundedDiff = count * step;
-  var remainder = abs - roundedDiff;
-  var correction = remainder / count;
-  return step + correction;
+  // Always return fixed step size to maintain consistent padding
+  // This ensures paths stay at least 'padding' distance from obstacles
+  return step;
 }
 
 /**

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,11 @@
+import { Point } from '../geometry';
+import type { NodeLookup } from '../options';
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
+ */
+export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup): 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;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAyF5C;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAoC5F"}

package/esm/utils/pathValidation.js

@@ -0,0 +1,162 @@
+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 { Point, Rectangle } from "../geometry";
+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);
+}
+
+/**
+ * Find unique intersection points between a line segment and a rectangle
+ * Returns array of intersection points (deduplicated)
+ */
+function findSegmentRectIntersections(p1, p2, rect) {
+  var intersections = [];
+  var tolerance = 0.01;
+
+  // Define rectangle edges
+  var edges = [{
+    start: new Point(rect.x, rect.y),
+    end: new Point(rect.x + rect.width, rect.y)
+  },
+  // Top
+  {
+    start: new Point(rect.x + rect.width, rect.y),
+    end: new Point(rect.x + rect.width, rect.y + rect.height)
+  },
+  // Right
+  {
+    start: new Point(rect.x + rect.width, rect.y + rect.height),
+    end: new Point(rect.x, rect.y + rect.height)
+  },
+  // Bottom
+  {
+    start: new Point(rect.x, rect.y + rect.height),
+    end: new Point(rect.x, rect.y)
+  } // Left
+  ];
+
+  // Find intersection point with each edge
+  var _loop = function _loop() {
+    var edge = _edges[_i];
+    var intersection = getLineSegmentIntersection(p1, p2, edge.start, edge.end);
+    if (intersection) {
+      // Check if this point is already in the list (avoid duplicates at corners)
+      var isDuplicate = intersections.some(function (existing) {
+        return Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance;
+      });
+      if (!isDuplicate) {
+        intersections.push(intersection);
+      }
+    }
+  };
+  for (var _i = 0, _edges = edges; _i < _edges.length; _i++) {
+    _loop();
+  }
+  return intersections;
+}
+
+/**
+ * Get intersection point between two line segments (if exists)
+ */
+function getLineSegmentIntersection(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)) {
+    // Lines intersect, calculate intersection point
+    var t = ((p3.x - p1.x) * (p3.y - p4.y) - (p3.y - p1.y) * (p3.x - p4.x)) / ((p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x));
+    return new Point(p1.x + t * (p2.x - p1.x), p1.y + t * (p2.y - p1.y));
+  }
+
+  // Check collinear cases
+  if (d1 === 0 && onSegment(p3, p1, p4)) return p1.clone();
+  if (d2 === 0 && onSegment(p3, p2, p4)) return p2.clone();
+  if (d3 === 0 && onSegment(p1, p3, p2)) return p3.clone();
+  if (d4 === 0 && onSegment(p1, p4, p2)) return p4.clone();
+  return null;
+}
+function direction(p1, p2, p3) {
+  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+}
+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);
+}
+
+/**
+ * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
+ */
+export function pathIntersectsObstacles(pathPoints, nodeLookup) {
+  var tolerance = 0.01;
+
+  // Iterate through all nodes (including source and target)
+  var _iterator = _createForOfIteratorHelper(nodeLookup),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 1),
+        nodeId = _step$value[0];
+      var nodeBBox = getNodeBBox(nodeId, nodeLookup);
+      if (!nodeBBox) continue;
+      var allIntersections = [];
+
+      // Collect all unique intersection points for this node
+      for (var i = 0; i < pathPoints.length - 1; i++) {
+        var p1 = pathPoints[i];
+        var p2 = pathPoints[i + 1];
+        var segmentIntersections = findSegmentRectIntersections(p1, p2, nodeBBox);
+
+        // Add to global list, avoiding duplicates
+        var _iterator2 = _createForOfIteratorHelper(segmentIntersections),
+          _step2;
+        try {
+          var _loop2 = function _loop2() {
+            var intersection = _step2.value;
+            var isDuplicate = allIntersections.some(function (existing) {
+              return Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance;
+            });
+            if (!isDuplicate) {
+              allIntersections.push(intersection);
+            }
+          };
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            _loop2();
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+
+      // If path has 2 or more unique intersections with this node, it crosses through it
+      if (allIntersections.length >= 2) {
+        console.log("[pathIntersectsObstacles] Path crosses node ".concat(nodeId, " with ").concat(allIntersections.length, " intersections"));
+        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.10",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",