@rxflow/manhattan 0.0.2-alpha.7 → 0.0.2

package/README.md

@@ -2,33 +2,237 @@
 
 Manhattan 路由算法，用于 ReactFlow 生成正交路径，支持障碍物避让。
 
+## 特性
+
+- **A* 寻路算法** - 高效的路径搜索，支持早期终止优化
+- **正交路径生成** - 生成符合 Manhattan 风格的直角路径
+- **障碍物避让** - 自动绕过节点障碍物
+- **四叉树优化** - 使用 QuadTree 加速空间查询
+- **自适应步长** - 根据节点密度和距离自动调整网格步长
+- **路径缓存** - LRU 缓存机制提升重复查询性能
+- **全局网格对齐** - 确保所有路径点对齐到全局网格
+- **圆角支持** - 可配置的路径转角圆角半径
+- **性能监控** - 内置性能指标收集和日志
+
 ## 安装
 
 ```bash
 npm install @rxflow/manhattan
 # or
 pnpm add @rxflow/manhattan
+yarn add @rxflow/manhattan
 ```
 
-## 使用
+## 基本使用
 
 ```tsx
 import { getManHattanPath } from '@rxflow/manhattan';
+import { useReactFlow } from '@xyflow/react';
+
+function CustomEdge({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, source, target }) {
+  const { getNodes } = useReactFlow();
+  const nodeLookup = new Map(getNodes().map(n => [n.id, n]));
+
+  const path = getManHattanPath({
+    sourceNodeId: source,
+    targetNodeId: target,
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition,
+    nodeLookup,
+    options: {
+      step: 10,
+      borderRadius: 5,
+    }
+  });
+
+  return <path d={path} />;
+}
+```
+
+## API
+
+### getManHattanPath(params)
+
+生成 Manhattan 风格的 SVG 路径字符串。
+
+#### 参数
+
+| 参数 | 类型 | 必填 | 描述 |
+|------|------|------|------|
+| sourceNodeId | string | ✓ | 源节点 ID |
+| targetNodeId | string | ✓ | 目标节点 ID |
+| sourceX | number | ✓ | 源锚点 X 坐标 |
+| sourceY | number | ✓ | 源锚点 Y 坐标 |
+| targetX | number | ✓ | 目标锚点 X 坐标 |
+| targetY | number | ✓ | 目标锚点 Y 坐标 |
+| sourcePosition | Position | ✓ | 源锚点位置 (top/right/bottom/left) |
+| targetPosition | Position | ✓ | 目标锚点位置 |
+| nodeLookup | NodeLookup | ✓ | ReactFlow 节点查找 Map |
+| options | ManhattanRouterOptions | - | 路由配置选项 |
+
+#### 返回值
+
+返回 SVG 路径字符串，可直接用于 `<path d={...} />` 元素。
 
+### ManhattanRouterOptions
+
+| 选项 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| step | number | 10 | 网格步长（像素） |
+| maxLoopCount | number | 2000 | 最大迭代次数 |
+| precision | number | 1 | 坐标精度（小数位数） |
+| borderRadius | number | 5 | 转角圆角半径 |
+| extensionDistance | number | 20 | 路径延伸距离 |
+| padding | number \| object | 20 | 节点边界框内边距 |
+| startDirections | Direction[] | ['top', 'right', 'bottom', 'left'] | 允许的起始方向 |
+| endDirections | Direction[] | ['top', 'right', 'bottom', 'left'] | 允许的结束方向 |
+| excludeNodes | string[] | [] | 排除的节点 ID |
+| excludeShapes | string[] | [] | 排除的节点类型 |
+| adaptiveStep | AdaptiveStepConfig | - | 自适应步长配置 |
+| performance | PerformanceConfig | - | 性能优化配置 |
+| debug | DebugConfig | - | 调试配置 |
+
+### AdaptiveStepConfig
+
+```typescript
+interface AdaptiveStepConfig {
+  enabled: boolean;        // 是否启用自适应步长
+  minStep: number;         // 最小步长 (默认: 5)
+  maxStep: number;         // 最大步长 (默认: 50)
+  densityThreshold: number; // 密度阈值 (默认: 0.3)
+  distanceThreshold: number; // 距离阈值 (默认: 500)
+}
+```
+
+### PerformanceConfig
+
+```typescript
+interface PerformanceConfig {
+  enableCache: boolean;      // 启用路径缓存
+  cacheSize: number;         // 缓存大小 (默认: 100)
+  enableQuadTree: boolean;   // 启用四叉树优化
+  earlyTermination: boolean; // 启用早期终止
+}
+```
+
+### DebugConfig
+
+```typescript
+interface DebugConfig {
+  enableLogging: boolean;  // 启用日志
+  enableMetrics: boolean;  // 启用性能指标
+  logLevel: 'error' | 'warn' | 'info' | 'debug';
+}
+```
+
+## 高级用法
+
+### 自定义障碍物排除
+
+```typescript
 const path = getManHattanPath({
-  sourceNodeId: 'node-1',
-  targetNodeId: 'node-2',
-  nodeLookup,
-  // ... other options
+  // ...基本参数
+  options: {
+    excludeNodes: ['node-3', 'node-4'],  // 排除特定节点
+    excludeShapes: ['group'],             // 排除特定类型
+    excludeTerminals: ['source'],         // 排除源/目标节点
+  }
 });
 ```
 
