@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/getManHattanPath.js

@@ -0,0 +1,449 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getManHattanPath = getManHattanPath;
+var _react = require("@xyflow/react");
+var _geometry = require("./geometry");
+var _obstacle = require("./obstacle");
+var _options = require("./options");
+var _pathfinder = require("./pathfinder");
+var _svg = require("./svg");
+var _utils = require("./utils");
+/**
+ * Parameters for getManHattanPath function
+ */
+
+/**
+ * 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({
+ *   sourceNodeId: 'node1',
+ *   targetNodeId: 'node2',
+ *   sourcePosition: { x: 100, y: 100 },
+ *   targetPosition: { x: 300, y: 300 },
+ *   nodeLookup: nodes,
+ *   options: {
+ *     step: 10,
+ *     startDirections: ['bottom'],
+ *     endDirections: ['top']
+ *   }
+ * })
+ * ```
+ */
+function getManHattanPath(params) {
+  const {
+    sourceNodeId,
+    targetNodeId,
+    sourcePosition,
+    targetPosition,
+    nodeLookup,
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    options: userOptions = {}
+  } = params;
+
+  // Resolve options and add position information
+  const options = (0, _options.resolveOptions)({
+    ...userOptions,
+    sourcePosition,
+    targetPosition
+  });
+
+  // Direction control is automatically handled by getRectPoints:
+  // - When anchor is on an edge, only outward directions are allowed (via isDirectionOutward)
+  // - For sourcePosition="right": anchor on right edge -> only extends right
+  // - For targetPosition="left": anchor on left edge -> path approaches from right (outward from left)
+  // This ensures paths follow the sourcePosition and targetPosition constraints
+
+  // Get source and target nodes
+  const sourceNode = nodeLookup.get(sourceNodeId);
+  const targetNode = nodeLookup.get(targetNodeId);
+  if (!sourceNode || !targetNode) {
+    // Fallback to simple straight line if nodes not found
+    console.warn('[getManHattanPath] Source or target node not found in nodeLookup');
+    const start = new _geometry.Point(sourceX, sourceY);
+    const end = new _geometry.Point(targetX, targetY);
+    // Use ErrorRecovery to generate a proper fallback path
+    const fallbackPath = _utils.ErrorRecovery.generateFallbackPath(start, end);
+    return (0, _svg.pointsToPath)(fallbackPath, options.precision, options.borderRadius);
+  }
+
+  // Get node dimensions using ReactFlow's priority logic
+  const sourceDimensions = (0, _utils.getNodeDimensions)(sourceNode);
+  const targetDimensions = (0, _utils.getNodeDimensions)(targetNode);
+
+  // Get absolute positions from internals
+  const sourcePos = (0, _utils.getNodePosition)(sourceNode);
+  const targetPos = (0, _utils.getNodePosition)(targetNode);
+
+  // Calculate bounding boxes
+  const sourceBBox = new _geometry.Rectangle(sourcePos.x, sourcePos.y, sourceDimensions.width, sourceDimensions.height);
+  const targetBBox = new _geometry.Rectangle(targetPos.x, targetPos.y, targetDimensions.width, targetDimensions.height);
+
+  // Create anchor points
+  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)) {
+    return smoothStepPath;
+  }
+
+  // Build obstacle map with anchor information
+  const obstacleMap = new _obstacle.ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
+
+  // Find route
+  let route = (0, _pathfinder.findRoute)(sourceBBox, targetBBox, sourceAnchor, targetAnchor, obstacleMap, options);
+
+  // Fallback to Z-shaped path if no route found
+  if (!route) {
+    console.warn('[getManHattanPath] Unable to find Manhattan route, using fallback path');
+    route = _utils.ErrorRecovery.generateFallbackPath(sourceAnchor, targetAnchor);
+  }
+
+  // If using smart point generation (sourcePosition/targetPosition specified),
+  // the route already contains the correct extension points, so skip manual processing
+  const useSmartPoints = sourcePosition || targetPosition;
+  if (useSmartPoints) {
+    // Post-process route to fix X coordinates for horizontal anchors
+    // This ensures the extension distance is fixed and not affected by grid alignment
+    const isSourceHorizontal = sourcePosition === _react.Position.Left || sourcePosition === _react.Position.Right;
+    const isTargetHorizontal = targetPosition === _react.Position.Left || targetPosition === _react.Position.Right;
+    if (isSourceHorizontal && isTargetHorizontal && route.length > 0) {
+      // Calculate expected extension X coordinates
+      const sourceExtensionX = sourcePosition === _react.Position.Right ? sourceAnchor.x + options.extensionDistance : sourceAnchor.x - options.extensionDistance;
+      const targetExtensionX = targetPosition === _react.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
+      let horizontalSegmentStart = -1;
+      let horizontalSegmentEnd = -1;
+      for (let i = 0; i < route.length - 1; i++) {
+        const curr = route[i];
+        const next = route[i + 1];
+        const 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 (let i = 0; i < route.length; i++) {
+        const point = route[i];
+        if (horizontalSegmentStart >= 0) {
+          if (i <= horizontalSegmentStart) {
+            // Source side - all vertical segment points should use sourceExtensionX
+            route[i] = new _geometry.Point(sourceExtensionX, point.y);
+          } else if (i >= horizontalSegmentEnd) {
+            // Target side - all vertical segment points should use targetExtensionX
+            route[i] = new _geometry.Point(targetExtensionX, point.y);
+          }
+        }
+      }
+
+      // Remove redundant points (consecutive points on same line)
+      const optimized = [];
+      for (let i = 0; i < route.length; i++) {
+        const point = route[i];
+        if (optimized.length < 2) {
+          optimized.push(point);
+        } else {
+          const prev = optimized[optimized.length - 1];
+          const prevPrev = optimized[optimized.length - 2];
+
+          // Check if prev is on the same line as prevPrev and point
+          const sameX = Math.abs(prevPrev.x - prev.x) < 1 && Math.abs(prev.x - point.x) < 1;
+          const 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
+    const finalRoute = [sourceAnchor, ...route, targetAnchor];
+    return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
+  }
+
+  // Remove extension points from route that were added by getRectPoints
+  // We will add our own with fixed step distance
+  const step = options.step;
+  const tolerance = 1;
+
+  // Check if first point is an extension point from source
+  if (route.length > 0) {
+    const firstPoint = route[0];
+    const onLeft = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
+    const onRight = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
+    const onTop = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
+    const onBottom = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
+
+    // Check if firstPoint is close to source anchor (indicating it's an extension point)
+    const distToFirst = sourceAnchor.manhattanDistance(firstPoint);
+    if (distToFirst < step * 2) {
+      // 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();
+      }
+    }
+  }
+
+  // Check if last point is an extension point from target
+  if (route.length > 0) {
+    const lastPoint = route[route.length - 1];
+    const onLeft = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
+    const onRight = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    const onTop = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
+    const onBottom = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
+
+    // Check if lastPoint is close to target anchor (indicating it's an extension point)
+    const distToLast = targetAnchor.manhattanDistance(lastPoint);
+    if (distToLast < step * 2) {
+      // 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();
+      }
+    }
+  }
+
+  // Insert extension point at source - always extend away from node edge by fixed distance
+  if (route.length > 0) {
+    const extensionDistance = options.extensionDistance;
+    const firstPoint = route[0];
+
+    // Determine which edge the source anchor is on
+    const onLeft = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
+    const onRight = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
+    const onTop = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
+    const onBottom = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
+
+    // Insert extension point and corner point to ensure orthogonal path
+    if (onRight) {
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = sourceAnchor.x + extensionDistance;
+      const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
+      // Check if we need a corner point
+      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
+        route.unshift(new _geometry.Point(extendX, firstPoint.y)); // Corner point
+      }
+      route.unshift(extensionPoint); // Extension point (fixed distance)
+    } else if (onLeft) {
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = sourceAnchor.x - extensionDistance;
+      const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
+      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
+        route.unshift(new _geometry.Point(extendX, firstPoint.y));
+      }
+      route.unshift(extensionPoint);
+    } else if (onBottom) {
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = sourceAnchor.y + extensionDistance;
+      const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
+      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
+        route.unshift(new _geometry.Point(firstPoint.x, extendY));
+      }
+      route.unshift(extensionPoint);
+    } else if (onTop) {
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = sourceAnchor.y - extensionDistance;
+      const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
+      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
+        route.unshift(new _geometry.Point(firstPoint.x, extendY));
+      }
+      route.unshift(extensionPoint);
+    }
+  }
+
+  // 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 > 3) {
+    const 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
+    const sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
+    const sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
+    if (sameX || sameY) {
+      const secondRoutePoint = route[1]; // Corner point (if exists)
+      const fourthPoint = route[3];
+      // If corner point and fourth point form a straight line, remove the third point
+      const cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
+      const 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
+      }
+    }
+  }
+
+  // Optimize zigzag patterns BEFORE inserting target extension
+  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134)
+  // where the middle segment goes to target edge and then moves along it
+  // Use target bbox with padding (same as ObstacleMap)
+  const targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
+  if (route.length >= 3) {
+    let i = 0;
+    while (i < route.length - 2) {
+      const p1 = route[i];
+      const p2 = route[i + 1];
+      const p3 = route[i + 2];
+
+      // Check if p2 is on the target bbox edge (with padding)
+      const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
+      const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBoxWithPadding.x + targetBBoxWithPadding.width)) < tolerance;
+      const p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
+      const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
+      const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
+      if (p2OnTargetEdge) {
+        // Check if p1 -> p2 -> p3 forms a zigzag
+        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;
+        if (p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal) {
+          // We have a zigzag at target edge, remove p2 and p3
+          route.splice(i + 1, 2); // Remove p2 and p3
+          continue;
+        }
+      }
+      i++;
+    }
+  }
+
+  // Insert extension point at target - always extend away from node edge by fixed distance
+  if (route.length > 0) {
+    const extensionDistance = options.extensionDistance;
+    const lastPoint = route[route.length - 1];
+
+    // Determine which edge the target anchor is on
+    const onLeft = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
+    const onRight = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    const onTop = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
+    const onBottom = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
+
+    // Insert extension point and corner point to ensure orthogonal path
+    if (onLeft) {
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = targetAnchor.x - extensionDistance;
+      const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
+      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
+        route.push(new _geometry.Point(extendX, lastPoint.y)); // Corner point
+      }
+      route.push(extensionPoint); // Extension point (fixed distance)
+    } else if (onRight) {
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = targetAnchor.x + extensionDistance;
+      const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
+      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
+        route.push(new _geometry.Point(extendX, lastPoint.y));
+      }
+      route.push(extensionPoint);
+    } else if (onTop) {
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = targetAnchor.y - extensionDistance;
+      const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
+      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
+        route.push(new _geometry.Point(lastPoint.x, extendY));
+      }
+      route.push(extensionPoint);
+    } else if (onBottom) {
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = targetAnchor.y + extensionDistance;
+      const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
+      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
+        route.push(new _geometry.Point(lastPoint.x, extendY));
+      }
+      route.push(extensionPoint);
+    }
+  }
+
+  // Remove redundant points before target extension
+  // Similar logic for target side
+  if (route.length > 2) {
+    const lastIdx = route.length - 1;
+    const secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
+    const thirdLastPoint = route[lastIdx - 2]; // Original A* point
+
+    // Check if the third-to-last point is redundant
+    const sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    const sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if (sameX || sameY) {
+      if (route.length > 3) {
+        const fourthLastPoint = route[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) {
+          route.splice(lastIdx - 2, 1); // Remove the third-to-last point
+        }
+      }
+    }
+  }
+
+  // Additional optimization: Remove unnecessary zigzag patterns near target
+  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134) -> (800, -134)
+  // where (815, 16) and (815, -134) form a zigzag at the target edge
+  let i = 0;
+  while (i < route.length - 2) {
+    const p1 = route[i];
+    const p2 = route[i + 1];
+    const p3 = route[i + 2];
+
+    // Check if p2 is on the target bbox edge
+    const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBox.x) < tolerance;
+    const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    const p2OnTargetTopEdge = Math.abs(p2.y - targetBBox.y) < tolerance;
+    const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBox.y + targetBBox.height)) < tolerance;
+    const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
+    if (p2OnTargetEdge) {
+      // Check if p1 -> p2 -> p3 forms a zigzag
+      const p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
+      const p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
+      if (p1ToP2Horizontal && p2ToP3Vertical && i < route.length - 3) {
+        // We have horizontal -> vertical at target edge
+        // Check if we can skip p2 and p3
+        const p4 = route[i + 3];
+        const p3ToP4Horizontal = Math.abs(p3.y - p4.y) < tolerance;
+        if (p3ToP4Horizontal) {
+          // Pattern: horizontal -> vertical -> horizontal (zigzag)
+          route.splice(i + 1, 2); // Remove p2 and p3
+          continue;
+        }
+      }
+    }
+    i++;
+  }
+
+  // Add source and target anchors to route
+  const finalRoute = [sourceAnchor, ...route, targetAnchor];
+
+  // Convert to SVG path string
+  return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
+}

