@rxflow/manhattan 0.0.1-alpha.0

package/cjs/pathfinder/findRoute.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findRoute = findRoute;
+var _SortedSet = require("./SortedSet");
+var _utils = require("../utils");
+/**
+ * Find route between two points using A* algorithm
+ */
+function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, options) {
+  const precision = options.precision;
+
+  // Round anchor points
+  const sourceEndpoint = (0, _utils.round)(sourceAnchor.clone(), precision);
+  const targetEndpoint = (0, _utils.round)(targetAnchor.clone(), precision);
+
+  // Get grid for this route
+  const grid = (0, _utils.getGrid)(options.step, sourceEndpoint, targetEndpoint);
+
+  // Get pathfinding points
+  const startPoint = sourceEndpoint;
+  const endPoint = targetEndpoint;
+
+  // Get start and end points around rectangles
+  let startPoints = (0, _utils.getRectPoints)(startPoint, sourceBBox, options.startDirections, grid, options);
+  let endPoints = (0, _utils.getRectPoints)(targetEndpoint, targetBBox, options.endDirections, grid, options);
+  console.log('[findRoute] Start points from getRectPoints:', startPoints.map(p => `(${p.x}, ${p.y})`));
+  console.log('[findRoute] End points from getRectPoints:', endPoints.map(p => `(${p.x}, ${p.y})`));
+
+  // Take into account only accessible rect points
+  startPoints = startPoints.filter(p => map.isAccessible(p));
+  endPoints = endPoints.filter(p => map.isAccessible(p));
+  console.log('[findRoute] Start points after filter:', startPoints.map(p => `(${p.x}, ${p.y})`));
+  console.log('[findRoute] End points after filter:', endPoints.map(p => `(${p.x}, ${p.y})`));
+
+  // Ensure we always have at least the anchor points
+  // This handles edge cases where anchor is on the node boundary
+  if (startPoints.length === 0) {
+    startPoints = [(0, _utils.align)(startPoint, grid, precision)];
+  }
+  if (endPoints.length === 0) {
+    endPoints = [(0, _utils.align)(endPoint, grid, precision)];
+  }
+
+  // Initialize A* data structures
+  const openSet = new _SortedSet.SortedSet();
+  const points = new Map();
+  const parents = new Map();
+  const costs = new Map();
+
+  // Add all start points to open set
+  for (const startPoint of startPoints) {
+    const key = (0, _utils.getKey)(startPoint);
+    openSet.add(key, (0, _utils.getCost)(startPoint, endPoints));
+    points.set(key, startPoint);
+    costs.set(key, 0);
+  }
+  const previousRouteDirectionAngle = options.previousDirectionAngle;
+  const isPathBeginning = previousRouteDirectionAngle === undefined;
+
+  // Get directions with grid offsets
+  const directions = (0, _utils.getGridOffsets)(grid, options);
+  const numDirections = directions.length;
+
+  // Create set of end point keys for quick lookup
+  const endPointsKeys = new Set(endPoints.map(p => (0, _utils.getKey)(p)));
+
+  // Check if start and end points are the same
+  const sameStartEndPoints = startPoints.length === endPoints.length && startPoints.every((sp, i) => sp.equals(endPoints[i]));
+
+  // Main A* loop
+  let loopsRemaining = options.maxLoopCount;
+  while (!openSet.isEmpty() && loopsRemaining > 0) {
+    // Get the closest item and mark it CLOSED
+    const currentKey = openSet.pop();
+    if (!currentKey) break;
+    const currentPoint = points.get(currentKey);
+    const currentParent = parents.get(currentKey);
+    const currentCost = costs.get(currentKey);
+    const isStartPoint = currentPoint.equals(startPoint);
+    const isRouteBeginning = currentParent === undefined;
+
+    // Calculate previous direction angle
+    let previousDirectionAngle;
+    if (!isRouteBeginning) {
+      previousDirectionAngle = (0, _utils.getDirectionAngle)(currentParent, currentPoint, numDirections, grid, options);
+    } else if (!isPathBeginning) {
+      previousDirectionAngle = previousRouteDirectionAngle;
+    } else if (!isStartPoint) {
+      previousDirectionAngle = (0, _utils.getDirectionAngle)(startPoint, currentPoint, numDirections, grid, options);
+    } else {
+      previousDirectionAngle = null;
+    }
+
+    // Check if we reached any endpoint
+    const skipEndCheck = isRouteBeginning && sameStartEndPoints;
+    if (!skipEndCheck && endPointsKeys.has(currentKey)) {
+      options.previousDirectionAngle = previousDirectionAngle;
+      return (0, _utils.reconstructRoute)(parents, points, currentPoint, startPoint, endPoint);
+    }
+
+    // Explore neighbors in all directions
+    for (const direction of directions) {
+      const directionAngle = direction.angle;
+      const directionChange = (0, _utils.getDirectionChange)(previousDirectionAngle ?? 0, directionAngle);
+
+      // Don't use the point if direction changed too rapidly
+      if (!(isPathBeginning && isStartPoint) && directionChange > options.maxDirectionChange) {
+        continue;
+      }
+
+      // Calculate neighbor point
+      const neighborPoint = (0, _utils.align)(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), grid, precision);
+      const neighborKey = (0, _utils.getKey)(neighborPoint);
+
+      // Skip if closed or not accessible
+      if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+        continue;
+      }
+
+      // Check if neighbor is an end point
+      if (endPointsKeys.has(neighborKey)) {
+        const isEndPoint = neighborPoint.equals(endPoint);
+        if (!isEndPoint) {
+          const endDirectionAngle = (0, _utils.getDirectionAngle)(neighborPoint, endPoint, numDirections, grid, options);
+          const endDirectionChange = (0, _utils.getDirectionChange)(directionAngle, endDirectionAngle);
+          if (endDirectionChange > options.maxDirectionChange) {
+            continue;
+          }
+        }
+      }
+
+      // Calculate costs
+      const neighborCost = direction.cost;
+      const neighborPenalty = isStartPoint ? 0 : options.penalties[directionChange] || 0;
+      const costFromStart = currentCost + neighborCost + neighborPenalty;
+
+      // Update if not in open set or found better path
+      if (!openSet.isOpen(neighborKey) || costFromStart < (costs.get(neighborKey) || Infinity)) {
+        points.set(neighborKey, neighborPoint);
+        parents.set(neighborKey, currentPoint);
+        costs.set(neighborKey, costFromStart);
+        openSet.add(neighborKey, costFromStart + (0, _utils.getCost)(neighborPoint, endPoints));
+      }
+    }
+    loopsRemaining -= 1;
+  }
+
+  // No path found, try fallback
+  if (options.fallbackRoute) {
+    return options.fallbackRoute(startPoint, endPoint);
+  }
+  return null;
+}

