@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/utils/grid.js

@@ -1,31 +1,36 @@
 import { Point } from "../geometry";
+import { GlobalGrid } from "./GlobalGrid";
 
 /**
  * Grid interface for dynamic grid system
  */
 
-/**
- * Get grid dimension for a single axis
- */
-function getGridDimension(diff, step) {
-  // Always return fixed step size to maintain consistent padding
-  // This ensures paths stay at least 'padding' distance from obstacles
-  return step;
-}
-
 /**
  * Get grid size in x and y dimensions, adapted to source and target positions
  * Uses global grid system with origin at (0, 0) for path alignment
+ *
+ * @param step - The grid step size
+ * @param source - Source point (used for reference, not as origin)
+ * @param target - Target point (used for reference, not as origin)
+ * @returns Grid configuration with global origin
  */
 export function getGrid(step, source, target) {
   return {
     source: new Point(0, 0),
     // Use global origin for consistent grid alignment
-    x: getGridDimension(target.x - source.x, step),
-    y: getGridDimension(target.y - source.y, step)
+    x: step,
+    y: step
   };
 }
 
+/**
+ * Create a GlobalGrid instance from step size
+ * This is the preferred way to create grids for new code
+ */
+export function createGlobalGrid(step) {
+  return GlobalGrid.uniform(step);
+}
+
 /**
  * Snap a value to grid
  */
@@ -34,9 +39,9 @@ export function snapToGrid(value, gridSize) {
 }
 
 /**
- * Snap a point to grid
+ * Snap a point to grid using global origin
  */
-function snapPointToGrid(point, grid) {
+export function snapPointToGrid(point, grid) {
   var source = grid.source;
   var x = snapToGrid(point.x - source.x, grid.x) + source.x;
   var y = snapToGrid(point.y - source.y, grid.y) + source.y;

package/esm/utils/heuristics.js

@@ -0,0 +1,144 @@
+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; }
+/**
+ * Heuristics - 启发式函数模块
+ *
+ * 提供多种启发式函数用于 A* 算法：
+ * - Manhattan: 曼哈顿距离（默认）
+ * - Euclidean: 欧几里得距离
+ * - Octile: 八方向距离
+ *
+ * Implements: Requirements 3.1
+ */
+
+/**
+ * 启发式函数类型
+ */
+
+/**
+ * 启发式函数配置
+ */
+
+/**
+ * 默认启发式配置
+ */
+export var DEFAULT_HEURISTIC_CONFIG = {
+  type: 'manhattan',
+  weight: 1.0
+};
+
+/**
+ * 计算曼哈顿距离
+ * 适用于只能水平或垂直移动的场景
+ */
+export function manhattanDistance(from, to) {
+  return Math.abs(from.x - to.x) + Math.abs(from.y - to.y);
+}
+
+/**
+ * 计算欧几里得距离
+ * 适用于可以任意方向移动的场景
+ */
+export function euclideanDistance(from, to) {
+  var dx = from.x - to.x;
+  var dy = from.y - to.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * 计算八方向距离（Octile/Chebyshev）
+ * 适用于可以对角移动的场景
+ */
+export function octileDistance(from, to) {
+  var dx = Math.abs(from.x - to.x);
+  var dy = Math.abs(from.y - to.y);
+  // D = 1, D2 = sqrt(2) ≈ 1.414
+  var D = 1;
+  var D2 = Math.SQRT2;
+  return D * (dx + dy) + (D2 - 2 * D) * Math.min(dx, dy);
+}
+
+/**
+ * 根据配置计算启发式值
+ */
+export function calculateHeuristic(from, to) {
+  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_HEURISTIC_CONFIG;
+  var distance;
+  switch (config.type) {
+    case 'euclidean':
+      distance = euclideanDistance(from, to);
+      break;
+    case 'octile':
+      distance = octileDistance(from, to);
+      break;
+    case 'manhattan':
+    default:
+      distance = manhattanDistance(from, to);
+      break;
+  }
+  return distance * config.weight;
+}
+
+/**
+ * 计算到多个目标点的最小启发式值
+ */
+export function calculateMinHeuristic(from, targets) {
+  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_HEURISTIC_CONFIG;
+  var min = Infinity;
+  var _iterator = _createForOfIteratorHelper(targets),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var target = _step.value;
+      var h = calculateHeuristic(from, target, config);
+      if (h < min) {
+        min = h;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return min;
+}
+
+/**
+ * 方向优先级计算
+ * 优先考虑与目标方向一致的移动
+ */
+export function calculateDirectionPriority(current, neighbor, target) {
+  var weight = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.1;
+  // 计算当前到邻居的方向
+  var moveX = neighbor.x - current.x;
+  var moveY = neighbor.y - current.y;
+
+  // 计算当前到目标的方向
+  var targetX = target.x - current.x;
+  var targetY = target.y - current.y;
+
+  // 如果移动方向与目标方向一致，给予奖励（负惩罚）
+  var bonus = 0;
+
+  // 水平方向一致
+  if (moveX > 0 && targetX > 0 || moveX < 0 && targetX < 0) {
+    bonus -= weight;
+  }
+
+  // 垂直方向一致
+  if (moveY > 0 && targetY > 0 || moveY < 0 && targetY < 0) {
+    bonus -= weight;
+  }
+  return bonus;
+}
+
+/**
+ * 创建启发式函数
+ */
+export function createHeuristicFunction() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_HEURISTIC_CONFIG;
+  return function (from, targets) {
+    return calculateMinHeuristic(from, targets, config);
+  };
+}

package/esm/utils/index.js

@@ -1,7 +1,13 @@
 export * from "./grid";
+export * from "./GlobalGrid";
 export * from "./direction";
 export * from "./rect";
 export * from "./route";
 export * from "./node";
 export * from "./pathValidation";
-export * from "./getAnchorPoints";
+export * from "./getAnchorPoints";
+export * from "./AdaptiveStepCalculator";
+export * from "./PerformanceMonitor";
+export * from "./ErrorRecovery";
+export * from "./heuristics";
+export * from "./pathProcessing";

package/esm/utils/pathProcessing.js

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

package/esm/utils/pathValidation.js

@@ -149,7 +149,6 @@ export function pathIntersectsObstacles(pathPoints, nodeLookup) {
 
       // 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;
       }
     }

package/esm/utils/rect.js

@@ -67,6 +67,13 @@ export function getRectPoints(anchor, bbox, directionList, grid, options) {
         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)
+        var extensionPoint = new Point(anchor.x + direction.x * grid.x, anchor.y + direction.y * grid.y);
+        var target = align(extensionPoint, grid, precision);
+        rectPoints.push(target);
+        continue;
       }
 
       // Create a line that is guaranteed to intersect the bbox if bbox
