@rxflow/manhattan 0.0.1-alpha.0

package/esm/pathfinder/findRoute.js

@@ -0,0 +1,189 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { SortedSet } from "./SortedSet";
+import { getGrid, align, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute } from "../utils";
+
+/**
+ * Find route between two points using A* algorithm
+ */
+export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, options) {
+  var precision = options.precision;
+
+  // Round anchor points
+  var sourceEndpoint = round(sourceAnchor.clone(), precision);
+  var targetEndpoint = round(targetAnchor.clone(), precision);
+
+  // Get grid for this route
+  var grid = getGrid(options.step, sourceEndpoint, targetEndpoint);
+
+  // Get pathfinding points
+  var startPoint = sourceEndpoint;
+  var endPoint = targetEndpoint;
+
+  // Get start and end points around rectangles
+  var startPoints = getRectPoints(startPoint, sourceBBox, options.startDirections, grid, options);
+  var endPoints = getRectPoints(targetEndpoint, targetBBox, options.endDirections, grid, options);
+  console.log('[findRoute] Start points from getRectPoints:', startPoints.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+  console.log('[findRoute] End points from getRectPoints:', endPoints.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+
+  // Take into account only accessible rect points
+  startPoints = startPoints.filter(function (p) {
+    return map.isAccessible(p);
+  });
+  endPoints = endPoints.filter(function (p) {
+    return map.isAccessible(p);
+  });
+  console.log('[findRoute] Start points after filter:', startPoints.map(function (p) {
+    return "(".concat(p.x, ", ").concat(p.y, ")");
+  }));
+  console.log('[findRoute] End points after filter:', endPoints.map(function (p) {
+    return "(".concat(p.x, ", ").concat(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 = [align(startPoint, grid, precision)];
+  }
+  if (endPoints.length === 0) {
+    endPoints = [align(endPoint, grid, precision)];
+  }
+
+  // Initialize A* data structures
+  var openSet = new SortedSet();
+  var points = new Map();
+  var parents = new Map();
+  var costs = new Map();
+
+  // Add all start points to open set
+  var _iterator = _createForOfIteratorHelper(startPoints),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _startPoint = _step.value;
+      var key = getKey(_startPoint);
+      openSet.add(key, getCost(_startPoint, endPoints));
+      points.set(key, _startPoint);
+      costs.set(key, 0);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var previousRouteDirectionAngle = options.previousDirectionAngle;
+  var isPathBeginning = previousRouteDirectionAngle === undefined;
+
+  // Get directions with grid offsets
+  var directions = getGridOffsets(grid, options);
+  var numDirections = directions.length;
+
+  // Create set of end point keys for quick lookup
+  var endPointsKeys = new Set(endPoints.map(function (p) {
+    return getKey(p);
+  }));
+
+  // Check if start and end points are the same
+  var sameStartEndPoints = startPoints.length === endPoints.length && startPoints.every(function (sp, i) {
+    return sp.equals(endPoints[i]);
+  });
+
+  // Main A* loop
+  var loopsRemaining = options.maxLoopCount;
+  while (!openSet.isEmpty() && loopsRemaining > 0) {
+    // Get the closest item and mark it CLOSED
+    var currentKey = openSet.pop();
+    if (!currentKey) break;
+    var currentPoint = points.get(currentKey);
+    var currentParent = parents.get(currentKey);
+    var currentCost = costs.get(currentKey);
+    var isStartPoint = currentPoint.equals(startPoint);
+    var isRouteBeginning = currentParent === undefined;
+
+    // Calculate previous direction angle
+    var previousDirectionAngle = void 0;
+    if (!isRouteBeginning) {
+      previousDirectionAngle = getDirectionAngle(currentParent, currentPoint, numDirections, grid, options);
+    } else if (!isPathBeginning) {
+      previousDirectionAngle = previousRouteDirectionAngle;
+    } else if (!isStartPoint) {
+      previousDirectionAngle = getDirectionAngle(startPoint, currentPoint, numDirections, grid, options);
+    } else {
+      previousDirectionAngle = null;
+    }
+
+    // Check if we reached any endpoint
+    var skipEndCheck = isRouteBeginning && sameStartEndPoints;
+    if (!skipEndCheck && endPointsKeys.has(currentKey)) {
+      options.previousDirectionAngle = previousDirectionAngle;
+      return reconstructRoute(parents, points, currentPoint, startPoint, endPoint);
+    }
+
+    // Explore neighbors in all directions
+    var _iterator2 = _createForOfIteratorHelper(directions),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _previousDirectionAng;
+        var direction = _step2.value;
+        var directionAngle = direction.angle;
+        var directionChange = getDirectionChange((_previousDirectionAng = previousDirectionAngle) !== null && _previousDirectionAng !== void 0 ? _previousDirectionAng : 0, directionAngle);
+
+        // Don't use the point if direction changed too rapidly
+        if (!(isPathBeginning && isStartPoint) && directionChange > options.maxDirectionChange) {
+          continue;
+        }
+
+        // Calculate neighbor point
+        var neighborPoint = align(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), grid, precision);
+        var neighborKey = 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)) {
+          var isEndPoint = neighborPoint.equals(endPoint);
+          if (!isEndPoint) {
+            var endDirectionAngle = getDirectionAngle(neighborPoint, endPoint, numDirections, grid, options);
+            var endDirectionChange = getDirectionChange(directionAngle, endDirectionAngle);
+            if (endDirectionChange > options.maxDirectionChange) {
+              continue;
+            }
+          }
+        }
+
+        // Calculate costs
+        var neighborCost = direction.cost;
+        var neighborPenalty = isStartPoint ? 0 : options.penalties[directionChange] || 0;
+        var 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 + getCost(neighborPoint, endPoints));
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    loopsRemaining -= 1;
+  }
+
+  // No path found, try fallback
+  if (options.fallbackRoute) {
+    return options.fallbackRoute(startPoint, endPoint);
+  }
+  return null;
+}

package/esm/pathfinder/index.d.ts

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

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

@@ -0,0 +1,2 @@
+export { SortedSet } from "./SortedSet";
+export { findRoute } from "./findRoute";

package/esm/svg/index.d.ts

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

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

@@ -0,0 +1 @@
+export { pointsToPath, snapPathToGrid } from "./pathConverter";

package/esm/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/esm/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/esm/svg/pathConverter.js

@@ -0,0 +1,107 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * Convert array of points to SVG path string
+ */
+export function pointsToPath(points, precision) {
+  var borderRadius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  if (points.length === 0) {
+    return '';
+  }
+  var factor = Math.pow(10, precision);
+  var roundCoord = function roundCoord(value) {
+    return Math.round(value * factor) / factor;
+  };
+
+  // If no border radius or only 2 points, use simple line path
+  if (borderRadius === 0 || points.length <= 2) {
+    var _firstPoint = points[0];
+    var _path = "M ".concat(roundCoord(_firstPoint.x), " ").concat(roundCoord(_firstPoint.y));
+    for (var i = 1; i < points.length; i++) {
+      var point = points[i];
+      _path += " L ".concat(roundCoord(point.x), " ").concat(roundCoord(point.y));
+    }
+    return _path;
+  }
+
+  // Start with M (moveTo) command for first point
+  var firstPoint = points[0];
+  var path = "M ".concat(roundCoord(firstPoint.x), " ").concat(roundCoord(firstPoint.y));
+
+  // Process each segment with rounded corners
+  for (var _i = 1; _i < points.length - 1; _i++) {
+    var prev = points[_i - 1];
+    var current = points[_i];
+    var next = points[_i + 1];
+
+    // Calculate the distance from prev to current and current to next
+    var distToPrev = Math.sqrt(Math.pow(current.x - prev.x, 2) + Math.pow(current.y - prev.y, 2));
+    var 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
+    var radius = Math.min(borderRadius, distToPrev / 2, distToNext / 2);
+
+    // Calculate the point before the corner (on the line from prev to current)
+    var beforeCornerRatio = (distToPrev - radius) / distToPrev;
+    var 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)
+    var afterCornerRatio = radius / distToNext;
+    var 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 ".concat(roundCoord(beforeCorner.x), " ").concat(roundCoord(beforeCorner.y));
+
+    // Draw quadratic bezier curve for the rounded corner
+    path += " Q ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y), " ").concat(roundCoord(afterCorner.x), " ").concat(roundCoord(afterCorner.y));
+  }
+
+  // Draw line to the last point
+  var lastPoint = points[points.length - 1];
+  path += " L ".concat(roundCoord(lastPoint.x), " ").concat(roundCoord(lastPoint.y));
+  return path;
+}
+
+/**
+ * Snap path to grid by aligning consecutive points
+ */
+export function snapPathToGrid(points, gridSize) {
+  if (points.length <= 1) {
+    return points;
+  }
+  var snappedPoints = _toConsumableArray(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 (var i = 2; i < snappedPoints.length - 3; i++) {
+    var first = snappedPoints[i];
+    var second = snappedPoints[i + 1];
+    if (first.x === second.x) {
+      // Vertical line - snap X coordinate
+      var 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
+      var y = gridSize * Math.round(first.y / gridSize);
+      if (first.y !== y) {
+        first.y = y;
+        second.y = y;
+      }
+    }
+  }
+  return snappedPoints;
+}

package/esm/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/esm/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/esm/utils/direction.js

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

package/esm/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/esm/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/esm/utils/grid.js

@@ -0,0 +1,70 @@
+import { Point } from "../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;
+  }
+  var abs = Math.abs(diff);
+  var count = Math.round(abs / step);
+
+  // Return abs if less than one step apart
+  if (!count) {
+    return abs;
+  }
+
+  // Otherwise, return corrected step
+  var roundedDiff = count * step;
+  var remainder = abs - roundedDiff;
+  var correction = remainder / count;
+  return step + correction;
+}
+
+/**
+ * Get grid size in x and y dimensions, adapted to source and target positions
+ */
+export 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
+ */
+export function snapToGrid(value, gridSize) {
+  return Math.round(value / gridSize) * gridSize;
+}
+
+/**
+ * Snap a point to grid
+ */
+function snapPointToGrid(point, grid) {
+  var source = grid.source;
+  var x = snapToGrid(point.x - source.x, grid.x) + source.x;
+  var y = snapToGrid(point.y - source.y, grid.y) + source.y;
+  return new Point(x, y);
+}
+
+/**
+ * Align point to grid and apply precision
+ */
+export function align(point, grid, precision) {
+  return snapPointToGrid(point.clone(), grid).round(precision);
+}
+
+/**
+ * Round point coordinates
+ */
+export function round(point, precision) {
+  return point.round(precision);
+}

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