package/cjs/pathfinder/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pathfinder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/cjs/pathfinder/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SortedSet", {
+  enumerable: true,
+  get: function () {
+    return _SortedSet.SortedSet;
+  }
+});
+Object.defineProperty(exports, "findRoute", {
+  enumerable: true,
+  get: function () {
+    return _findRoute.findRoute;
+  }
+});
+var _SortedSet = require("./SortedSet");
+var _findRoute = require("./findRoute");

package/cjs/svg/index.d.ts

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

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

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

package/cjs/svg/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "pointsToPath", {
+  enumerable: true,
+  get: function () {
+    return _pathConverter.pointsToPath;
+  }
+});
+Object.defineProperty(exports, "snapPathToGrid", {
+  enumerable: true,
+  get: function () {
+    return _pathConverter.snapPathToGrid;
+  }
+});
+var _pathConverter = require("./pathConverter");

package/cjs/svg/pathConverter.d.ts

@@ -0,0 +1,10 @@
+import { Point } from '../geometry';
+/**
+ * Convert array of points to SVG path string
+ */
+export declare function pointsToPath(points: Point[], precision: number, borderRadius?: number): string;
+/**
+ * Snap path to grid by aligning consecutive points
+ */
+export declare function snapPathToGrid(points: Point[], gridSize: number): Point[];
+//# sourceMappingURL=pathConverter.d.ts.map

