@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/utils/route.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCost = getCost;
+exports.getKey = getKey;
+exports.normalizePoint = normalizePoint;
+exports.reconstructRoute = reconstructRoute;
+var _geometry = require("../geometry");
+/**
+ * Normalize a point to a unit direction vector
+ */
+function normalizePoint(point) {
+  return new _geometry.Point(point.x === 0 ? 0 : Math.abs(point.x) / point.x, point.y === 0 ? 0 : Math.abs(point.y) / point.y);
+}
+
+/**
+ * Get string key for a point
+ */
+function getKey(point) {
+  return point.toString();
+}
+
+/**
+ * Calculate minimum Manhattan distance from a point to multiple anchors
+ */
+function getCost(from, anchors) {
+  let min = Infinity;
+  for (const anchor of anchors) {
+    const dist = from.manhattanDistance(anchor);
+    if (dist < min) {
+      min = dist;
+    }
+  }
+  return min;
+}
+
+/**
+ * Reconstruct route by concatenating points with their parents
+ * Removes redundant points in the same direction
+ */
+function reconstructRoute(parents, points, tailPoint, startPoint, endPoint) {
+  const route = [];
+  let prevDiff = normalizePoint(endPoint.diff(tailPoint));
+
+  // tailPoint is assumed to be aligned already
+  let currentKey = getKey(tailPoint);
+  let parent = parents.get(currentKey);
+  let point;
+  let iterationCount = 0;
+  const maxIterations = 10000; // Safety limit
+
+  while (parent && iterationCount < maxIterations) {
+    iterationCount++;
+    if (iterationCount % 100 === 0) {}
+
+    // point is assumed to be aligned already
+    point = points.get(currentKey);
+    if (point) {
+      const diff = normalizePoint(point.diff(parent));
+      if (!diff.equals(prevDiff)) {
+        route.unshift(point);
+        prevDiff = diff;
+      }
+    }
+
+    // parent is assumed to be aligned already
+    const nextKey = getKey(parent);
+
+    // CRITICAL: Check for circular reference
+    if (nextKey === currentKey) {
+      console.error('[reconstructRoute] CIRCULAR REFERENCE DETECTED! currentKey === nextKey:', currentKey);
+      break;
+    }
+    currentKey = nextKey;
+    parent = parents.get(currentKey);
+  }
+  if (iterationCount >= maxIterations) {
+    console.error('[reconstructRoute] MAX ITERATIONS REACHED! Possible infinite loop.');
+  }
+
+  // leadPoint is assumed to be aligned already
+  const leadPoint = points.get(currentKey);
+  if (leadPoint) {
+    const fromDiff = normalizePoint(leadPoint.diff(startPoint));
+    if (!fromDiff.equals(prevDiff)) {
+      route.unshift(leadPoint);
+    }
+  }
+  return route;
+}

package/esm/geometry/Line.d.ts

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

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

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

package/esm/geometry/Point.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Point class representing a 2D coordinate
+ */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    /**
+     * Create a copy of this point
+     */
+    clone(): Point;
+    /**
+     * Check if this point equals another point
+     */
+    equals(other: Point): boolean;
+    /**
+     * Translate this point by dx and dy
+     */
+    translate(dx: number, dy: number): Point;
+    /**
+     * Round coordinates to specified precision
+     */
+    round(precision: number): Point;
+    /**
+     * Calculate Manhattan distance to another point
+     */
+    manhattanDistance(other: Point): number;
+    /**
+     * Calculate angle (in degrees) from this point to another point
+     */
+    theta(other: Point): number;
+    /**
+     * Calculate the difference vector from this point to another
+     */
+    diff(other: Point): Point;
+    /**
+     * Convert point to string representation
+     */
+    toString(): string;
+    /**
+     * Snap point to grid
+     */
+    snapToGrid(gridSize: number): Point;
+    /**
+     * Calculate squared distance to another point (for performance)
+     */
+    squaredDistance(other: Point): number;
+}
+//# sourceMappingURL=Point.d.ts.map

