@rxflow/manhattan 0.0.2 → 0.0.3

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/getAnchorPoints.d.ts

@@ -0,0 +1,15 @@
+import { Point } from '../geometry';
+import type { ObstacleMap } from '../obstacle';
+import type { Direction } from '../options';
+/**
+ * Get accessible anchor points using binary search optimization
+ *
+ * @param anchor - The anchor point (on node edge)
+ * @param position - The position/direction (right, left, top, bottom)
+ * @param extensionDistance - The preferred extension distance
+ * @param step - The step size for binary search
+ * @param obstacleMap - The obstacle map for accessibility checking
+ * @returns Array of accessible points, prioritized by distance
+ */
+export declare function getAnchorPoints(anchor: Point, position: Direction, extensionDistance: number, step: number, obstacleMap: ObstacleMap): Point[];
+//# sourceMappingURL=getAnchorPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getAnchorPoints.d.ts","sourceRoot":"","sources":["../../src/utils/getAnchorPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,SAAS,EACnB,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,GACvB,KAAK,EAAE,CAsDT"}

package/cjs/utils/getAnchorPoints.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAnchorPoints = getAnchorPoints;
+var _geometry = require("../geometry");
+/**
+ * Get accessible anchor points using binary search optimization
+ *
+ * @param anchor - The anchor point (on node edge)
+ * @param position - The position/direction (right, left, top, bottom)
+ * @param extensionDistance - The preferred extension distance
+ * @param step - The step size for binary search
+ * @param obstacleMap - The obstacle map for accessibility checking
+ * @returns Array of accessible points, prioritized by distance
+ */
+function getAnchorPoints(anchor, position, extensionDistance, step, obstacleMap) {
+  const points = [];
+
+  // Determine direction vector based on position
+  const directionMap = {
+    'right': {
+      dx: 1,
+      dy: 0
+    },
+    'left': {
+      dx: -1,
+      dy: 0
+    },
+    'top': {
+      dx: 0,
+      dy: -1
+    },
+    'bottom': {
+      dx: 0,
+      dy: 1
+    }
+  };
+  const dir = directionMap[position];
+  if (!dir) {
+    console.warn(`[getAnchorPoints] Invalid position: ${position}`);
+    return [anchor];
+  }
+
+  // 1. First try extensionDistance
+  const extensionPoint = new _geometry.Point(anchor.x + dir.dx * extensionDistance, anchor.y + dir.dy * extensionDistance);
+  if (obstacleMap.isAccessible(extensionPoint)) {
+    points.push(extensionPoint);
+    return points;
+  }
+
+  // 2. If extensionDistance point is blocked, use binary search with step
+  // Try: step -> step/2 -> step/4 -> ... -> 1px
+  let distance = step;
+  while (distance >= 1) {
+    const testPoint = new _geometry.Point(anchor.x + dir.dx * distance, anchor.y + dir.dy * distance);
+    if (obstacleMap.isAccessible(testPoint)) {
+      points.push(testPoint);
+      return points;
+    }
+
+    // Halve the distance for next iteration
+    distance = Math.floor(distance / 2);
+  }
+
+  // 3. If still no accessible point found, return the anchor itself
+  console.warn(`[getAnchorPoints] No accessible point found, using anchor itself: (${anchor.x}, ${anchor.y})`);
+  points.push(anchor);
+  return points;
+}

package/cjs/utils/grid.d.ts