-## 特性
+### 性能优化配置
 
-- A* 寻路算法
-- 正交路径生成
-- 障碍物避让
-- 高性能计算
+```typescript
+const path = getManHattanPath({
+  // ...基本参数
+  options: {
+    performance: {
+      enableCache: true,
+      cacheSize: 200,
+      enableQuadTree: true,
+      earlyTermination: true,
+    },
+    adaptiveStep: {
+      enabled: true,
+      minStep: 5,
+      maxStep: 30,
+    }
+  }
+});
+```
+
+### 调试模式
+
+```typescript
+const path = getManHattanPath({
+  // ...基本参数
+  options: {
+    debug: {
+      enableLogging: true,
+      enableMetrics: true,
+      logLevel: 'debug',
+    }
+  }
+});
+```
+
+## 工具类
+
+### GlobalGrid
+
+全局网格对齐工具，确保所有路径点对齐到统一网格。
+
+```typescript
+import { GlobalGrid } from '@rxflow/manhattan';
+
+const grid = new GlobalGrid(10);
+const snapped = grid.snapToGrid({ x: 15, y: 23 }); // { x: 20, y: 20 }
+```
+
+### ObstacleMap
+
+障碍物地图，用于空间查询和碰撞检测。
+
+```typescript
+import { ObstacleMap } from '@rxflow/manhattan';
+
+const map = new ObstacleMap(options);
+map.build(nodeLookup, sourceId, targetId, sourceAnchor, targetAnchor);
+const accessible = map.isAccessible(point);
+```
+
+### ErrorRecovery
+
+错误恢复工具，提供回退路径生成。
+
+```typescript
+import { ErrorRecovery } from '@rxflow/manhattan';
+
+const fallback = ErrorRecovery.generateFallbackPath(start, end);
+const validated = ErrorRecovery.validateAndFixConfig(config);
+```
+
+## 架构
+
+```
+@rxflow/manhattan
+├── getManHattanPath.ts    # 主入口函数
+├── geometry/              # 几何类 (Point, Rectangle)
+├── obstacle/              # 障碍物处理 (ObstacleMap, QuadTree)
+├── pathfinder/            # A* 寻路算法
+├── options/               # 配置解析
+├── svg/                   # SVG 路径转换
+└── utils/                 # 工具函数
+    ├── GlobalGrid.ts      # 全局网格
+    ├── AdaptiveStepCalculator.ts  # 自适应步长
+    ├── PerformanceMonitor.ts      # 性能监控
+    ├── ErrorRecovery.ts   # 错误恢复
+    └── heuristics.ts      # 启发式函数
+```
 
 ## License
 

package/esm/getManHattanPath.js

@@ -14,13 +14,13 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import { getSmoothStepPath } from '@xyflow/react';
+import { getSmoothStepPath, Position } from '@xyflow/react';
 import { Point, Rectangle } from "./geometry";
 import { ObstacleMap } from "./obstacle";
 import { resolveOptions } from "./options";
 import { findRoute } from "./pathfinder";
 import { pointsToPath, parseSVGPath } from "./svg";
