@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/utils/node.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeDimensions = getNodeDimensions;
+exports.getNodePosition = getNodePosition;
+/**
+ * Node dimensions interface
+ */
+
+/**
+ * Get node dimensions following ReactFlow's internal logic
+ * Priority: measured > direct property > initialWidth/Height > 0
+ * 
+ * @param node - ReactFlow internal node
+ * @returns Node dimensions with width and height
+ */
+function getNodeDimensions(node) {
+  const width = node.measured?.width ?? node.width ?? node.initialWidth ?? 0;
+  const height = node.measured?.height ?? node.height ?? node.initialHeight ?? 0;
+  return {
+    width,
+    height
+  };
+}
+
+/**
+ * Get node absolute position from internals
+ * 
+ * @param node - ReactFlow internal node
+ * @returns Absolute position { x, y }
+ */
+function getNodePosition(node) {
+  return node.internals.positionAbsolute;
+}

package/cjs/utils/pathProcessing.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Path Processing Utilities
+ *
+ * 提供路径后处理功能，包括：
+ * - 移除冗余扩展点
+ * - 插入扩展点
+ * - 优化锯齿模式
+ *
+ * Implements: Requirements 5.3
+ */
+import { Point, Rectangle } from '../geometry';
+import type { ResolvedOptions } from '../options';
+/**
+ * 检测锚点在边界框的哪条边上
+ */
+export declare function detectAnchorEdge(anchor: Point, bbox: Rectangle, tolerance?: number): 'left' | 'right' | 'top' | 'bottom' | null;
+/**
+ * 移除路径起点的扩展点
+ */
+export declare function removeSourceExtensionPoint(route: Point[], sourceAnchor: Point, sourceBBox: Rectangle, step: number, tolerance?: number): Point[];
+/**
+ * 移除路径终点的扩展点
+ */
+export declare function removeTargetExtensionPoint(route: Point[], targetAnchor: Point, targetBBox: Rectangle, step: number, tolerance?: number): Point[];
+/**
+ * 在源点插入扩展点
+ */
+export declare function insertSourceExtension(route: Point[], sourceAnchor: Point, sourceBBox: Rectangle, extensionDistance: number, tolerance?: number): Point[];
+/**
+ * 在目标点插入扩展点
+ */
+export declare function insertTargetExtension(route: Point[], targetAnchor: Point, targetBBox: Rectangle, extensionDistance: number, tolerance?: number): Point[];
+/**
+ * 检测并移除锯齿模式
+ */
+export declare function removeZigzagPatterns(route: Point[], targetBBox: Rectangle, tolerance?: number): Point[];
+/**
+ * 移除冗余点
+ */
+export declare function removeRedundantPoints(route: Point[], anchor: Point, tolerance?: number): Point[];
+/**
+ * 完整的路径后处理流程
+ */
+export declare function processRoute(route: Point[], sourceAnchor: Point, targetAnchor: Point, sourceBBox: Rectangle, targetBBox: Rectangle, options: ResolvedOptions): Point[];
+//# sourceMappingURL=pathProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathProcessing.d.ts","sourceRoot":"","sources":["../../src/utils/pathProcessing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,KAAK,EACb,IAAI,EAAE,SAAS,EACf,SAAS,GAAE,MAAU,GACpB,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,CAM5C;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,KAAK,EAAE,EACd,YAAY,EAAE,KAAK,EACnB,UAAU,EAAE,SAAS,EACrB,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CAoBT;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,KAAK,EAAE,EACd,YAAY,EAAE,KAAK,EACnB,UAAU,EAAE,SAAS,EACrB,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CAoBT;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EAAE,EACd,YAAY,EAAE,KAAK,EACnB,UAAU,EAAE,SAAS,EACrB,iBAAiB,EAAE,MAAM,EACzB,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CA6CT;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EAAE,EACd,YAAY,EAAE,KAAK,EACnB,UAAU,EAAE,SAAS,EACrB,iBAAiB,EAAE,MAAM,EACzB,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CA6CT;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EAAE,EACd,UAAU,EAAE,SAAS,EACrB,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CA2BT;AAmCD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EAAE,EACd,MAAM,EAAE,KAAK,EACb,SAAS,GAAE,MAAU,GACpB,KAAK,EAAE,CA2BT;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,KAAK,EAAE,EACd,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,CA2ET"}