package/esm/geometry/Point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Point.d.ts","sourceRoot":"","sources":["../../src/geometry/Point.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,KAAK;IAChB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;gBAEG,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAKhC;;OAEG;IACH,KAAK,IAAI,KAAK;IAId;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI7B;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK;IAIxC;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK;IAQ/B;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAIvC;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAO3B;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAIzB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK;IAOnC;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;CAKtC"}

package/esm/geometry/Rectangle.d.ts

@@ -0,0 +1,41 @@
+import { Point } from './Point';
+/**
+ * Rectangle class representing a bounding box
+ */
+export declare class Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    /**
+     * Create a copy of this rectangle
+     */
+    clone(): Rectangle;
+    /**
+     * Get the center point of the rectangle
+     */
+    getCenter(): Point;
+    /**
+     * Get the origin (top-left) point of the rectangle
+     */
+    getOrigin(): Point;
+    /**
+     * Get the corner (bottom-right) point of the rectangle
+     */
+    getCorner(): Point;
+    /**
+     * Check if a point is contained within this rectangle (interior only, excluding edges)
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     * Move and expand the rectangle by a box offset
+     */
+    moveAndExpand(box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): Rectangle;
+}
+//# sourceMappingURL=Rectangle.d.ts.map

package/esm/geometry/Rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rectangle.d.ts","sourceRoot":"","sources":["../../src/geometry/Rectangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B;;GAEG;AACH,qBAAa,SAAS;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;gBAEF,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAO/D;;OAEG;IACH,KAAK,IAAI,SAAS;IAIlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAOlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAIlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAIlB;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IASpC;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;CAQvF"}

package/esm/geometry/collision.d.ts

@@ -0,0 +1,15 @@
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+/**
+ * Check if a line segment intersects with a rectangle
+ */
+export declare function lineSegmentIntersectsRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if a line segment crosses through a rectangle (not just touching edges)
+ */
+export declare function lineSegmentCrossesRect(p1: Point, p2: Point, rect: Rectangle): boolean;
+/**
+ * Check if two line segments intersect
+ */
+export declare function lineSegmentsIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean;
+//# sourceMappingURL=collision.d.ts.map

package/esm/geometry/collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/geometry/collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAwBxF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAsBrF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAgBzF"}

package/esm/geometry/index.d.ts

@@ -0,0 +1,5 @@
+export { Point } from './Point';
+export { Rectangle } from './Rectangle';
+export { Line } from './Line';
+export { lineSegmentIntersectsRect, lineSegmentCrossesRect, lineSegmentsIntersect } from './collision';
+//# sourceMappingURL=index.d.ts.map

package/esm/geometry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/esm/getManHattanPath.d.ts