package/cjs/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ReactFlow Manhattan Router
+ *
+ * A Manhattan routing algorithm adapted for ReactFlow from AntV X6.
+ * Generates orthogonal (right-angle) paths that intelligently avoid obstacles.
+ *
+ * @packageDocumentation
+ */
+export { getManHattanPath } from './getManHattanPath';
+export type { GetManHattanPathParams } from './getManHattanPath';
+export type { Direction, InternalNode, NodeLookup, ManhattanRouterOptions, ResolvedOptions, } from './options';
+export { Point, Rectangle, Line } from './geometry';
+export { getGrid, align, snapToGrid, getDirectionAngle, getDirectionChange, getRectPoints, getCost, getKey, reconstructRoute, normalizePoint, getNodeDimensions, getNodePosition, } from './utils';
+export type { NodeDimensions } from './utils';
+export { pointsToPath, snapPathToGrid } from './svg';
+//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAGhE,YAAY,EACV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,sBAAsB,EACtB,eAAe,GAChB,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAGnD,OAAO,EACL,OAAO,EACP,KAAK,EACL,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,OAAO,EACP,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,SAAS,CAAA;AAGhB,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAG7C,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA"}

package/cjs/index.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Line", {
+  enumerable: true,
+  get: function () {
+    return _geometry.Line;
+  }
+});
+Object.defineProperty(exports, "Point", {
+  enumerable: true,
+  get: function () {
+    return _geometry.Point;
+  }
+});
+Object.defineProperty(exports, "Rectangle", {
+  enumerable: true,
+  get: function () {
+    return _geometry.Rectangle;
+  }
+});
+Object.defineProperty(exports, "align", {
+  enumerable: true,
+  get: function () {
+    return _utils.align;
+  }
+});
+Object.defineProperty(exports, "getCost", {
+  enumerable: true,
+  get: function () {
+    return _utils.getCost;
+  }
+});
+Object.defineProperty(exports, "getDirectionAngle", {
+  enumerable: true,
+  get: function () {
+    return _utils.getDirectionAngle;
+  }
+});
+Object.defineProperty(exports, "getDirectionChange", {
+  enumerable: true,
+  get: function () {
+    return _utils.getDirectionChange;
+  }
+});
+Object.defineProperty(exports, "getGrid", {
+  enumerable: true,
+  get: function () {
+    return _utils.getGrid;
+  }
+});
+Object.defineProperty(exports, "getKey", {
+  enumerable: true,
+  get: function () {
+    return _utils.getKey;
+  }
+});
+Object.defineProperty(exports, "getManHattanPath", {
+  enumerable: true,
+  get: function () {
+    return _getManHattanPath.getManHattanPath;
+  }
+});
+Object.defineProperty(exports, "getNodeDimensions", {
+  enumerable: true,
+  get: function () {
+    return _utils.getNodeDimensions;
+  }
+});
+Object.defineProperty(exports, "getNodePosition", {
+  enumerable: true,
+  get: function () {
+    return _utils.getNodePosition;
+  }
+});
+Object.defineProperty(exports, "getRectPoints", {
+  enumerable: true,
+  get: function () {
+    return _utils.getRectPoints;
+  }
+});
+Object.defineProperty(exports, "normalizePoint", {
+  enumerable: true,
+  get: function () {
+    return _utils.normalizePoint;
+  }
+});
+Object.defineProperty(exports, "pointsToPath", {
+  enumerable: true,
+  get: function () {
+    return _svg.pointsToPath;
+  }
+});
+Object.defineProperty(exports, "reconstructRoute", {
+  enumerable: true,
+  get: function () {
+    return _utils.reconstructRoute;
+  }
+});
+Object.defineProperty(exports, "snapPathToGrid", {
+  enumerable: true,
+  get: function () {
+    return _svg.snapPathToGrid;
+  }
+});
+Object.defineProperty(exports, "snapToGrid", {
+  enumerable: true,
+  get: function () {
+    return _utils.snapToGrid;
+  }
+});
+var _getManHattanPath = require("./getManHattanPath");
+var _geometry = require("./geometry");
+var _utils = require("./utils");
+var _svg = require("./svg");