@@ -0,0 +1,5 @@
+export * from "./grid";
+export * from "./direction";
+export * from "./rect";
+export * from "./route";
+export * from "./node";

package/esm/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/esm/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/esm/utils/node.js

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+export function getNodeDimensions(node) {
+  var _ref, _ref2, _node$measured$width, _node$measured, _ref3, _ref4, _node$measured$height, _node$measured2;
+  var width = (_ref = (_ref2 = (_node$measured$width = (_node$measured = node.measured) === null || _node$measured === void 0 ? void 0 : _node$measured.width) !== null && _node$measured$width !== void 0 ? _node$measured$width : node.width) !== null && _ref2 !== void 0 ? _ref2 : node.initialWidth) !== null && _ref !== void 0 ? _ref : 0;
+  var height = (_ref3 = (_ref4 = (_node$measured$height = (_node$measured2 = node.measured) === null || _node$measured2 === void 0 ? void 0 : _node$measured2.height) !== null && _node$measured$height !== void 0 ? _node$measured$height : node.height) !== null && _ref4 !== void 0 ? _ref4 : node.initialHeight) !== null && _ref3 !== void 0 ? _ref3 : 0;
+  return {
+    width: width,
+    height: height
+  };
+}
+
+/**
+ * Get node absolute position from internals
+ * 
+ * @param node - ReactFlow internal node
+ * @returns Absolute position { x, y }
+ */
+export function getNodePosition(node) {
+  return node.internals.positionAbsolute;
+}

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

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

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