@rxflow/manhattan 0.0.1-alpha.0

package/esm/getManHattanPath.d.ts

@@ -0,0 +1,60 @@
+import type { ManhattanRouterOptions, NodeLookup } from './options';
+/**
+ * Parameters for getManHattanPath function
+ */
+export interface GetManHattanPathParams {
+    /**
+     * Source node ID
+     */
+    sourceNodeId: string;
+    /**
+     * Target node ID
+     */
+    targetNodeId: string;
+    /**
+     * Source anchor position (where the edge starts)
+     */
+    sourcePosition: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Target anchor position (where the edge ends)
+     */
+    targetPosition: {
+        x: number;
+        y: number;
+    };
+    /**
+     * ReactFlow node lookup map
+     */
+    nodeLookup: NodeLookup;
+    /**
+     * Router options
+     */
+    options?: ManhattanRouterOptions;
+}
+/**
+ * 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']
+ *   }
+ * })
+ * ```
+ */
+export declare function getManHattanPath(params: GetManHattanPathParams): string;
+//# sourceMappingURL=getManHattanPath.d.ts.map

package/esm/getManHattanPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAOnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;OAEG;IACH,cAAc,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAExC;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CA4PvE"}

package/esm/getManHattanPath.js

@@ -0,0 +1,291 @@
+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; }
+import { Point, Rectangle } from "./geometry";
+import { resolveOptions } from "./options";
+import { ObstacleMap } from "./obstacle";
+import { findRoute } from "./pathfinder";
+import { pointsToPath, snapPathToGrid } from "./svg";
+import { getNodeDimensions, getNodePosition } from "./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']
+ *   }
+ * })
+ * ```
+ */
+export function getManHattanPath(params) {
+  var sourceNodeId = params.sourceNodeId,
+    targetNodeId = params.targetNodeId,
+    sourcePosition = params.sourcePosition,
+    targetPosition = params.targetPosition,
+    nodeLookup = params.nodeLookup,
+    _params$options = params.options,
+    userOptions = _params$options === void 0 ? {} : _params$options;
+
+  // Resolve options
+  var options = resolveOptions(userOptions);
+
+  // Get source and target nodes
+  var sourceNode = nodeLookup.get(sourceNodeId);
+  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');
+    var start = new Point(sourcePosition.x, sourcePosition.y);
+    var end = new Point(targetPosition.x, targetPosition.y);
+    return pointsToPath([start, end], options.precision);
+  }
+
+  // Get node dimensions using ReactFlow's priority logic
+  var sourceDimensions = getNodeDimensions(sourceNode);
+  var targetDimensions = getNodeDimensions(targetNode);
+
+  // Get absolute positions from internals
+  var sourcePos = getNodePosition(sourceNode);
+  var targetPos = getNodePosition(targetNode);
+
+  // Calculate bounding boxes
+  var sourceBBox = new Rectangle(sourcePos.x, sourcePos.y, sourceDimensions.width, sourceDimensions.height);
+  var targetBBox = new Rectangle(targetPos.x, targetPos.y, targetDimensions.width, targetDimensions.height);
+
+  // Create anchor points
+  var sourceAnchor = new Point(sourcePosition.x, sourcePosition.y);
+  var targetAnchor = new Point(targetPosition.x, targetPosition.y);
+
+  // Build obstacle map with anchor information
+  var obstacleMap = new ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
+
+  // Find route
+  var route = 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(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, ")"));
+
+  // Remove extension points from route that were added by getRectPoints
+  // We will add our own with fixed step distance
+  var step = options.step;
+  var tolerance = 1;
+
+  // Check if first point is an extension point from source
+  if (route.length > 0) {
+    var firstPoint = route[0];
+    var onLeft = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
+    var onRight = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
+    var onTop = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
+    var onBottom = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
+
+    // Check if firstPoint is close to source anchor (indicating it's an extension point)
+    var 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) {
+    var lastPoint = route[route.length - 1];
+    var _onLeft = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
+    var _onRight = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    var _onTop = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
+    var _onBottom = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
+
+    // Check if lastPoint is close to target anchor (indicating it's an extension point)
+    var 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) {
+    var _firstPoint = route[0];
+
+    // Determine which edge the source anchor is on
+    var _onLeft2 = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
+    var _onRight2 = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
+    var _onTop2 = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
+    var _onBottom2 = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
+
+    // Insert extension point and corner point to ensure orthogonal path
+    if (_onRight2) {
+      // Anchor on right edge - extend right by fixed step
+      var extendX = sourceAnchor.x + step;
+      var extensionPoint = new Point(extendX, sourceAnchor.y);
+      // Check if we need a corner point
+      if (Math.abs(extensionPoint.y - _firstPoint.y) > tolerance) {
+        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 fixed step
+      var _extendX = sourceAnchor.x - step;
+      var _extensionPoint = new Point(_extendX, sourceAnchor.y);
+      if (Math.abs(_extensionPoint.y - _firstPoint.y) > tolerance) {
+        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 fixed step
+      var extendY = sourceAnchor.y + step;
+      var _extensionPoint2 = new Point(sourceAnchor.x, extendY);
+      if (Math.abs(_extensionPoint2.x - _firstPoint.x) > tolerance) {
+        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 fixed step
+      var _extendY = sourceAnchor.y - step;
+      var _extensionPoint3 = new Point(sourceAnchor.x, _extendY);
+      if (Math.abs(_extensionPoint3.x - _firstPoint.x) > tolerance) {
+        route.unshift(new Point(_firstPoint.x, _extendY));
+      }
+      route.unshift(_extensionPoint3);
+      console.log('[getManHattanPath] Inserted source extension (up):', "(".concat(sourceAnchor.x, ", ").concat(_extendY, ")"));
+    }
+  }
+
+  // Insert extension point at target - always extend away from node edge by fixed step distance
+  if (route.length > 0) {
+    var _step = options.step;
+    var _tolerance = 1;
+    var _lastPoint = route[route.length - 1];
+
+    // Determine which edge the target anchor is on
+    var _onLeft3 = Math.abs(targetAnchor.x - targetBBox.x) < _tolerance;
+    var _onRight3 = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < _tolerance;
+    var _onTop3 = Math.abs(targetAnchor.y - targetBBox.y) < _tolerance;
+    var _onBottom3 = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < _tolerance;
+
+    // Insert extension point and corner point to ensure orthogonal path
+    if (_onLeft3) {
+      // Anchor on left edge - extend left by fixed step
+      var _extendX2 = targetAnchor.x - _step;
+      var _extensionPoint4 = new Point(_extendX2, targetAnchor.y);
+      if (Math.abs(_extensionPoint4.y - _lastPoint.y) > _tolerance) {
+        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 fixed step
+      var _extendX3 = targetAnchor.x + _step;
+      var _extensionPoint5 = new Point(_extendX3, targetAnchor.y);
+      if (Math.abs(_extensionPoint5.y - _lastPoint.y) > _tolerance) {
+        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 fixed step
+      var _extendY2 = targetAnchor.y - _step;
+      var _extensionPoint6 = new Point(targetAnchor.x, _extendY2);
+      if (Math.abs(_extensionPoint6.x - _lastPoint.x) > _tolerance) {
+        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 fixed step
+      var _extendY3 = targetAnchor.y + _step;
+      var _extensionPoint7 = new Point(targetAnchor.x, _extendY3);
+      if (Math.abs(_extensionPoint7.x - _lastPoint.x) > _tolerance) {
+        route.push(new Point(_lastPoint.x, _extendY3));
+      }
+      route.push(_extensionPoint7);
+      console.log('[getManHattanPath] Inserted target extension (down):', "(".concat(targetAnchor.x, ", ").concat(_extendY3, ")"));
+    }
+  }
+
+  // Add source and target anchors to route
+  var fullRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
+  console.log('[getManHattanPath] Full route:', fullRoute.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+
+  // Snap to grid if enabled
+  var finalRoute = fullRoute;
+  if (options.snapToGrid) {
+    // Use step size as grid size for snapping
+    finalRoute = snapPathToGrid(fullRoute, options.step);
+  }
+
+  // Simplify path by removing collinear points
+  finalRoute = simplifyPath(finalRoute);
+  console.log('[getManHattanPath] Simplified route:', finalRoute.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+
+  // Convert to SVG path string
+  return pointsToPath(finalRoute, options.precision, options.borderRadius);
+}
+
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+function simplifyPath(points) {
+  if (points.length <= 2) {
+    return points;
+  }
+  var simplified = [points[0]];
+  for (var i = 1; i < points.length - 1; i++) {
+    var prev = simplified[simplified.length - 1];
+    var current = points[i];
+    var next = points[i + 1];
+
+    // Check if current point is collinear with prev and next
+    var isHorizontalLine = prev.y === current.y && current.y === next.y;
+    var 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/esm/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/esm/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/esm/index.js

@@ -0,0 +1,24 @@
+/**
+ * ReactFlow Manhattan Router
+ * 
+ * A Manhattan routing algorithm adapted for ReactFlow from AntV X6.
+ * Generates orthogonal (right-angle) paths that intelligently avoid obstacles.
+ * 
+ * @packageDocumentation
+ */
+
+// Main function
+export { getManHattanPath } from "./getManHattanPath";
+
+// Types
+
+// Geometry classes (for advanced usage)
+export { Point, Rectangle, Line } from "./geometry";
+
+// Utility functions (for advanced usage)
+export { getGrid, align, snapToGrid, getDirectionAngle, getDirectionChange, getRectPoints, getCost, getKey, reconstructRoute, normalizePoint, getNodeDimensions, getNodePosition } from "./utils";
+
+// Export types for utility functions
+
+// SVG utilities (for advanced usage)
+export { pointsToPath, snapPathToGrid } from "./svg";

package/esm/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/esm/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/esm/obstacle/ObstacleMap.js

@@ -0,0 +1,183 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 { Point, Rectangle } from "../geometry";
+import { getNodePosition, getNodeDimensions } from "../utils";
+
+/**
+ * ObstacleMap class for managing obstacles in pathfinding
+ * Uses a grid-based spatial partitioning for efficient queries
+ */
+export var ObstacleMap = /*#__PURE__*/function () {
+  function ObstacleMap(options) {
+    _classCallCheck(this, ObstacleMap);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "mapGridSize", void 0);
+    _defineProperty(this, "map", void 0);
+    _defineProperty(this, "sourceAnchor", void 0);
+    _defineProperty(this, "targetAnchor", void 0);
+    this.options = options;
+    this.mapGridSize = 100;
+    this.map = new Map();
+  }
+
+  /**
+   * Build obstacle map from node lookup
+   */
+  _createClass(ObstacleMap, [{
+    key: "build",
+    value: function build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor) {
+      var _this = this;
+      var _this$options = this.options,
+        excludeNodes = _this$options.excludeNodes,
+        excludeShapes = _this$options.excludeShapes,
+        excludeTerminals = _this$options.excludeTerminals,
+        paddingBox = _this$options.paddingBox;
+
+      // Store anchors for later use in isAccessible
+      this.sourceAnchor = sourceAnchor;
+      this.targetAnchor = targetAnchor;
+
+      // Iterate through all nodes
+      nodeLookup.forEach(function (node) {
+        // Check if node should be excluded
+        var isExcludedNode = excludeNodes.includes(node.id);
+        var isExcludedShape = node.type ? excludeShapes.includes(node.type) : false;
+        var isSourceTerminal = excludeTerminals.includes('source') && node.id === sourceNodeId;
+        var isTargetTerminal = excludeTerminals.includes('target') && node.id === targetNodeId;
+        var isSource = node.id === sourceNodeId;
+        var 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
+        var position = getNodePosition(node);
+        var dimensions = getNodeDimensions(node);
+        var bbox = new 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:', "(".concat(bbox.x, ", ").concat(bbox.y, ", ").concat(bbox.width, ", ").concat(bbox.height, ")"));
+          console.log('  Anchor:', sourceAnchor ? "(".concat(sourceAnchor.x, ", ").concat(sourceAnchor.y, ")") : 'none');
+        } else if (isTarget) {
+          console.log('[ObstacleMap] Adding target node as obstacle:');
+          console.log('  Node ID:', node.id);
+          console.log('  BBox:', "(".concat(bbox.x, ", ").concat(bbox.y, ", ").concat(bbox.width, ", ").concat(bbox.height, ")"));
+          console.log('  Anchor:', targetAnchor ? "(".concat(targetAnchor.x, ", ").concat(targetAnchor.y, ")") : 'none');
+        }
+
+        // Map bbox to grid cells
+        var origin = bbox.getOrigin().snapToGrid(_this.mapGridSize);
+        var corner = bbox.getCorner().snapToGrid(_this.mapGridSize);
+        for (var x = origin.x; x <= corner.x; x += _this.mapGridSize) {
+          for (var y = origin.y; y <= corner.y; y += _this.mapGridSize) {
+            var key = new 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
+     */
+  }, {
+    key: "shrinkBBoxAroundAnchor",
+    value: function shrinkBBoxAroundAnchor(bbox, anchor, nodePosition, nodeDimensions) {
+      var tolerance = 1;
+      var step = this.options.step || 10;
+      var margin = step * 3; // Increased margin for better clearance
+
+      // Determine which edge the anchor is on (relative to original node position)
+      var onLeft = Math.abs(anchor.x - nodePosition.x) < tolerance;
+      var onRight = Math.abs(anchor.x - (nodePosition.x + nodeDimensions.width)) < tolerance;
+      var onTop = Math.abs(anchor.y - nodePosition.y) < tolerance;
+      var 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 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 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 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 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)
+     */
+  }, {
+    key: "isAccessible",
+    value: function isAccessible(point) {
+      var key = point.clone().snapToGrid(this.mapGridSize).toString();
+      var rects = this.map.get(key);
+      if (!rects) {
+        return true;
+      }
+
+      // Check if point is near an anchor - if so, allow it
+      var margin = (this.options.step || 10) * 3;
+      if (this.sourceAnchor) {
+        var distToSource = Math.abs(point.x - this.sourceAnchor.x) + Math.abs(point.y - this.sourceAnchor.y);
+        if (distToSource < margin) {
+          console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): accessible (near source anchor)"));
+          return true;
+        }
+      }
+      if (this.targetAnchor) {
+        var distToTarget = Math.abs(point.x - this.targetAnchor.x) + Math.abs(point.y - this.targetAnchor.y);
+        if (distToTarget < margin) {
+          console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): accessible (near target anchor)"));
+          return true;
+        }
+      }
+      var accessible = rects.every(function (rect) {
+        return !rect.containsPoint(point);
+      });
+
+      // Debug: log points on the direct path
+      if (point.y === 40 && point.x >= 0 && point.x <= 545) {
+        console.log("[isAccessible] Point (".concat(point.x, ", ").concat(point.y, "): ").concat(accessible ? 'accessible' : 'BLOCKED'));
+        if (!accessible) {
+          rects.forEach(function (rect, i) {
+            if (rect.containsPoint(point)) {
+              console.log("  Blocked by rect ".concat(i, ": (").concat(rect.x, ", ").concat(rect.y, ", ").concat(rect.width, ", ").concat(rect.height, ")"));
+            }
+          });
+        }
+      }
+      return accessible;
+    }
+  }]);
+  return ObstacleMap;
+}();

package/esm/obstacle/index.d.ts

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

package/esm/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/esm/obstacle/index.js

@@ -0,0 +1 @@
+export { ObstacleMap } from "./ObstacleMap";

package/esm/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/esm/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"}