@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/cjs/utils/pathValidation.js

@@ -1,130 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.pathIntersectsObstacles = pathIntersectsObstacles;
-var _geometry = require("../geometry");
-var _node = require("./node");
-/**
- * Get node bounding box
- */
-function getNodeBBox(nodeId, nodeLookup) {
-  const node = nodeLookup.get(nodeId);
-  if (!node) return null;
-  const dimensions = (0, _node.getNodeDimensions)(node);
-  const position = (0, _node.getNodePosition)(node);
-  return new _geometry.Rectangle(position.x, position.y, dimensions.width, dimensions.height);
-}
-
-/**
- * Find unique intersection points between a line segment and a rectangle
- * Returns array of intersection points (deduplicated)
- */
-function findSegmentRectIntersections(p1, p2, rect) {
-  const intersections = [];
-  const tolerance = 0.01;
-
-  // Define rectangle edges
-  const edges = [{
-    start: new _geometry.Point(rect.x, rect.y),
-    end: new _geometry.Point(rect.x + rect.width, rect.y)
-  },
-  // Top
-  {
-    start: new _geometry.Point(rect.x + rect.width, rect.y),
-    end: new _geometry.Point(rect.x + rect.width, rect.y + rect.height)
-  },
-  // Right
-  {
-    start: new _geometry.Point(rect.x + rect.width, rect.y + rect.height),
-    end: new _geometry.Point(rect.x, rect.y + rect.height)
-  },
-  // Bottom
-  {
-    start: new _geometry.Point(rect.x, rect.y + rect.height),
-    end: new _geometry.Point(rect.x, rect.y)
-  } // Left
-  ];
-
-  // Find intersection point with each edge
-  for (const edge of edges) {
-    const intersection = getLineSegmentIntersection(p1, p2, edge.start, edge.end);
-    if (intersection) {
-      // Check if this point is already in the list (avoid duplicates at corners)
-      const isDuplicate = intersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
-      if (!isDuplicate) {
-        intersections.push(intersection);
-      }
-    }
-  }
-  return intersections;
-}
-
-/**
- * Get intersection point between two line segments (if exists)
- */
-function getLineSegmentIntersection(p1, p2, p3, p4) {
-  const d1 = direction(p3, p4, p1);
-  const d2 = direction(p3, p4, p2);
-  const d3 = direction(p1, p2, p3);
-  const d4 = direction(p1, p2, p4);
-  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
-    // Lines intersect, calculate intersection point
-    const t = ((p3.x - p1.x) * (p3.y - p4.y) - (p3.y - p1.y) * (p3.x - p4.x)) / ((p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x));
-    return new _geometry.Point(p1.x + t * (p2.x - p1.x), p1.y + t * (p2.y - p1.y));
-  }
-
-  // Check collinear cases
-  if (d1 === 0 && onSegment(p3, p1, p4)) return p1.clone();
-  if (d2 === 0 && onSegment(p3, p2, p4)) return p2.clone();
-  if (d3 === 0 && onSegment(p1, p3, p2)) return p3.clone();
-  if (d4 === 0 && onSegment(p1, p4, p2)) return p4.clone();
-  return null;
-}
-function direction(p1, p2, p3) {
-  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
-}
-function onSegment(p1, p2, p3) {
-  return p2.x >= Math.min(p1.x, p3.x) && p2.x <= Math.max(p1.x, p3.x) && p2.y >= Math.min(p1.y, p3.y) && p2.y <= Math.max(p1.y, p3.y);
-}
-
-/**
- * Check if a path intersects with any obstacles (nodes)
- * A path is considered to intersect if it has >= 2 unique intersection points with a node
- *
- * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
- * into line segments, so this function works correctly with curved paths
- */
-function pathIntersectsObstacles(pathPoints, nodeLookup) {
-  const tolerance = 0.01;
-
-  // Iterate through all nodes (including source and target)
-  for (const [nodeId] of nodeLookup) {
-    const nodeBBox = getNodeBBox(nodeId, nodeLookup);
-    if (!nodeBBox) continue;
-    const allIntersections = [];
-
-    // Collect all unique intersection points for this node
-    for (let i = 0; i < pathPoints.length - 1; i++) {
-      const p1 = pathPoints[i];
-      const p2 = pathPoints[i + 1];
-      const segmentIntersections = findSegmentRectIntersections(p1, p2, nodeBBox);
-
-      // Add to global list, avoiding duplicates
-      for (const intersection of segmentIntersections) {
-        const isDuplicate = allIntersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
-        if (!isDuplicate) {
-          allIntersections.push(intersection);
-        }
-      }
-    }
-
-    // If path has 2 or more unique intersections with this node, it crosses through it
-    if (allIntersections.length >= 2) {
-      console.log(`[pathIntersectsObstacles] Path crosses node ${nodeId} with ${allIntersections.length} intersections`);
-      return true;
-    }
-  }
-  return false;
-}