package/cjs/obstacle/ObstacleMap.d.ts

@@ -0,0 +1,66 @@
+import { Point } from '../geometry';
+import type { ResolvedOptions, NodeLookup } from '../options';
+/**
+ * ObstacleMap class for managing obstacles in pathfinding
+ * Feature: manhattan-optimization
+ *
+ * Uses QuadTree for efficient spatial queries (O(log n) instead of O(n))
+ * Includes query caching for repeated accessibility checks
+ */
+export declare class ObstacleMap {
+    private options;
+    private quadTree;
+    private obstacles;
+    private sourceAnchor?;
+    private targetAnchor?;
+    private accessibilityCache;
+    private cacheHits;
+    private cacheMisses;
+    constructor(options: ResolvedOptions);
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    /**
+     * Clear the accessibility cache
+     */
+    clearCache(): void;
+    /**
+     * Build obstacle map from node lookup using QuadTree
+     */
+    build(nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string, sourceAnchor?: Point, targetAnchor?: Point): ObstacleMap;
+    /**
+     * Check if a point is accessible (not inside any obstacle)
+     * Uses QuadTree for efficient spatial queries with caching
+     */
+    isAccessible(point: Point, checkRadius?: number): boolean;
+    /**
+     * Check if an anchor point has sufficient clearance around it
+     * This ensures the path can start/end at the anchor without being blocked
+     */
+    hasAnchorClearance(anchor: Point, direction: 'top' | 'right' | 'bottom' | 'left'): boolean;
+    /**
+     * Check accessibility without using cache (for internal use)
+     */
+    private isAccessibleWithoutCache;
+    /**
+     * Find the nearest accessible point from an anchor in a given direction
+     * Uses binary search for efficiency
+     */
+    findNearestAccessiblePoint(anchor: Point, direction: 'top' | 'right' | 'bottom' | 'left', maxDistance: number): Point | null;
+    /**
+     * Batch check accessibility for multiple points (optimized)
+     * Returns array of booleans in same order as input points
+     */
+    areAccessible(points: Point[]): boolean[];
+    /**
+     * Check accessibility using binary search optimization
+     * Tries step -> step/2 -> step/4 -> ... -> 1px
+     */
+    private isAccessibleWithBinarySearch;
+}
+//# sourceMappingURL=ObstacleMap.d.ts.map

package/cjs/obstacle/ObstacleMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAI7D;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,SAAS,CAAmD;IACpE,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;IAG5B,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAY;gBAEnB,OAAO,EAAE,eAAe;IAIpC;;OAEG;IACH,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IASlE;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IA8Cd;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAoD5D;;;OAGG;IACH,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO;IA0C1F;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;OAGG;IACH,0BAA0B,CACxB,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAC9C,WAAW,EAAE,MAAM,GAClB,KAAK,GAAG,IAAI;IAyDf;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE;IAIzC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}