@@ -0,0 +1,42 @@
+import { Point } from '../geometry';
+import { GlobalGrid } from './GlobalGrid';
+/**
+ * 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
+ * Uses global grid system with origin at (0, 0) for path alignment
+ *
+ * @param step - The grid step size
+ * @param source - Source point (used for reference, not as origin)
+ * @param target - Target point (used for reference, not as origin)
+ * @returns Grid configuration with global origin
+ */
+export declare function getGrid(step: number, source: Point, target: Point): Grid;
+/**
+ * Create a GlobalGrid instance from step size
+ * This is the preferred way to create grids for new code
+ */
+export declare function createGlobalGrid(step: number): GlobalGrid;
+/**
+ * Snap a value to grid
+ */
+export declare function snapToGrid(value: number, gridSize: number): number;
+/**
+ * Snap a point to grid using global origin
+ */
+export declare function snapPointToGrid(point: Point, grid: Grid): Point;
+/**
+ * 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;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAEzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,CAK/D;AAED;;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,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.align = align;
+exports.createGlobalGrid = createGlobalGrid;
+exports.getGrid = getGrid;
+exports.round = round;
+exports.snapPointToGrid = snapPointToGrid;
+exports.snapToGrid = snapToGrid;
+var _geometry = require("../geometry");
+var _GlobalGrid = require("./GlobalGrid");
+/**
+ * Grid interface for dynamic grid system
+ */
+
+/**
+ * Get grid size in x and y dimensions, adapted to source and target positions
+ * Uses global grid system with origin at (0, 0) for path alignment
+ *
+ * @param step - The grid step size
+ * @param source - Source point (used for reference, not as origin)
+ * @param target - Target point (used for reference, not as origin)
+ * @returns Grid configuration with global origin
+ */
+function getGrid(step, source, target) {
+  return {
+    source: new _geometry.Point(0, 0),
+    // Use global origin for consistent grid alignment
+    x: step,
+    y: step
+  };
+}
+
+/**
+ * Create a GlobalGrid instance from step size
+ * This is the preferred way to create grids for new code
+ */
+function createGlobalGrid(step) {
+  return _GlobalGrid.GlobalGrid.uniform(step);
+}
+
+/**
+ * Snap a value to grid
+ */
+function snapToGrid(value, gridSize) {
+  return Math.round(value / gridSize) * gridSize;
+}
+
+/**
+ * Snap a point to grid using global origin
+ */
+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/heuristics.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Heuristics - 启发式函数模块
+ *
+ * 提供多种启发式函数用于 A* 算法：
+ * - Manhattan: 曼哈顿距离（默认）
+ * - Euclidean: 欧几里得距离
+ * - Octile: 八方向距离
+ *
+ * Implements: Requirements 3.1
+ */
+import { Point } from '../geometry';
+/**
+ * 启发式函数类型
+ */
+export type HeuristicType = 'manhattan' | 'euclidean' | 'octile';
+/**
+ * 启发式函数配置
+ */
+export interface HeuristicConfig {
+    /** 启发式函数类型 */
+    type: HeuristicType;
+    /** 启发式权重（> 1 加速但可能不是最优） */
+    weight: number;
+}
+/**
+ * 默认启发式配置
+ */
+export declare const DEFAULT_HEURISTIC_CONFIG: HeuristicConfig;
+/**
+ * 计算曼哈顿距离
+ * 适用于只能水平或垂直移动的场景
+ */
+export declare function manhattanDistance(from: Point, to: Point): number;
+/**
+ * 计算欧几里得距离
+ * 适用于可以任意方向移动的场景
+ */
+export declare function euclideanDistance(from: Point, to: Point): number;
+/**
+ * 计算八方向距离（Octile/Chebyshev）
+ * 适用于可以对角移动的场景
+ */
+export declare function octileDistance(from: Point, to: Point): number;
+/**
+ * 根据配置计算启发式值
+ */
+export declare function calculateHeuristic(from: Point, to: Point, config?: HeuristicConfig): number;
+/**
+ * 计算到多个目标点的最小启发式值
+ */
+export declare function calculateMinHeuristic(from: Point, targets: Point[], config?: HeuristicConfig): number;
+/**
+ * 方向优先级计算
+ * 优先考虑与目标方向一致的移动
+ */
+export declare function calculateDirectionPriority(current: Point, neighbor: Point, target: Point, weight?: number): number;
+/**
+ * 创建启发式函数
+ */
+export declare function createHeuristicFunction(config?: HeuristicConfig): (from: Point, targets: Point[]) => number;
+//# sourceMappingURL=heuristics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heuristics.d.ts","sourceRoot":"","sources":["../../src/utils/heuristics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAA;AAEhE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,cAAc;IACd,IAAI,EAAE,aAAa,CAAA;IACnB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,eAGtC,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAEhE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAIhE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAO7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,MAAM,GAAE,eAA0C,GACjD,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,KAAK,EAAE,EAChB,MAAM,GAAE,eAA0C,GACjD,MAAM,CAWR;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,KAAK,EACd,QAAQ,EAAE,KAAK,EACf,MAAM,EAAE,KAAK,EACb,MAAM,GAAE,MAAY,GACnB,MAAM,CAuBR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,GAAE,eAA0C,GACjD,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,MAAM,CAI3C"}

package/cjs/utils/heuristics.js