package/cjs/utils/rect.d.ts

@@ -1,9 +0,0 @@
-import { Point, Rectangle } from '../geometry';
-import type { ResolvedOptions, Direction } from '../options';
-import type { Grid } from './grid';
-/**
- * Get points around a rectangle taking given directions into account
- * Lines are drawn from anchor in given directions, intersections recorded
- */
-export declare function getRectPoints(anchor: Point, bbox: Rectangle, directionList: Direction[], grid: Grid, options: ResolvedOptions): Point[];
-//# sourceMappingURL=rect.d.ts.map

package/cjs/utils/rect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../src/utils/rect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAQ,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AA6ClC;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EACb,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,SAAS,EAAE,EAC1B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,CAsET"}

package/cjs/utils/rect.js

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getRectPoints = getRectPoints;
-var _geometry = require("../geometry");
-var _grid = require("./grid");
-/**
- * Check if a point is on the edge of a rectangle
- */
-function isPointOnRectangleEdge(point, bbox, tolerance = 0.01) {
-  const onLeft = Math.abs(point.x - bbox.x) < tolerance;
-  const onRight = Math.abs(point.x - (bbox.x + bbox.width)) < tolerance;
-  const onTop = Math.abs(point.y - bbox.y) < tolerance;
-  const onBottom = Math.abs(point.y - (bbox.y + bbox.height)) < tolerance;
-  const withinVerticalBounds = point.y >= bbox.y - tolerance && point.y <= bbox.y + bbox.height + tolerance;
-  const withinHorizontalBounds = point.x >= bbox.x - tolerance && point.x <= bbox.x + bbox.width + tolerance;
-  return (onLeft || onRight) && withinVerticalBounds || (onTop || onBottom) && withinHorizontalBounds;
-}
-
-/**
- * Check if a direction points outward from the rectangle edge where the anchor is located
- */
-function isDirectionOutward(anchor, bbox, direction, tolerance = 0.01) {
-  const onLeft = Math.abs(anchor.x - bbox.x) < tolerance;
-  const onRight = Math.abs(anchor.x - (bbox.x + bbox.width)) < tolerance;
-  const onTop = Math.abs(anchor.y - bbox.y) < tolerance;
-  const onBottom = Math.abs(anchor.y - (bbox.y + bbox.height)) < tolerance;
-
-  // Only allow outward directions from the edge
-  if (onLeft && direction.x < 0) return true;
-  if (onRight && direction.x > 0) return true;
-  if (onTop && direction.y < 0) return true;
-  if (onBottom && direction.y > 0) return true;
-
-  // For corners, allow both perpendicular directions
-  if ((onLeft || onRight) && direction.x === 0) return true;
-  if ((onTop || onBottom) && direction.y === 0) return true;
-  return false;
-}
-
-/**
- * Get points around a rectangle taking given directions into account
- * Lines are drawn from anchor in given directions, intersections recorded
- */
-function getRectPoints(anchor, bbox, directionList, grid, options) {
-  const precision = options.precision;
-  const directionMap = options.directionMap;
-  const centerVector = anchor.diff(bbox.getCenter());
-  const rectPoints = [];
-
-  // Check if anchor is on the edge of the bbox
-  const isOnEdge = isPointOnRectangleEdge(anchor, bbox);
-
-  // Check each allowed direction
-  for (const key of directionList) {
-    const direction = directionMap[key];
-
-    // If anchor is on edge, only consider outward directions
-    if (isOnEdge) {
-      const isOutward = isDirectionOutward(anchor, bbox, direction);
-      if (!isOutward) {
-        continue; // Skip inward directions
-      }
-    }
-
-    // Create a line that is guaranteed to intersect the bbox if bbox
-    // is in the direction even if anchor lies outside of bbox
-    const ending = new _geometry.Point(anchor.x + direction.x * (Math.abs(centerVector.x) + bbox.width), anchor.y + direction.y * (Math.abs(centerVector.y) + bbox.height));
-    const intersectionLine = new _geometry.Line(anchor, ending);
-
-    // Get the farther intersection, in case there are two
-    const intersections = intersectionLine.intersect(bbox);
-    let farthestIntersectionDistance;
-    let farthestIntersection = null;
-    for (const intersection of intersections) {
-      const distance = anchor.squaredDistance(intersection);
-      if (farthestIntersectionDistance === undefined || distance > farthestIntersectionDistance) {
-        farthestIntersectionDistance = distance;
-        farthestIntersection = intersection;
-      }
-    }
-
-    // If an intersection was found in this direction, it is our rectPoint
-    if (farthestIntersection) {
-      let target = (0, _grid.align)(farthestIntersection, grid, precision);
-
-      // If the rectPoint lies inside the bbox, offset it by one more step
-      if (bbox.containsPoint(target)) {
-        target = (0, _grid.align)(target.translate(direction.x * grid.x, direction.y * grid.y), grid, precision);
-      }
-      rectPoints.push(target);
-    }
-  }
-
-  // If anchor lies outside of bbox, add it to the array of points
-  // If anchor is on edge, don't add it - force path to start from extended points
-  if (!bbox.containsPoint(anchor) && !isOnEdge) {
-    rectPoints.push((0, _grid.align)(anchor, grid, precision));
-  }
-  return rectPoints;
-}