@@ -0,0 +1,53 @@
+import { Position } from '@xyflow/react';
+import type { ManhattanRouterOptions, NodeLookup } from './options';
+/**
+ * Parameters for getManHattanPath function
+ */
+export interface GetManHattanPathParams {
+    /**
+     * Source node ID
+     */
+    sourceNodeId: string;
+    /**
+     * Target node ID
+     */
+    targetNodeId: string;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
+    /**
+     * 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":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;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,CAydvE"}

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/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/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;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"}

package/esm/obstacle/QuadTree.d.ts

@@ -0,0 +1,119 @@
+/**
+ * QuadTree implementation for efficient spatial queries
+ * Feature: manhattan-optimization
+ *
+ * A QuadTree is a tree data structure that recursively subdivides 2D space
+ * into four quadrants. This enables O(log n) spatial queries instead of O(n).
+ */
+import { Point, Rectangle } from '../geometry';
+/**
+ * Item stored in the QuadTree
+ */
+export interface QuadTreeItem<T> {
+    bounds: Rectangle;
+    data: T;
+}
+/**
+ * QuadTree configuration
+ */
+export interface QuadTreeConfig {
+    /** Maximum items per node before splitting */
+    maxItems: number;
+    /** Maximum depth of the tree */
+    maxDepth: number;
+    /** Minimum node size (prevents infinite subdivision) */
+    minSize: number;
+}
+/**
+ * QuadTree node for spatial partitioning
+ */
+export declare class QuadTree<T> {
+    private bounds;
+    private items;
+    private children;
+    private depth;
+    private config;
+    constructor(bounds: Rectangle, config?: Partial<QuadTreeConfig>, depth?: number);
+    /**
+     * Insert an item into the QuadTree
+     */
+    insert(item: QuadTreeItem<T>): boolean;
+    /**
+     * Insert an item with just bounds and data
+     */
+    insertRect(bounds: Rectangle, data: T): boolean;
+    /**
+     * Query all items that intersect with the given bounds
+     */
+    query(bounds: Rectangle): QuadTreeItem<T>[];
+    /**
+     * Query all items that contain the given point
+     */
+    queryPoint(point: Point): QuadTreeItem<T>[];
+    /**
+     * Get all items in the tree
+     */
+    getAllItems(): QuadTreeItem<T>[];
+    /**
+     * Clear all items from the tree
+     */
+    clear(): void;
+    /**
+     * Get the total number of items in the tree
+     */
+    get size(): number;
+    /**
+     * Get the depth of the tree
+     */
+    getMaxDepth(): number;
+    /**
+     * Internal query implementation
+     */
+    private queryInternal;
+    /**
+     * Internal point query implementation
+     */
+    private queryPointInternal;
+    /**
+     * Check if this node should split
+     */
+    private shouldSplit;
+    /**
+     * Split this node into four children
+     */
+    private split;
+    /**
+     * Insert item into appropriate children
+     */
+    private insertIntoChildren;
+    /**
+     * Check if a rectangle intersects this node's bounds
+     */
+    private intersects;
+    /**
+     * Check if two rectangles intersect
+     */
+    private rectanglesIntersect;
+    /**
+     * Check if this node's bounds contain a point
+     */
+    private containsPoint;
+    /**
+     * Get statistics about the tree
+     */
+    getStats(): {
+        totalItems: number;
+        maxDepth: number;
+        nodeCount: number;
+        itemsPerNode: number;
+    };
+    private collectStats;
+}
+/**
+ * Create a QuadTree with bounds that cover all given rectangles
+ */
+export declare function createQuadTreeFromRects<T>(items: Array<{
+    bounds: Rectangle;
+    data: T;
+}>, config?: Partial<QuadTreeConfig>): QuadTree<T>;
+//# sourceMappingURL=QuadTree.d.ts.map

package/esm/obstacle/QuadTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuadTree.d.ts","sourceRoot":"","sources":["../../src/obstacle/QuadTree.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE9C;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,CAAC,CAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAA;CAChB;AAWD;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAgB;gBAG5B,MAAM,EAAE,SAAS,EACjB,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,EACpC,KAAK,GAAE,MAAU;IASnB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAsBtC;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAI/C;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAM3C;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAM3C;;OAEG;IACH,WAAW,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE;IAYhC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAUjB;IAED;;OAEG;IACH,WAAW,IAAI,MAAM;IAarB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,KAAK;IA2Cb;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,QAAQ,IAAI;QACV,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;QACjB,YAAY,EAAE,MAAM,CAAA;KACrB;IAcD,OAAO,CAAC,YAAY;CAerB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,EAC5C,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAC/B,QAAQ,CAAC,CAAC,CAAC,CAkCb"}

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/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' | 'sourcePosition' | 'targetPosition' | 'performance' | 'adaptiveStep' | 'debug'>>;
+/**
+ * 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,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,aAAa,GAAG,cAAc,GAAG,OAAO,CAAC,CAkB7J,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}

package/esm/options/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './defaults';
+export * from './resolver';
+//# sourceMappingURL=index.d.ts.map

package/esm/options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/options/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/esm/options/resolver.d.ts

@@ -0,0 +1,10 @@
+import type { ManhattanRouterOptions, ResolvedOptions } from './types';
+/**
+ * Normalize angle to 0-360 range
+ */
+export declare function normalizeAngle(angle: number): number;
+/**
+ * Resolve options by merging user options with defaults
+ */
+export declare function resolveOptions(options?: ManhattanRouterOptions): ResolvedOptions;
+//# sourceMappingURL=resolver.d.ts.map

package/esm/options/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/options/resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAkC,MAAM,SAAS,CAAA;AAmCtG;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAgGD;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA4EpF"}