@@ -0,0 +1,141 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_HEURISTIC_CONFIG = void 0;
+exports.calculateDirectionPriority = calculateDirectionPriority;
+exports.calculateHeuristic = calculateHeuristic;
+exports.calculateMinHeuristic = calculateMinHeuristic;
+exports.createHeuristicFunction = createHeuristicFunction;
+exports.euclideanDistance = euclideanDistance;
+exports.manhattanDistance = manhattanDistance;
+exports.octileDistance = octileDistance;
+/**
+ * Heuristics - 启发式函数模块
+ *
+ * 提供多种启发式函数用于 A* 算法：
+ * - Manhattan: 曼哈顿距离（默认）
+ * - Euclidean: 欧几里得距离
+ * - Octile: 八方向距离
+ *
+ * Implements: Requirements 3.1
+ */
+
+/**
+ * 启发式函数类型
+ */
+
+/**
+ * 启发式函数配置
+ */
+
+/**
+ * 默认启发式配置
+ */
+const DEFAULT_HEURISTIC_CONFIG = exports.DEFAULT_HEURISTIC_CONFIG = {
+  type: 'manhattan',
+  weight: 1.0
+};
+
+/**
+ * 计算曼哈顿距离
+ * 适用于只能水平或垂直移动的场景
+ */
+function manhattanDistance(from, to) {
+  return Math.abs(from.x - to.x) + Math.abs(from.y - to.y);
+}
+
+/**
+ * 计算欧几里得距离
+ * 适用于可以任意方向移动的场景
+ */
+function euclideanDistance(from, to) {
+  const dx = from.x - to.x;
+  const dy = from.y - to.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * 计算八方向距离（Octile/Chebyshev）
+ * 适用于可以对角移动的场景
+ */
+function octileDistance(from, to) {
+  const dx = Math.abs(from.x - to.x);
+  const dy = Math.abs(from.y - to.y);
+  // D = 1, D2 = sqrt(2) ≈ 1.414
+  const D = 1;
+  const D2 = Math.SQRT2;
+  return D * (dx + dy) + (D2 - 2 * D) * Math.min(dx, dy);
+}
+
+/**
+ * 根据配置计算启发式值
+ */
+function calculateHeuristic(from, to, config = DEFAULT_HEURISTIC_CONFIG) {
+  let distance;
+  switch (config.type) {
+    case 'euclidean':
+      distance = euclideanDistance(from, to);
+      break;
+    case 'octile':
+      distance = octileDistance(from, to);
+      break;
+    case 'manhattan':
+    default:
+      distance = manhattanDistance(from, to);
+      break;
+  }
+  return distance * config.weight;
+}
+
+/**
+ * 计算到多个目标点的最小启发式值
+ */
+function calculateMinHeuristic(from, targets, config = DEFAULT_HEURISTIC_CONFIG) {
+  let min = Infinity;
+  for (const target of targets) {
+    const h = calculateHeuristic(from, target, config);
+    if (h < min) {
+      min = h;
+    }
+  }
+  return min;
+}
+
+/**
+ * 方向优先级计算
+ * 优先考虑与目标方向一致的移动
+ */
+function calculateDirectionPriority(current, neighbor, target, weight = 0.1) {
+  // 计算当前到邻居的方向
+  const moveX = neighbor.x - current.x;
+  const moveY = neighbor.y - current.y;
+
+  // 计算当前到目标的方向
+  const targetX = target.x - current.x;
+  const targetY = target.y - current.y;
+
+  // 如果移动方向与目标方向一致，给予奖励（负惩罚）
+  let bonus = 0;
+
+  // 水平方向一致
+  if (moveX > 0 && targetX > 0 || moveX < 0 && targetX < 0) {
+    bonus -= weight;
+  }
+
+  // 垂直方向一致
+  if (moveY > 0 && targetY > 0 || moveY < 0 && targetY < 0) {
+    bonus -= weight;
+  }
+  return bonus;
+}
+
+/**
+ * 创建启发式函数
+ */
+function createHeuristicFunction(config = DEFAULT_HEURISTIC_CONFIG) {
+  return (from, targets) => {
+    return calculateMinHeuristic(from, targets, config);
+  };
+}

package/cjs/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './grid';
+export * from './GlobalGrid';
+export * from './direction';
+export * from './rect';
+export * from './route';
+export * from './node';
+export * from './pathValidation';
+export * from './getAnchorPoints';
+export * from './AdaptiveStepCalculator';
+export * from './PerformanceMonitor';
+export * from './ErrorRecovery';
+export * from './heuristics';
+export * from './pathProcessing';
+//# 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,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA"}

package/cjs/utils/index.js

@@ -0,0 +1,148 @@
+"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 _GlobalGrid = require("./GlobalGrid");
+Object.keys(_GlobalGrid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _GlobalGrid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GlobalGrid[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];
+    }
+  });
+});
+var _pathValidation = require("./pathValidation");
+Object.keys(_pathValidation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pathValidation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pathValidation[key];
+    }
+  });
+});
+var _getAnchorPoints = require("./getAnchorPoints");
+Object.keys(_getAnchorPoints).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getAnchorPoints[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getAnchorPoints[key];
+    }
+  });
+});
+var _AdaptiveStepCalculator = require("./AdaptiveStepCalculator");
+Object.keys(_AdaptiveStepCalculator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _AdaptiveStepCalculator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AdaptiveStepCalculator[key];
+    }
+  });
+});
+var _PerformanceMonitor = require("./PerformanceMonitor");
+Object.keys(_PerformanceMonitor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PerformanceMonitor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PerformanceMonitor[key];
+    }
+  });
+});
+var _ErrorRecovery = require("./ErrorRecovery");
+Object.keys(_ErrorRecovery).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ErrorRecovery[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ErrorRecovery[key];
+    }
+  });
+});
+var _heuristics = require("./heuristics");
+Object.keys(_heuristics).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _heuristics[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _heuristics[key];
+    }
+  });
+});
+var _pathProcessing = require("./pathProcessing");
+Object.keys(_pathProcessing).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pathProcessing[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pathProcessing[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"}