package/cjs/svg/pathConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathConverter.d.ts","sourceRoot":"","sources":["../../src/svg/pathConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM,CAgEjG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAgCzE"}

package/cjs/svg/pathConverter.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pointsToPath = pointsToPath;
+exports.snapPathToGrid = snapPathToGrid;
+/**
+ * Convert array of points to SVG path string
+ */
+function pointsToPath(points, precision, borderRadius = 0) {
+  if (points.length === 0) {
+    return '';
+  }
+  const factor = Math.pow(10, precision);
+  const roundCoord = value => Math.round(value * factor) / factor;
+
+  // If no border radius or only 2 points, use simple line path
+  if (borderRadius === 0 || points.length <= 2) {
+    const firstPoint = points[0];
+    let path = `M ${roundCoord(firstPoint.x)} ${roundCoord(firstPoint.y)}`;
+    for (let i = 1; i < points.length; i++) {
+      const point = points[i];
+      path += ` L ${roundCoord(point.x)} ${roundCoord(point.y)}`;
+    }
+    return path;
+  }
+
+  // Start with M (moveTo) command for first point
+  const firstPoint = points[0];
+  let path = `M ${roundCoord(firstPoint.x)} ${roundCoord(firstPoint.y)}`;
+
+  // Process each segment with rounded corners
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const current = points[i];
+    const next = points[i + 1];
+
+    // Calculate the distance from prev to current and current to next
+    const distToPrev = Math.sqrt(Math.pow(current.x - prev.x, 2) + Math.pow(current.y - prev.y, 2));
+    const distToNext = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2));
+
+    // Use the smaller of borderRadius or half the segment length
+    const radius = Math.min(borderRadius, distToPrev / 2, distToNext / 2);
+
+    // Calculate the point before the corner (on the line from prev to current)
+    const beforeCornerRatio = (distToPrev - radius) / distToPrev;
+    const beforeCorner = {
+      x: prev.x + (current.x - prev.x) * beforeCornerRatio,
+      y: prev.y + (current.y - prev.y) * beforeCornerRatio
+    };
+
+    // Calculate the point after the corner (on the line from current to next)
+    const afterCornerRatio = radius / distToNext;
+    const afterCorner = {
+      x: current.x + (next.x - current.x) * afterCornerRatio,
+      y: current.y + (next.y - current.y) * afterCornerRatio
+    };
+
+    // Draw line to the point before corner
+    path += ` L ${roundCoord(beforeCorner.x)} ${roundCoord(beforeCorner.y)}`;
+
+    // Draw quadratic bezier curve for the rounded corner
+    path += ` Q ${roundCoord(current.x)} ${roundCoord(current.y)} ${roundCoord(afterCorner.x)} ${roundCoord(afterCorner.y)}`;
+  }
+
+  // Draw line to the last point
+  const lastPoint = points[points.length - 1];
+  path += ` L ${roundCoord(lastPoint.x)} ${roundCoord(lastPoint.y)}`;
+  return path;
+}
+
+/**
+ * Snap path to grid by aligning consecutive points
+ */
+function snapPathToGrid(points, gridSize) {
+  if (points.length <= 1) {
+    return points;
+  }
+  const snappedPoints = [...points];
+
+  // Don't snap the first and last points (anchors)
+  // Don't snap the second and second-to-last points (extension points)
+  // Only snap intermediate segments
+  for (let i = 2; i < snappedPoints.length - 3; i++) {
+    const first = snappedPoints[i];
+    const second = snappedPoints[i + 1];
+    if (first.x === second.x) {
+      // Vertical line - snap X coordinate
+      const x = gridSize * Math.round(first.x / gridSize);
+      if (first.x !== x) {
+        first.x = x;
+        second.x = x;
+      }
+    } else if (first.y === second.y) {
+      // Horizontal line - snap Y coordinate
+      const y = gridSize * Math.round(first.y / gridSize);
+      if (first.y !== y) {
+        first.y = y;
+        second.y = y;
+      }
+    }
+  }
+  return snappedPoints;
+}