-import { getNodeDimensions, getNodePosition, pathIntersectsObstacles } from "./utils";
+import { getNodeDimensions, getNodePosition, pathIntersectsObstacles, ErrorRecovery } from "./utils";
 
 /**
  * Parameters for getManHattanPath function
@@ -78,10 +78,12 @@ export function getManHattanPath(params) {
   var targetNode = nodeLookup.get(targetNodeId);
   if (!sourceNode || !targetNode) {
     // Fallback to simple straight line if nodes not found
-    console.warn('Source or target node not found in nodeLookup');
+    console.warn('[getManHattanPath] Source or target node not found in nodeLookup');
     var start = new Point(sourceX, sourceY);
     var end = new Point(targetX, targetY);
-    return pointsToPath([start, end], options.precision);
+    // Use ErrorRecovery to generate a proper fallback path
+    var fallbackPath = ErrorRecovery.generateFallbackPath(start, end);
+    return pointsToPath(fallbackPath, options.precision, options.borderRadius);
   }
 
   // Get node dimensions using ReactFlow's priority logic
@@ -118,10 +120,8 @@ export function getManHattanPath(params) {
 
   // Check if smooth step path intersects with any obstacles
   if (smoothStepPoints.length > 0 && !pathIntersectsObstacles(smoothStepPoints, nodeLookup)) {
-    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);
@@ -129,27 +129,80 @@ export function getManHattanPath(params) {
   // Find route
   var route = findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, obstacleMap, options);
 
-  // Fallback to straight line if no route found
+  // Fallback to Z-shaped path if no route found
   if (!route) {
-    console.warn('Unable to find Manhattan route, using straight line fallback');
-    route = [sourceAnchor, targetAnchor];
+    console.warn('[getManHattanPath] Unable to find Manhattan route, using fallback path');
+    route = ErrorRecovery.generateFallbackPath(sourceAnchor, targetAnchor);
   }
-  console.log('[getManHattanPath] Route from findRoute:', route.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
-  console.log('[getManHattanPath] Source anchor:', "(".concat(sourceAnchor.x, ", ").concat(sourceAnchor.y, ")"));
-  console.log('[getManHattanPath] Target anchor:', "(".concat(targetAnchor.x, ", ").concat(targetAnchor.y, ")"));
 
   // If using smart point generation (sourcePosition/targetPosition specified),
   // the route already contains the correct extension points, so skip manual processing
   var useSmartPoints = sourcePosition || targetPosition;
   if (useSmartPoints) {
-    console.log('[getManHattanPath] Using smart points, skipping manual extension point processing');
+    // Post-process route to fix X coordinates for horizontal anchors
+    // This ensures the extension distance is fixed and not affected by grid alignment
+    var isSourceHorizontal = sourcePosition === Position.Left || sourcePosition === Position.Right;
+    var isTargetHorizontal = targetPosition === Position.Left || targetPosition === Position.Right;
+    if (isSourceHorizontal && isTargetHorizontal && route.length > 0) {
+      // Calculate expected extension X coordinates
+      var sourceExtensionX = sourcePosition === Position.Right ? sourceAnchor.x + options.extensionDistance : sourceAnchor.x - options.extensionDistance;
+      var targetExtensionX = targetPosition === Position.Left ? targetAnchor.x - options.extensionDistance : targetAnchor.x + options.extensionDistance;
+
+      // Find the horizontal segment (where Y stays constant but X changes significantly)
+      // This divides the path into source-side and target-side
+      var horizontalSegmentStart = -1;
+      var horizontalSegmentEnd = -1;
+      for (var _i = 0; _i < route.length - 1; _i++) {
+        var curr = route[_i];
+        var next = route[_i + 1];
+        var isHorizontalMove = Math.abs(curr.y - next.y) < 1 && Math.abs(curr.x - next.x) > options.step;
+        if (isHorizontalMove) {
+          horizontalSegmentStart = _i;
+          horizontalSegmentEnd = _i + 1;
+          break;
+        }
+      }
+
+      // Fix route points
+      for (var _i2 = 0; _i2 < route.length; _i2++) {
+        var point = route[_i2];
+        if (horizontalSegmentStart >= 0) {
+          if (_i2 <= horizontalSegmentStart) {
+            // Source side - all vertical segment points should use sourceExtensionX
+            route[_i2] = new Point(sourceExtensionX, point.y);
+          } else if (_i2 >= horizontalSegmentEnd) {
+            // Target side - all vertical segment points should use targetExtensionX
+            route[_i2] = new Point(targetExtensionX, point.y);
+          }
+        }
+      }
+
+      // Remove redundant points (consecutive points on same line)
+      var optimized = [];
+      for (var _i3 = 0; _i3 < route.length; _i3++) {
+        var _point = route[_i3];
+        if (optimized.length < 2) {
+          optimized.push(_point);
+        } else {
+          var prev = optimized[optimized.length - 1];
+          var prevPrev = optimized[optimized.length - 2];
+
+          // Check if prev is on the same line as prevPrev and point
+          var sameX = Math.abs(prevPrev.x - prev.x) < 1 && Math.abs(prev.x - _point.x) < 1;
+          var sameY = Math.abs(prevPrev.y - prev.y) < 1 && Math.abs(prev.y - _point.y) < 1;
+          if (sameX || sameY) {
+            // prev is redundant, replace it with current point
+            optimized[optimized.length - 1] = _point;
+          } else {
+            optimized.push(_point);
+          }
+        }
+      }
+      route = optimized;
+    }
+
     // Add source and target anchors to route
     var _finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
-    console.log('[getManHattanPath] Final route:', _finalRoute.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
     return pointsToPath(_finalRoute, options.precision, options.borderRadius);
   }
 
@@ -172,7 +225,6 @@ export function getManHattanPath(params) {
       // This is likely an extension point, remove it
       if (onRight && firstPoint.x > sourceAnchor.x || onLeft && firstPoint.x < sourceAnchor.x || onBottom && firstPoint.y > sourceAnchor.y || onTop && firstPoint.y < sourceAnchor.y) {
         route.shift();
-        console.log('[getManHattanPath] Removed extension point from route start');
       }
     }
   }
@@ -191,7 +243,6 @@ export function getManHattanPath(params) {
       // This is likely an extension point, remove it
       if (_onLeft && lastPoint.x < targetAnchor.x || _onRight && lastPoint.x > targetAnchor.x || _onTop && lastPoint.y < targetAnchor.y || _onBottom && lastPoint.y > targetAnchor.y) {
         route.pop();
-        console.log('[getManHattanPath] Removed extension point from route end');
       }
     }
   }
@@ -217,7 +268,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(extendX, _firstPoint.y)); // Corner point
       }
       route.unshift(extensionPoint); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted source extension (right):', "(".concat(extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onLeft2) {
       // Anchor on left edge - extend left by step + borderRadius
       var _extendX = sourceAnchor.x - extensionDistance;
@@ -226,7 +276,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_extendX, _firstPoint.y));
       }
       route.unshift(_extensionPoint);
-      console.log('[getManHattanPath] Inserted source extension (left):', "(".concat(_extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onBottom2) {
       // Anchor on bottom edge - extend down by step + borderRadius
       var extendY = sourceAnchor.y + extensionDistance;
@@ -235,7 +284,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_firstPoint.x, extendY));
       }
       route.unshift(_extensionPoint2);
-      console.log('[getManHattanPath] Inserted source extension (down):', "(".concat(sourceAnchor.x, ", ").concat(extendY, ")"));
     } else if (_onTop2) {
       // Anchor on top edge - extend up by step + borderRadius
       var _extendY = sourceAnchor.y - extensionDistance;
@@ -244,33 +292,25 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_firstPoint.x, _extendY));
       }
       route.unshift(_extensionPoint3);
-      console.log('[getManHattanPath] Inserted source extension (up):', "(".concat(sourceAnchor.x, ", ").concat(_extendY, ")"));
     }
   }
 
   // Remove redundant points after source extension
   // If the first route point has the same x or y coordinate as the source anchor, it's redundant
-  if (route.length > 2) {
-    var firstRoutePoint = route[0]; // Extension point
-    var secondRoutePoint = route[1]; // Corner point (if exists)
+  if (route.length > 3) {
     var thirdRoutePoint = route[2]; // Original A* point
-
     // Check if the third point (original A* point) is redundant
     // It's redundant if it's on the same line as the corner point and can be skipped
-    var sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
-    var sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
-    if (sameX || sameY) {
-      // The third point is aligned with the source anchor, likely redundant
-      // Check if we can skip it by connecting corner point directly to the next point
-      if (route.length > 3) {
-        var fourthPoint = route[3];
-        // If corner point and fourth point form a straight line, remove the third point
-        var cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
-        var thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
-        if (cornerToThird && thirdToFourth) {
-          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdRoutePoint.x, ", ").concat(thirdRoutePoint.y, ")"));
-          route.splice(2, 1); // Remove the third point
-        }
+    var _sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
+    var _sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
+    if (_sameX || _sameY) {
+      var secondRoutePoint = route[1]; // Corner point (if exists)
+      var fourthPoint = route[3];
+      // If corner point and fourth point form a straight line, remove the third point
+      var cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
+      var thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
+      if (cornerToThird && thirdToFourth) {
+        route.splice(2, 1); // Remove the third point
       }
     }
   }
@@ -280,16 +320,12 @@ export function getManHattanPath(params) {
   // where the middle segment goes to target edge and then moves along it
   // Use target bbox with padding (same as ObstacleMap)
   var targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
-  console.log('[getManHattanPath] Route before zigzag check:', route.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
-  console.log('[getManHattanPath] Target BBox with padding:', "x=".concat(targetBBoxWithPadding.x, ", y=").concat(targetBBoxWithPadding.y));
   if (route.length >= 3) {
-    var _i = 0;
-    while (_i < route.length - 2) {
-      var p1 = route[_i];
-      var p2 = route[_i + 1];
-      var p3 = route[_i + 2];
+    var _i4 = 0;
+    while (_i4 < route.length - 2) {
+      var p1 = route[_i4];
+      var p2 = route[_i4 + 1];
+      var p3 = route[_i4 + 2];
 
       // Check if p2 is on the target bbox edge (with padding)
       var p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
@@ -297,22 +333,19 @@ export function getManHattanPath(params) {
       var p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
       var p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
       var p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
-      console.log("[getManHattanPath] Checking i=".concat(_i, ": p2=(").concat(p2.x, ", ").concat(p2.y, "), onEdge=").concat(p2OnTargetEdge));
       if (p2OnTargetEdge) {
         // Check if p1 -> p2 -> p3 forms a zigzag
         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;
-        console.log("[getManHattanPath] Zigzag pattern: H->V=".concat(p1ToP2Horizontal && p2ToP3Vertical, ", V->H=").concat(p1ToP2Vertical && p2ToP3Horizontal));
         if (p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal) {
           // We have a zigzag at target edge, remove p2 and p3
-          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(p2.x, ", ").concat(p2.y, ")"), "and (".concat(p3.x, ", ").concat(p3.y, ")"));
-          route.splice(_i + 1, 2); // Remove p2 and p3
+          route.splice(_i4 + 1, 2); // Remove p2 and p3
           continue;
         }
       }
-      _i++;
+      _i4++;
     }
   }
 
@@ -336,7 +369,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_extendX2, _lastPoint.y)); // Corner point
       }
       route.push(_extensionPoint4); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted target extension (left):', "(".concat(_extendX2, ", ").concat(targetAnchor.y, ")"));
     } else if (_onRight3) {
       // Anchor on right edge - extend right by step + borderRadius
       var _extendX3 = targetAnchor.x + _extensionDistance;
@@ -345,7 +377,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_extendX3, _lastPoint.y));
       }
       route.push(_extensionPoint5);
-      console.log('[getManHattanPath] Inserted target extension (right):', "(".concat(_extendX3, ", ").concat(targetAnchor.y, ")"));
     } else if (_onTop3) {
       // Anchor on top edge - extend up by step + borderRadius
       var _extendY2 = targetAnchor.y - _extensionDistance;
@@ -354,7 +385,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_lastPoint.x, _extendY2));
       }
       route.push(_extensionPoint6);
-      console.log('[getManHattanPath] Inserted target extension (up):', "(".concat(targetAnchor.x, ", ").concat(_extendY2, ")"));
     } else if (_onBottom3) {
       // Anchor on bottom edge - extend down by step + borderRadius
       var _extendY3 = targetAnchor.y + _extensionDistance;
@@ -363,7 +393,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_lastPoint.x, _extendY3));
       }
       route.push(_extensionPoint7);
-      console.log('[getManHattanPath] Inserted target extension (down):', "(".concat(targetAnchor.x, ", ").concat(_extendY3, ")"));
     }
   }
 
@@ -371,20 +400,18 @@ export function getManHattanPath(params) {
   // Similar logic for target side
   if (route.length > 2) {
     var lastIdx = route.length - 1;
-    var lastRoutePoint = route[lastIdx]; // Extension point
     var secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
     var thirdLastPoint = route[lastIdx - 2]; // Original A* point
 
     // Check if the third-to-last point is redundant
-    var _sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
-    var _sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
-    if (_sameX || _sameY) {
+    var _sameX2 = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    var _sameY2 = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if (_sameX2 || _sameY2) {
       if (route.length > 3) {
         var fourthLastPoint = route[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) {
-          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdLastPoint.x, ", ").concat(thirdLastPoint.y, ")"));
           route.splice(lastIdx - 2, 1); // Remove the third-to-last point
         }
       }
@@ -417,7 +444,6 @@ export function getManHattanPath(params) {
         var p3ToP4Horizontal = Math.abs(_p3.y - p4.y) < tolerance;
         if (p3ToP4Horizontal) {
           // Pattern: horizontal -> vertical -> horizontal (zigzag)
-          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(_p2.x, ", ").concat(_p2.y, ")"), "and (".concat(_p3.x, ", ").concat(_p3.y, ")"));
           route.splice(i + 1, 2); // Remove p2 and p3
           continue;
         }
@@ -428,9 +454,6 @@ export function getManHattanPath(params) {
 
   // Add source and target anchors to route
   var finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
-  console.log('[getManHattanPath] Final route:', finalRoute.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
 
   // Convert to SVG path string
   return pointsToPath(finalRoute, options.precision, options.borderRadius);