package/cjs/utils/pathProcessing.js

@@ -0,0 +1,270 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectAnchorEdge = detectAnchorEdge;
+exports.insertSourceExtension = insertSourceExtension;
+exports.insertTargetExtension = insertTargetExtension;
+exports.processRoute = processRoute;
+exports.removeRedundantPoints = removeRedundantPoints;
+exports.removeSourceExtensionPoint = removeSourceExtensionPoint;
+exports.removeTargetExtensionPoint = removeTargetExtensionPoint;
+exports.removeZigzagPatterns = removeZigzagPatterns;
+var _geometry = require("../geometry");
+/**
+ * Path Processing Utilities
+ *
+ * 提供路径后处理功能，包括：
+ * - 移除冗余扩展点
+ * - 插入扩展点
+ * - 优化锯齿模式
+ *
+ * Implements: Requirements 5.3
+ */
+
+/**
+ * 检测锚点在边界框的哪条边上
+ */
+function detectAnchorEdge(anchor, bbox, tolerance = 1) {
+  if (Math.abs(anchor.x - bbox.x) < tolerance) return 'left';
+  if (Math.abs(anchor.x - (bbox.x + bbox.width)) < tolerance) return 'right';
+  if (Math.abs(anchor.y - bbox.y) < tolerance) return 'top';
+  if (Math.abs(anchor.y - (bbox.y + bbox.height)) < tolerance) return 'bottom';
+  return null;
+}
+
+/**
+ * 移除路径起点的扩展点
+ */
+function removeSourceExtensionPoint(route, sourceAnchor, sourceBBox, step, tolerance = 1) {
+  if (route.length === 0) return route;
+  const firstPoint = route[0];
+  const edge = detectAnchorEdge(sourceAnchor, sourceBBox, tolerance);
+  const distToFirst = sourceAnchor.manhattanDistance(firstPoint);
+  if (distToFirst >= step * 2) return route;
+  const shouldRemove = edge === 'right' && firstPoint.x > sourceAnchor.x || edge === 'left' && firstPoint.x < sourceAnchor.x || edge === 'bottom' && firstPoint.y > sourceAnchor.y || edge === 'top' && firstPoint.y < sourceAnchor.y;
+  if (shouldRemove) {
+    return route.slice(1);
+  }
+  return route;
+}
+
+/**
+ * 移除路径终点的扩展点
+ */
+function removeTargetExtensionPoint(route, targetAnchor, targetBBox, step, tolerance = 1) {
+  if (route.length === 0) return route;
+  const lastPoint = route[route.length - 1];
+  const edge = detectAnchorEdge(targetAnchor, targetBBox, tolerance);
+  const distToLast = targetAnchor.manhattanDistance(lastPoint);
+  if (distToLast >= step * 2) return route;
+  const shouldRemove = edge === 'left' && lastPoint.x < targetAnchor.x || edge === 'right' && lastPoint.x > targetAnchor.x || edge === 'top' && lastPoint.y < targetAnchor.y || edge === 'bottom' && lastPoint.y > targetAnchor.y;
+  if (shouldRemove) {
+    return route.slice(0, -1);
+  }
+  return route;
+}
+
+/**
+ * 在源点插入扩展点
+ */
+function insertSourceExtension(route, sourceAnchor, sourceBBox, extensionDistance, tolerance = 1) {
+  if (route.length === 0) return route;
+  const result = [...route];
+  const firstPoint = result[0];
+  const edge = detectAnchorEdge(sourceAnchor, sourceBBox, tolerance);
+  if (!edge) return result;
+  let extensionPoint;
+  let cornerPoint = null;
+  switch (edge) {
+    case 'right':
+      extensionPoint = new _geometry.Point(sourceAnchor.x + extensionDistance, sourceAnchor.y);
+      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
+        cornerPoint = new _geometry.Point(extensionPoint.x, firstPoint.y);
+      }
+      break;
+    case 'left':
+      extensionPoint = new _geometry.Point(sourceAnchor.x - extensionDistance, sourceAnchor.y);
+      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
+        cornerPoint = new _geometry.Point(extensionPoint.x, firstPoint.y);
+      }
+      break;
+    case 'bottom':
+      extensionPoint = new _geometry.Point(sourceAnchor.x, sourceAnchor.y + extensionDistance);
+      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
+        cornerPoint = new _geometry.Point(firstPoint.x, extensionPoint.y);
+      }
+      break;
+    case 'top':
+      extensionPoint = new _geometry.Point(sourceAnchor.x, sourceAnchor.y - extensionDistance);
+      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
+        cornerPoint = new _geometry.Point(firstPoint.x, extensionPoint.y);
+      }
+      break;
+  }
+  if (cornerPoint) {
+    result.unshift(cornerPoint);
+  }
+  result.unshift(extensionPoint);
+  return result;
+}
+
+/**
+ * 在目标点插入扩展点
+ */
+function insertTargetExtension(route, targetAnchor, targetBBox, extensionDistance, tolerance = 1) {
+  if (route.length === 0) return route;
+  const result = [...route];
+  const lastPoint = result[result.length - 1];
+  const edge = detectAnchorEdge(targetAnchor, targetBBox, tolerance);
+  if (!edge) return result;
+  let extensionPoint;
+  let cornerPoint = null;
+  switch (edge) {
+    case 'left':
+      extensionPoint = new _geometry.Point(targetAnchor.x - extensionDistance, targetAnchor.y);
+      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
+        cornerPoint = new _geometry.Point(extensionPoint.x, lastPoint.y);
+      }
+      break;
+    case 'right':
+      extensionPoint = new _geometry.Point(targetAnchor.x + extensionDistance, targetAnchor.y);
+      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
+        cornerPoint = new _geometry.Point(extensionPoint.x, lastPoint.y);
+      }
+      break;
+    case 'top':
+      extensionPoint = new _geometry.Point(targetAnchor.x, targetAnchor.y - extensionDistance);
+      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
+        cornerPoint = new _geometry.Point(lastPoint.x, extensionPoint.y);
+      }
+      break;
+    case 'bottom':
+      extensionPoint = new _geometry.Point(targetAnchor.x, targetAnchor.y + extensionDistance);
+      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
+        cornerPoint = new _geometry.Point(lastPoint.x, extensionPoint.y);
+      }
+      break;
+  }
+  if (cornerPoint) {
+    result.push(cornerPoint);
+  }
+  result.push(extensionPoint);
+  return result;
+}
+
+/**
+ * 检测并移除锯齿模式
+ */
+function removeZigzagPatterns(route, targetBBox, tolerance = 1) {
+  if (route.length < 3) return route;
+  const result = [...route];
+  let i = 0;
+  while (i < result.length - 2) {
+    const p1 = result[i];
+    const p2 = result[i + 1];
+    const p3 = result[i + 2];
+
+    // 检查 p2 是否在目标边界框边缘
+    const p2OnEdge = isPointOnBBoxEdge(p2, targetBBox, tolerance);
+    if (p2OnEdge) {
+      const isZigzag = isZigzagPattern(p1, p2, p3, tolerance);
+      if (isZigzag) {
+        result.splice(i + 1, 2);
+        continue;
+      }
+    }
+    i++;
+  }
+  return result;
+}
+
+/**
+ * 检查点是否在边界框边缘
+ */
+function isPointOnBBoxEdge(point, bbox, tolerance) {
+  return Math.abs(point.x - bbox.x) < tolerance || Math.abs(point.x - (bbox.x + bbox.width)) < tolerance || Math.abs(point.y - bbox.y) < tolerance || Math.abs(point.y - (bbox.y + bbox.height)) < tolerance;
+}
+
+/**
+ * 检查三个点是否形成锯齿模式
+ */
+function isZigzagPattern(p1, p2, p3, tolerance) {
+  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;
+  return p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal;
+}
+
+/**
+ * 移除冗余点
+ */
+function removeRedundantPoints(route, anchor, tolerance = 1) {
+  if (route.length <= 3) return route;
+  const result = [...route];
+
+  // 检查第三个点是否冗余
+  const thirdPoint = result[2];
+  const sameX = Math.abs(thirdPoint.x - anchor.x) < tolerance;
+  const sameY = Math.abs(thirdPoint.y - anchor.y) < tolerance;
+  if ((sameX || sameY) && result.length > 3) {
+    const secondPoint = result[1];
+    const fourthPoint = result[3];
+    const cornerToThird = Math.abs(secondPoint.x - thirdPoint.x) < tolerance || Math.abs(secondPoint.y - thirdPoint.y) < tolerance;
+    const thirdToFourth = Math.abs(thirdPoint.x - fourthPoint.x) < tolerance || Math.abs(thirdPoint.y - fourthPoint.y) < tolerance;
+    if (cornerToThird && thirdToFourth) {
+      result.splice(2, 1);
+    }
+  }
+  return result;
+}
+
+/**
+ * 完整的路径后处理流程
+ */
+function processRoute(route, sourceAnchor, targetAnchor, sourceBBox, targetBBox, options) {
+  const tolerance = 1;
+  let processed = [...route];
+
+  // 1. 移除源点扩展点
+  processed = removeSourceExtensionPoint(processed, sourceAnchor, sourceBBox, options.step, tolerance);
+
+  // 2. 移除目标点扩展点
+  processed = removeTargetExtensionPoint(processed, targetAnchor, targetBBox, options.step, tolerance);
+
+  // 3. 插入源点扩展点
+  processed = insertSourceExtension(processed, sourceAnchor, sourceBBox, options.extensionDistance, tolerance);
+
+  // 4. 移除源点冗余点
+  processed = removeRedundantPoints(processed, sourceAnchor, tolerance);
+
+  // 5. 移除锯齿模式
+  const targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
+  processed = removeZigzagPatterns(processed, targetBBoxWithPadding, tolerance);
+
+  // 6. 插入目标点扩展点
+  processed = insertTargetExtension(processed, targetAnchor, targetBBox, options.extensionDistance, tolerance);
+
+  // 7. 移除目标点冗余点（从末尾）
+  if (processed.length > 3) {
+    const lastIdx = processed.length - 1;
+    const thirdLastPoint = processed[lastIdx - 2];
+    const sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    const sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if ((sameX || sameY) && processed.length > 3) {
+      const secondLastPoint = processed[lastIdx - 1];
+      const fourthLastPoint = processed[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) {
+        processed.splice(lastIdx - 2, 1);
+      }
+    }
+  }
+
+  // 8. 再次移除锯齿模式
+  processed = removeZigzagPatterns(processed, targetBBox, tolerance);
+  return processed;
+}

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