package/cjs/utils/direction.d.ts

@@ -0,0 +1,24 @@
+import { Point } from '../geometry';
+import type { ResolvedOptions } from '../options';
+import type { Grid } from './grid';
+/**
+ * Get direction angle from start point to end point
+ * Corrects for grid deformation between start and end
+ */
+export declare function getDirectionAngle(start: Point, end: Point, directionCount: number, grid: Grid, options: ResolvedOptions): number;
+/**
+ * Get the change in direction between two direction angles
+ */
+export declare function getDirectionChange(angle1: number, angle2: number): number;
+/**
+ * Fix direction offsets according to current grid
+ */
+export declare function getGridOffsets(grid: Grid, options: ResolvedOptions): {
+    cost: number;
+    offsetX: number;
+    offsetY: number;
+    angle?: number | undefined;
+    gridOffsetX?: number | undefined;
+    gridOffsetY?: number | undefined;
+}[];
+//# sourceMappingURL=direction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"direction.d.ts","sourceRoot":"","sources":["../../src/utils/direction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAyBlC;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,GACvB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe;;;;;;;IASlE"}

package/cjs/utils/direction.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDirectionAngle = getDirectionAngle;
+exports.getDirectionChange = getDirectionChange;
+exports.getGridOffsets = getGridOffsets;
+var _geometry = require("../geometry");
+var _resolver = require("../options/resolver");
+/**
+ * Fix angle end point to account for grid deformation
+ */
+function fixAngleEnd(start, end, grid, options) {
+  const step = options.step;
+  const diffX = end.x - start.x;
+  const diffY = end.y - start.y;
+  const gridStepsX = diffX / grid.x;
+  const gridStepsY = diffY / grid.y;
+  const distanceX = gridStepsX * step;
+  const distanceY = gridStepsY * step;
+  return new _geometry.Point(start.x + distanceX, start.y + distanceY);
+}
+
+/**
+ * Get direction angle from start point to end point
+ * Corrects for grid deformation between start and end
+ */
+function getDirectionAngle(start, end, directionCount, grid, options) {
+  const quadrant = 360 / directionCount;
+  const angleTheta = start.theta(fixAngleEnd(start, end, grid, options));
+  const normalizedAngle = (0, _resolver.normalizeAngle)(angleTheta + quadrant / 2);
+  return quadrant * Math.floor(normalizedAngle / quadrant);
+}
+
+/**
+ * Get the change in direction between two direction angles
+ */
+function getDirectionChange(angle1, angle2) {
+  const change = Math.abs(angle1 - angle2);
+  return change > 180 ? 360 - change : change;
+}
+
+/**
+ * Fix direction offsets according to current grid
+ */
+function getGridOffsets(grid, options) {
+  const step = options.step;
+  options.directions.forEach(direction => {
+    direction.gridOffsetX = direction.offsetX / step * grid.x;
+    direction.gridOffsetY = direction.offsetY / step * grid.y;
+  });
+  return options.directions;
+}

package/cjs/utils/grid.d.ts

@@ -0,0 +1,26 @@
+import { Point } from '../geometry';
+/**
+ * Grid interface for dynamic grid system
+ */
+export interface Grid {
+    source: Point;
+    x: number;
+    y: number;
+}
+/**
+ * Get grid size in x and y dimensions, adapted to source and target positions
+ */
+export declare function getGrid(step: number, source: Point, target: Point): Grid;
+/**
+ * Snap a value to grid
+ */
+export declare function snapToGrid(value: number, gridSize: number): number;
+/**
+ * Align point to grid and apply precision
+ */
+export declare function align(point: Point, grid: Grid, precision: number): Point;
+/**
+ * Round point coordinates
+ */
+export declare function round(point: Point, precision: number): Point;
+//# sourceMappingURL=grid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AA2BD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}