@@ -97,13 +104,13 @@ export function getRectPoints(anchor, bbox, directionList, grid, options) {
         _iterator2.f();
       }
       if (farthestIntersection) {
-        var target = align(farthestIntersection, grid, precision);
+        var _target = align(farthestIntersection, grid, precision);
 
         // If the rectPoint lies inside the bbox, offset it by one more step
-        if (bbox.containsPoint(target)) {
-          target = align(target.translate(direction.x * grid.x, direction.y * grid.y), grid, precision);
+        if (bbox.containsPoint(_target)) {
+          _target = align(_target.translate(direction.x * grid.x, direction.y * grid.y), grid, precision);
         }
-        rectPoints.push(target);
+        rectPoints.push(_target);
       }
     }
 

package/esm/utils/route.js

@@ -52,7 +52,13 @@ export function reconstructRoute(parents, points, tailPoint, startPoint, endPoin
   var currentKey = getKey(tailPoint);
   var parent = parents.get(currentKey);
   var point;
-  while (parent) {
+  var iterationCount = 0;
+  var maxIterations = 10000; // Safety limit
+
+  while (parent && iterationCount < maxIterations) {
+    iterationCount++;
+    if (iterationCount % 100 === 0) {}
+
     // point is assumed to be aligned already
     point = points.get(currentKey);
     if (point) {
@@ -64,9 +70,19 @@ export function reconstructRoute(parents, points, tailPoint, startPoint, endPoin
     }
 
     // parent is assumed to be aligned already
-    currentKey = getKey(parent);
+    var nextKey = getKey(parent);
+
+    // CRITICAL: Check for circular reference
+    if (nextKey === currentKey) {
+      console.error('[reconstructRoute] CIRCULAR REFERENCE DETECTED! currentKey === nextKey:', currentKey);
+      break;
+    }
+    currentKey = nextKey;
     parent = parents.get(currentKey);
   }
+  if (iterationCount >= maxIterations) {
+    console.error('[reconstructRoute] MAX ITERATIONS REACHED! Possible infinite loop.');
+  }
 
   // leadPoint is assumed to be aligned already
   var leadPoint = points.get(currentKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflow/manhattan",
-  "version": "0.0.2-alpha.8",
+  "version": "0.0.2",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",
@@ -34,10 +34,18 @@
     "cjs"
   ],
   "scripts": {
-    "build": "father build"
+    "build": "father build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "peerDependencies": {
     "@xyflow/react": ">=12.8.6"
   },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.0",
+    "fast-check": "^3.22.0",
+    "vitest": "^2.1.0"
+  },
   "gitHead": "dcdc06b5032aac044fa2094877d28c509c30d9eb"
 }

package/cjs/geometry/Line.d.ts

@@ -1,21 +0,0 @@
-import { Point } from './Point';
-import { Rectangle } from './Rectangle';
-/**
- * Line class representing a line segment
- */
-export declare class Line {
-    start: Point;
-    end: Point;
-    constructor(start: Point, end: Point);
-    /**
-     * Calculate intersection points with a rectangle
-     * Returns an array of intersection points
-     */
-    intersect(rect: Rectangle): Point[];
-    /**
-     * Calculate intersection point between two line segments
-     * Returns null if lines don't intersect
-     */
-    private lineIntersection;
-}
-//# sourceMappingURL=Line.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Line.d.ts","sourceRoot":"","sources":["../../src/geometry/Line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;GAEG;AACH,qBAAa,IAAI;IACf,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,KAAK,CAAA;gBAEE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK;IAKpC;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,EAAE;IA+BnC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CA+BzB"}