package/cjs/utils/pathValidation.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathIntersectsObstacles = pathIntersectsObstacles;
+var _geometry = require("../geometry");
+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);
+}
+
+/**
+ * Find unique intersection points between a line segment and a rectangle
+ * Returns array of intersection points (deduplicated)
+ */
+function findSegmentRectIntersections(p1, p2, rect) {
+  const intersections = [];
+  const tolerance = 0.01;
+
+  // Define rectangle edges
+  const edges = [{
+    start: new _geometry.Point(rect.x, rect.y),
+    end: new _geometry.Point(rect.x + rect.width, rect.y)
+  },
+  // Top
+  {
+    start: new _geometry.Point(rect.x + rect.width, rect.y),
+    end: new _geometry.Point(rect.x + rect.width, rect.y + rect.height)
+  },
+  // Right
+  {
+    start: new _geometry.Point(rect.x + rect.width, rect.y + rect.height),
+    end: new _geometry.Point(rect.x, rect.y + rect.height)
+  },
+  // Bottom
+  {
+    start: new _geometry.Point(rect.x, rect.y + rect.height),
+    end: new _geometry.Point(rect.x, rect.y)
+  } // Left
+  ];
+
+  // Find intersection point with each edge
+  for (const edge of edges) {
+    const intersection = getLineSegmentIntersection(p1, p2, edge.start, edge.end);
+    if (intersection) {
+      // Check if this point is already in the list (avoid duplicates at corners)
+      const isDuplicate = intersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
+      if (!isDuplicate) {
+        intersections.push(intersection);
+      }
+    }
+  }
+  return intersections;
+}
+
+/**
+ * Get intersection point between two line segments (if exists)
+ */
+function getLineSegmentIntersection(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)) {
+    // Lines intersect, calculate intersection point
+    const 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 _geometry.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
+ */
+function pathIntersectsObstacles(pathPoints, nodeLookup) {
+  const tolerance = 0.01;
+
+  // Iterate through all nodes (including source and target)
+  for (const [nodeId] of nodeLookup) {
+    const nodeBBox = getNodeBBox(nodeId, nodeLookup);
+    if (!nodeBBox) continue;
+    const allIntersections = [];
+
+    // Collect all unique intersection points for this node
+    for (let i = 0; i < pathPoints.length - 1; i++) {
+      const p1 = pathPoints[i];
+      const p2 = pathPoints[i + 1];
+      const segmentIntersections = findSegmentRectIntersections(p1, p2, nodeBBox);
+
+      // Add to global list, avoiding duplicates
+      for (const intersection of segmentIntersections) {
+        const isDuplicate = allIntersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
+        if (!isDuplicate) {
+          allIntersections.push(intersection);
+        }
+      }
+    }
+
+    // If path has 2 or more unique intersections with this node, it crosses through it
+    if (allIntersections.length >= 2) {
+      return true;
+    }
+  }
+  return false;
+}

package/cjs/utils/rect.d.ts

@@ -0,0 +1,9 @@
+import { Point, Rectangle } from '../geometry';
+import type { ResolvedOptions, Direction } from '../options';
+import type { Grid } from './grid';
+/**
+ * Get points around a rectangle taking given directions into account
+ * Lines are drawn from anchor in given directions, intersections recorded
+ */
+export declare function getRectPoints(anchor: Point, bbox: Rectangle, directionList: Direction[], grid: Grid, options: ResolvedOptions): Point[];
+//# sourceMappingURL=rect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../src/utils/rect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAQ,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AA6ClC;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EACb,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,SAAS,EAAE,EAC1B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,CAgFT"}

package/cjs/utils/rect.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRectPoints = getRectPoints;
+var _geometry = require("../geometry");
+var _grid = require("./grid");
+/**
+ * Check if a point is on the edge of a rectangle
+ */
+function isPointOnRectangleEdge(point, bbox, tolerance = 0.01) {
+  const onLeft = Math.abs(point.x - bbox.x) < tolerance;
+  const onRight = Math.abs(point.x - (bbox.x + bbox.width)) < tolerance;
+  const onTop = Math.abs(point.y - bbox.y) < tolerance;
+  const onBottom = Math.abs(point.y - (bbox.y + bbox.height)) < tolerance;
+  const withinVerticalBounds = point.y >= bbox.y - tolerance && point.y <= bbox.y + bbox.height + tolerance;
+  const withinHorizontalBounds = point.x >= bbox.x - tolerance && point.x <= bbox.x + bbox.width + tolerance;
+  return (onLeft || onRight) && withinVerticalBounds || (onTop || onBottom) && withinHorizontalBounds;
+}
+
+/**
+ * Check if a direction points outward from the rectangle edge where the anchor is located
+ */
+function isDirectionOutward(anchor, bbox, direction, tolerance = 0.01) {
+  const onLeft = Math.abs(anchor.x - bbox.x) < tolerance;
+  const onRight = Math.abs(anchor.x - (bbox.x + bbox.width)) < tolerance;
+  const onTop = Math.abs(anchor.y - bbox.y) < tolerance;
+  const onBottom = Math.abs(anchor.y - (bbox.y + bbox.height)) < tolerance;
+
+  // Only allow outward directions from the edge
+  if (onLeft && direction.x < 0) return true;
+  if (onRight && direction.x > 0) return true;
+  if (onTop && direction.y < 0) return true;
+  if (onBottom && direction.y > 0) return true;
+
+  // For corners, allow both perpendicular directions
+  if ((onLeft || onRight) && direction.x === 0) return true;
+  if ((onTop || onBottom) && direction.y === 0) return true;
+  return false;
+}
+
+/**
+ * Get points around a rectangle taking given directions into account
+ * Lines are drawn from anchor in given directions, intersections recorded
+ */
+function getRectPoints(anchor, bbox, directionList, grid, options) {
+  const precision = options.precision;
+  const directionMap = options.directionMap;
+  const centerVector = anchor.diff(bbox.getCenter());
+  const rectPoints = [];
+
+  // Check if anchor is on the edge of the bbox
+  const isOnEdge = isPointOnRectangleEdge(anchor, bbox);
+
+  // Check each allowed direction
+  for (const key of directionList) {
+    const direction = directionMap[key];
+
+    // If anchor is on edge, only consider outward directions
+    if (isOnEdge) {
+      const isOutward = isDirectionOutward(anchor, bbox, direction);
+      if (!isOutward) {
+        continue; // Skip inward directions
+      }
+
+      // When anchor is on edge and direction is outward, create extension point directly
+      // instead of trying to find intersection (which won't exist for outward directions)
+      const extensionPoint = new _geometry.Point(anchor.x + direction.x * grid.x, anchor.y + direction.y * grid.y);
+      const target = (0, _grid.align)(extensionPoint, grid, precision);
+      rectPoints.push(target);
+      continue;
+    }
+
+    // Create a line that is guaranteed to intersect the bbox if bbox
+    // is in the direction even if anchor lies outside of bbox
+    const ending = new _geometry.Point(anchor.x + direction.x * (Math.abs(centerVector.x) + bbox.width), anchor.y + direction.y * (Math.abs(centerVector.y) + bbox.height));
+    const intersectionLine = new _geometry.Line(anchor, ending);
+
+    // Get the farther intersection, in case there are two
+    const intersections = intersectionLine.intersect(bbox);
+    let farthestIntersectionDistance;
+    let farthestIntersection = null;
+    for (const intersection of intersections) {
+      const distance = anchor.squaredDistance(intersection);
+      if (farthestIntersectionDistance === undefined || distance > farthestIntersectionDistance) {
+        farthestIntersectionDistance = distance;
+        farthestIntersection = intersection;
+      }
+    }
+
+    // If an intersection was found in this direction, it is our rectPoint
+    if (farthestIntersection) {
+      let target = (0, _grid.align)(farthestIntersection, grid, precision);
+
+      // If the rectPoint lies inside the bbox, offset it by one more step
+      if (bbox.containsPoint(target)) {
+        target = (0, _grid.align)(target.translate(direction.x * grid.x, direction.y * grid.y), grid, precision);
+      }
+      rectPoints.push(target);
+    }
+  }
+
+  // If anchor lies outside of bbox, add it to the array of points
+  // If anchor is on edge, don't add it - force path to start from extended points
+  if (!bbox.containsPoint(anchor) && !isOnEdge) {
+    rectPoints.push((0, _grid.align)(anchor, grid, precision));
+  }
+  return rectPoints;
+}

package/cjs/utils/route.d.ts

@@ -0,0 +1,19 @@
+import { Point } from '../geometry';
+/**
+ * Normalize a point to a unit direction vector
+ */
+export declare function normalizePoint(point: Point): Point;
+/**
+ * Get string key for a point
+ */
+export declare function getKey(point: Point): string;
+/**
+ * Calculate minimum Manhattan distance from a point to multiple anchors
+ */
+export declare function getCost(from: Point, anchors: Point[]): number;
+/**
+ * Reconstruct route by concatenating points with their parents
+ * Removes redundant points in the same direction
+ */
+export declare function reconstructRoute(parents: Map<string, Point>, points: Map<string, Point>, tailPoint: Point, startPoint: Point, endPoint: Point): Point[];
+//# sourceMappingURL=route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/utils/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAKlD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,MAAM,CAW7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC1B,SAAS,EAAE,KAAK,EAChB,UAAU,EAAE,KAAK,EACjB,QAAQ,EAAE,KAAK,GACd,KAAK,EAAE,CA6DT"}