package/cjs/utils/grid.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.align = align;
+exports.getGrid = getGrid;
+exports.round = round;
+exports.snapToGrid = snapToGrid;
+var _geometry = require("../geometry");
+/**
+ * Grid interface for dynamic grid system
+ */
+
+/**
+ * Get grid dimension for a single axis
+ */
+function getGridDimension(diff, step) {
+  // Return step if diff = 0
+  if (!diff) {
+    return step;
+  }
+  const abs = Math.abs(diff);
+  const count = Math.round(abs / step);
+
+  // Return abs if less than one step apart
+  if (!count) {
+    return abs;
+  }
+
+  // Otherwise, return corrected step
+  const roundedDiff = count * step;
+  const remainder = abs - roundedDiff;
+  const correction = remainder / count;
+  return step + correction;
+}
+
+/**
+ * Get grid size in x and y dimensions, adapted to source and target positions
+ */
+function getGrid(step, source, target) {
+  return {
+    source: source.clone(),
+    x: getGridDimension(target.x - source.x, step),
+    y: getGridDimension(target.y - source.y, step)
+  };
+}
+
+/**
+ * Snap a value to grid
+ */
+function snapToGrid(value, gridSize) {
+  return Math.round(value / gridSize) * gridSize;
+}
+
+/**
+ * Snap a point to grid
+ */
+function snapPointToGrid(point, grid) {
+  const source = grid.source;
+  const x = snapToGrid(point.x - source.x, grid.x) + source.x;
+  const y = snapToGrid(point.y - source.y, grid.y) + source.y;
+  return new _geometry.Point(x, y);
+}
+
+/**
+ * Align point to grid and apply precision
+ */
+function align(point, grid, precision) {
+  return snapPointToGrid(point.clone(), grid).round(precision);
+}
+
+/**
+ * Round point coordinates
+ */
+function round(point, precision) {
+  return point.round(precision);
+}

package/cjs/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './grid';
+export * from './direction';
+export * from './rect';
+export * from './route';
+export * from './node';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA"}

package/cjs/utils/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _grid = require("./grid");
+Object.keys(_grid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _grid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _grid[key];
+    }
+  });
+});
+var _direction = require("./direction");
+Object.keys(_direction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _direction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _direction[key];
+    }
+  });
+});
+var _rect = require("./rect");
+Object.keys(_rect).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _rect[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _rect[key];
+    }
+  });
+});
+var _route = require("./route");
+Object.keys(_route).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _route[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _route[key];
+    }
+  });
+});
+var _node = require("./node");
+Object.keys(_node).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _node[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _node[key];
+    }
+  });
+});

package/cjs/utils/node.d.ts

@@ -0,0 +1,27 @@
+import type { InternalNode } from '../options';
+/**
+ * Node dimensions interface
+ */
+export interface NodeDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Get node dimensions following ReactFlow's internal logic
+ * Priority: measured > direct property > initialWidth/Height > 0
+ *
+ * @param node - ReactFlow internal node
+ * @returns Node dimensions with width and height
+ */
+export declare function getNodeDimensions(node: InternalNode): NodeDimensions;
+/**
+ * Get node absolute position from internals
+ *
+ * @param node - ReactFlow internal node
+ * @returns Absolute position { x, y }
+ */
+export declare function getNodePosition(node: InternalNode): {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/utils/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc,CAKpE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAE5E"}

package/cjs/utils/node.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeDimensions = getNodeDimensions;
+exports.getNodePosition = getNodePosition;
+/**
+ * Node dimensions interface
+ */
+
+/**
+ * Get node dimensions following ReactFlow's internal logic
+ * Priority: measured > direct property > initialWidth/Height > 0
+ * 
+ * @param node - ReactFlow internal node
+ * @returns Node dimensions with width and height
+ */
+function getNodeDimensions(node) {
+  const width = node.measured?.width ?? node.width ?? node.initialWidth ?? 0;
+  const height = node.measured?.height ?? node.height ?? node.initialHeight ?? 0;
+  return {
+    width,
+    height
+  };
+}
+
+/**
+ * Get node absolute position from internals
+ * 
+ * @param node - ReactFlow internal node
+ * @returns Absolute position { x, y }
+ */
+function getNodePosition(node) {
+  return node.internals.positionAbsolute;
+}

package/cjs/utils/rect.d.ts

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