@rxflow/manhattan 0.0.1-alpha.0

package/cjs/getManHattanPath.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getManHattanPath = getManHattanPath;
+var _geometry = require("./geometry");
+var _options = require("./options");
+var _obstacle = require("./obstacle");
+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,
+    options: userOptions = {}
+  } = params;
+
+  // Resolve options
+  const options = (0, _options.resolveOptions)(userOptions);
+
+  // 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('Source or target node not found in nodeLookup');
+    const start = new _geometry.Point(sourcePosition.x, sourcePosition.y);
+    const end = new _geometry.Point(targetPosition.x, targetPosition.y);
+    return (0, _svg.pointsToPath)([start, end], options.precision);
+  }
+
+  // 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(sourcePosition.x, sourcePosition.y);
+  const targetAnchor = new _geometry.Point(targetPosition.x, targetPosition.y);
+
+  // 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 straight line if no route found
+  if (!route) {
+    console.warn('Unable to find Manhattan route, using straight line fallback');
+    route = [sourceAnchor, targetAnchor];
+  }
+  console.log('[getManHattanPath] Route from findRoute:', route.map(p => `(${p.x}, ${p.y})`));
+  console.log('[getManHattanPath] Source anchor:', `(${sourceAnchor.x}, ${sourceAnchor.y})`);
+  console.log('[getManHattanPath] Target anchor:', `(${targetAnchor.x}, ${targetAnchor.y})`);
+
+  // 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();
+        console.log('[getManHattanPath] Removed extension point from route start');
+      }
+    }
+  }
+
+  // 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();
+        console.log('[getManHattanPath] Removed extension point from route end');
+      }
+    }
+  }
+
+  // Insert extension point at source - always extend away from node edge by fixed step distance
+  if (route.length > 0) {
+    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 fixed step
+      const extendX = sourceAnchor.x + step;
+      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)
+      console.log('[getManHattanPath] Inserted source extension (right):', `(${extendX}, ${sourceAnchor.y})`);
+    } else if (onLeft) {
+      // Anchor on left edge - extend left by fixed step
+      const extendX = sourceAnchor.x - step;
+      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);
+      console.log('[getManHattanPath] Inserted source extension (left):', `(${extendX}, ${sourceAnchor.y})`);
+    } else if (onBottom) {
+      // Anchor on bottom edge - extend down by fixed step
+      const extendY = sourceAnchor.y + step;
+      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);
+      console.log('[getManHattanPath] Inserted source extension (down):', `(${sourceAnchor.x}, ${extendY})`);
+    } else if (onTop) {
+      // Anchor on top edge - extend up by fixed step
+      const extendY = sourceAnchor.y - step;
+      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);
+      console.log('[getManHattanPath] Inserted source extension (up):', `(${sourceAnchor.x}, ${extendY})`);
+    }
+  }
+
+  // Insert extension point at target - always extend away from node edge by fixed step distance
+  if (route.length > 0) {
+    const step = options.step;
+    const tolerance = 1;
+    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 fixed step
+      const extendX = targetAnchor.x - step;
+      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)
+      console.log('[getManHattanPath] Inserted target extension (left):', `(${extendX}, ${targetAnchor.y})`);
+    } else if (onRight) {
+      // Anchor on right edge - extend right by fixed step
+      const extendX = targetAnchor.x + step;
+      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);
+      console.log('[getManHattanPath] Inserted target extension (right):', `(${extendX}, ${targetAnchor.y})`);
+    } else if (onTop) {
+      // Anchor on top edge - extend up by fixed step
+      const extendY = targetAnchor.y - step;
+      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);
+      console.log('[getManHattanPath] Inserted target extension (up):', `(${targetAnchor.x}, ${extendY})`);
+    } else if (onBottom) {
+      // Anchor on bottom edge - extend down by fixed step
+      const extendY = targetAnchor.y + step;
+      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);
+      console.log('[getManHattanPath] Inserted target extension (down):', `(${targetAnchor.x}, ${extendY})`);
+    }
+  }
+
+  // Add source and target anchors to route
+  const fullRoute = [sourceAnchor, ...route, targetAnchor];
+  console.log('[getManHattanPath] Full route:', fullRoute.map(p => `(${p.x}, ${p.y})`));
+
+  // Snap to grid if enabled
+  let finalRoute = fullRoute;
+  if (options.snapToGrid) {
+    // Use step size as grid size for snapping
+    finalRoute = (0, _svg.snapPathToGrid)(fullRoute, options.step);
+  }
+
+  // Simplify path by removing collinear points
+  finalRoute = simplifyPath(finalRoute);
+  console.log('[getManHattanPath] Simplified route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
+
+  // Convert to SVG path string
+  return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
+}
+
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+function simplifyPath(points) {
+  if (points.length <= 2) {
+    return points;
+  }
+  const simplified = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = simplified[simplified.length - 1];
+    const current = points[i];
+    const next = points[i + 1];
+
+    // Check if current point is collinear with prev and next
+    const isHorizontalLine = prev.y === current.y && current.y === next.y;
+    const isVerticalLine = prev.x === current.x && current.x === next.x;
+
+    // Only keep the point if it's not collinear (i.e., it's a corner)
+    if (!isHorizontalLine && !isVerticalLine) {
+      simplified.push(current);
+    }
+  }
+
+  // Always add the last point
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}

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,28 @@
+import { Point } from '../geometry';
+import type { ResolvedOptions, NodeLookup } from '../options';
+/**
+ * ObstacleMap class for managing obstacles in pathfinding
+ * Uses a grid-based spatial partitioning for efficient queries
+ */
+export declare class ObstacleMap {
+    private options;
+    private mapGridSize;
+    private map;
+    private sourceAnchor?;
+    private targetAnchor?;
+    constructor(options: ResolvedOptions);
+    /**
+     * Build obstacle map from node lookup
+     */
+    build(nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string, sourceAnchor?: Point, targetAnchor?: Point): ObstacleMap;
+    /**
+     * Shrink bbox to exclude the area around the anchor point
+     * This allows paths to start/end at the anchor but prevents crossing the node
+     */
+    private shrinkBBoxAroundAnchor;
+    /**
+     * Check if a point is accessible (not inside any obstacle)
+     */
+    isAccessible(point: Point): boolean;
+}
+//# 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;AAG7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;gBAEhB,OAAO,EAAE,eAAe;IAMpC;;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;IAiEd;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6D9B;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;CA2CpC"}