package/cjs/utils/route.d.ts

@@ -1,19 +0,0 @@
-import { Point } from '../geometry';
-/**
- * Normalize a point to a unit direction vector
- */
-export declare function normalizePoint(point: Point): Point;
-/**
- * Get string key for a point
- */
-export declare function getKey(point: Point): string;
-/**
- * Calculate minimum Manhattan distance from a point to multiple anchors
- */
-export declare function getCost(from: Point, anchors: Point[]): number;
-/**
- * Reconstruct route by concatenating points with their parents
- * Removes redundant points in the same direction
- */
-export declare function reconstructRoute(parents: Map<string, Point>, points: Map<string, Point>, tailPoint: Point, startPoint: Point, endPoint: Point): Point[];
-//# sourceMappingURL=route.d.ts.map

package/cjs/utils/route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/utils/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAKlD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,MAAM,CAW7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC1B,SAAS,EAAE,KAAK,EAChB,UAAU,EAAE,KAAK,EACjB,QAAQ,EAAE,KAAK,GACd,KAAK,EAAE,CAsCT"}

package/cjs/utils/route.js

@@ -1,76 +0,0 @@
-"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;
-  while (parent) {
-    // 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
-    currentKey = getKey(parent);
-    parent = parents.get(currentKey);
-  }
-
-  // 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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,41 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,15 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,EAAa,MAAM,WAAW,CAAA;AAM9E;;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,CAgbvE"}

package/esm/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,34 +0,0 @@
-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)
-     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
-     */
-    isAccessible(point: Point, checkRadius?: number): 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

@@ -1 +0,0 @@
-{"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;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAiD5D;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}

package/esm/obstacle/index.d.ts

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-import { Point } from '../geometry';
-import type { ManhattanRouterOptions } from './types';
-/**
- * Default configuration for Manhattan router
- */
-export declare const defaults: Required<Omit<ManhattanRouterOptions, 'fallbackRoute' | 'sourcePosition' | 'targetPosition'>>;
-/**
- * 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

@@ -1 +0,0 @@
-{"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,CAAC,CAkBlH,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}

package/esm/options/index.d.ts

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

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

@@ -1 +0,0 @@
-{"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"}