package/cjs/obstacle/ObstacleMap.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObstacleMap = void 0;
+var _geometry = require("../geometry");
+var _utils = require("../utils");
+/**
+ * ObstacleMap class for managing obstacles in pathfinding
+ * Uses a grid-based spatial partitioning for efficient queries
+ */
+class ObstacleMap {
+  options;
+  mapGridSize;
+  map;
+  sourceAnchor;
+  targetAnchor;
+  constructor(options) {
+    this.options = options;
+    this.mapGridSize = 100;
+    this.map = new Map();
+  }
+
+  /**
+   * Build obstacle map from node lookup
+   */
+  build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor) {
+    const {
+      excludeNodes,
+      excludeShapes,
+      excludeTerminals,
+      paddingBox
+    } = this.options;
+
+    // Store anchors for later use in isAccessible
+    this.sourceAnchor = sourceAnchor;
+    this.targetAnchor = targetAnchor;
+
+    // Iterate through all nodes
+    nodeLookup.forEach(node => {
+      // Check if node should be excluded
+      const isExcludedNode = excludeNodes.includes(node.id);
+      const isExcludedShape = node.type ? excludeShapes.includes(node.type) : false;
+      const isSourceTerminal = excludeTerminals.includes('source') && node.id === sourceNodeId;
+      const isTargetTerminal = excludeTerminals.includes('target') && node.id === targetNodeId;
+      const isSource = node.id === sourceNodeId;
+      const isTarget = node.id === targetNodeId;
+
+      // Skip if node should be excluded (but not source/target - we handle them specially)
+      if (isExcludedNode || isExcludedShape || isSourceTerminal || isTargetTerminal) {
+        return;
+      }
+
+      // Calculate node bounding box with padding
+      const position = (0, _utils.getNodePosition)(node);
+      const dimensions = (0, _utils.getNodeDimensions)(node);
+      let bbox = new _geometry.Rectangle(position.x, position.y, dimensions.width, dimensions.height).moveAndExpand(paddingBox);
+
+      // For source and target nodes, add them as full obstacles
+      // We'll handle anchor accessibility in isAccessible() method
+      if (isSource) {
+        console.log('[ObstacleMap] Adding source node as obstacle:');
+        console.log('  Node ID:', node.id);
+        console.log('  BBox:', `(${bbox.x}, ${bbox.y}, ${bbox.width}, ${bbox.height})`);
+        console.log('  Anchor:', sourceAnchor ? `(${sourceAnchor.x}, ${sourceAnchor.y})` : 'none');
+      } else if (isTarget) {
+        console.log('[ObstacleMap] Adding target node as obstacle:');
+        console.log('  Node ID:', node.id);
+        console.log('  BBox:', `(${bbox.x}, ${bbox.y}, ${bbox.width}, ${bbox.height})`);
+        console.log('  Anchor:', targetAnchor ? `(${targetAnchor.x}, ${targetAnchor.y})` : 'none');
+      }
+
+      // Map bbox to grid cells
+      const origin = bbox.getOrigin().snapToGrid(this.mapGridSize);
+      const corner = bbox.getCorner().snapToGrid(this.mapGridSize);
+      for (let x = origin.x; x <= corner.x; x += this.mapGridSize) {
+        for (let y = origin.y; y <= corner.y; y += this.mapGridSize) {
+          const key = new _geometry.Point(x, y).toString();
+          if (!this.map.has(key)) {
+            this.map.set(key, []);
+          }
+          this.map.get(key).push(bbox);
+        }
+      }
+    });
+    return this;
+  }
+
+  /**
+   * Shrink bbox to exclude the area around the anchor point
+   * This allows paths to start/end at the anchor but prevents crossing the node
+   */
+  shrinkBBoxAroundAnchor(bbox, anchor, nodePosition, nodeDimensions) {
+    const tolerance = 1;
+    const step = this.options.step || 10;
+    const margin = step * 3; // Increased margin for better clearance
+
+    // Determine which edge the anchor is on (relative to original node position)
+    const onLeft = Math.abs(anchor.x - nodePosition.x) < tolerance;
+    const onRight = Math.abs(anchor.x - (nodePosition.x + nodeDimensions.width)) < tolerance;
+    const onTop = Math.abs(anchor.y - nodePosition.y) < tolerance;
+    const onBottom = Math.abs(anchor.y - (nodePosition.y + nodeDimensions.height)) < tolerance;
+    console.log('[shrinkBBoxAroundAnchor] Edge detection:');
+    console.log('  anchor.x:', anchor.x, 'nodePosition.x:', nodePosition.x, 'diff:', Math.abs(anchor.x - nodePosition.x));
+    console.log('  anchor.x:', anchor.x, 'nodeRight:', nodePosition.x + nodeDimensions.width, 'diff:', Math.abs(anchor.x - (nodePosition.x + nodeDimensions.width)));
+    console.log('  onLeft:', onLeft, 'onRight:', onRight, 'onTop:', onTop, 'onBottom:', onBottom);
+    console.log('  margin:', margin);
+
+    // Shrink bbox based on anchor position
+    if (onLeft) {
+      // Anchor on left edge - exclude left portion
+      return new _geometry.Rectangle(bbox.x + margin, bbox.y, Math.max(0, bbox.width - margin), bbox.height);
+    } else if (onRight) {
+      // Anchor on right edge - exclude right portion
+      return new _geometry.Rectangle(bbox.x, bbox.y, Math.max(0, bbox.width - margin), bbox.height);
+    } else if (onTop) {
+      // Anchor on top edge - exclude top portion
+      return new _geometry.Rectangle(bbox.x, bbox.y + margin, bbox.width, Math.max(0, bbox.height - margin));
+    } else if (onBottom) {
+      // Anchor on bottom edge - exclude bottom portion
+      return new _geometry.Rectangle(bbox.x, bbox.y, bbox.width, Math.max(0, bbox.height - margin));
+    }
+
+    // If anchor is not on an edge, return original bbox
+    return bbox;
+  }
+
+  /**
+   * Check if a point is accessible (not inside any obstacle)
+   */
+  isAccessible(point) {
+    const key = point.clone().snapToGrid(this.mapGridSize).toString();
+    const rects = this.map.get(key);
+    if (!rects) {
+      return true;
+    }
+
+    // Check if point is near an anchor - if so, allow it
+    const margin = (this.options.step || 10) * 3;
+    if (this.sourceAnchor) {
+      const distToSource = Math.abs(point.x - this.sourceAnchor.x) + Math.abs(point.y - this.sourceAnchor.y);
+      if (distToSource < margin) {
+        console.log(`[isAccessible] Point (${point.x}, ${point.y}): accessible (near source anchor)`);
+        return true;
+      }
+    }
+    if (this.targetAnchor) {
+      const distToTarget = Math.abs(point.x - this.targetAnchor.x) + Math.abs(point.y - this.targetAnchor.y);
+      if (distToTarget < margin) {
+        console.log(`[isAccessible] Point (${point.x}, ${point.y}): accessible (near target anchor)`);
+        return true;
+      }
+    }
+    const accessible = rects.every(rect => !rect.containsPoint(point));
+
+    // Debug: log points on the direct path
+    if (point.y === 40 && point.x >= 0 && point.x <= 545) {
+      console.log(`[isAccessible] Point (${point.x}, ${point.y}): ${accessible ? 'accessible' : 'BLOCKED'}`);
+      if (!accessible) {
+        rects.forEach((rect, i) => {
+          if (rect.containsPoint(point)) {
+            console.log(`  Blocked by rect ${i}: (${rect.x}, ${rect.y}, ${rect.width}, ${rect.height})`);
+          }
+        });
+      }
+    }
+    return accessible;
+  }
+}
+exports.ObstacleMap = ObstacleMap;

package/cjs/obstacle/index.d.ts

@@ -0,0 +1,2 @@
+export { ObstacleMap } from './ObstacleMap';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/obstacle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/cjs/obstacle/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ObstacleMap", {
+  enumerable: true,
+  get: function () {
+    return _ObstacleMap.ObstacleMap;
+  }
+});
+var _ObstacleMap = require("./ObstacleMap");

package/cjs/options/defaults.d.ts

@@ -0,0 +1,16 @@
+import { Point } from '../geometry';
+import type { ManhattanRouterOptions } from './types';
+/**
+ * Default configuration for Manhattan router
+ */
+export declare const defaults: Required<Omit<ManhattanRouterOptions, 'fallbackRoute'>>;
+/**
+ * Direction map - maps direction names to unit vectors
+ */
+export declare const directionMap: {
+    top: Point;
+    right: Point;
+    bottom: Point;
+    left: Point;
+};
+//# sourceMappingURL=defaults.d.ts.map

package/cjs/options/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/options/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAa,MAAM,SAAS,CAAA;AAEhE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,sBAAsB,EAAE,eAAe,CAAC,CAkB5E,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}