@rxflow/manhattan 0.0.1-alpha.11 → 0.0.1-alpha.13

package/esm/pathfinder/findRoute.js

@@ -1,8 +1,164 @@
 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 { Point } from "../geometry";
 import { SortedSet } from "./SortedSet";
-import { getGrid, align, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute } from "../utils";
+import { getGrid, round, getDirectionAngle, getDirectionChange, getGridOffsets, getRectPoints, getCost, getKey, reconstructRoute } from "../utils";
+
+/**
+ * Find the closest accessible point in a given direction using step-based search with linear refinement
+ *
+ * Algorithm:
+ * 1. Try moving by step increments (step, 2*step, 3*step...) until finding an accessible point
+ * 2. Once found, linearly search backward from (n-1)*step+1 to n*step to find the closest accessible point
+ * 3. Returns null if no accessible point found within maxSteps
+ */
+function findAccessibleNeighbor(from, directionX, directionY, step, map, precision) {
+  var maxSteps = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 20;
+  // Normalize direction
+  var length = Math.sqrt(directionX * directionX + directionY * directionY);
+  var ndx = directionX / length;
+  var ndy = directionY / length;
+
+  // 1. Try the first step directly (most common case)
+  var firstStepPoint = new Point(from.x + ndx * step, from.y + ndy * step).round(precision);
+  if (map.isAccessible(firstStepPoint)) {
+    // First step is accessible, no need for refinement
+    return firstStepPoint;
+  }
+
+  // 2. First step blocked, search outward by step increments
+  var stepMultiplier = 2;
+  var foundAccessibleDistance = -1;
+  while (stepMultiplier <= maxSteps) {
+    var distance = stepMultiplier * step;
+    var testPoint = new Point(from.x + ndx * distance, from.y + ndy * distance).round(precision);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      break;
+    }
+    stepMultiplier++;
+  }
+  if (foundAccessibleDistance < 0) {
+    return null; // No accessible point found
+  }
+
+  // 3. Linear search within the last step interval to find closest accessible point
+  // Search from (n-1)*step+1 to n*step
+  var outerDistance = foundAccessibleDistance;
+  var innerDistance = foundAccessibleDistance - step;
+
+  // Search backward from outer to inner to find the closest accessible point
+  for (var dist = innerDistance + 1; dist < outerDistance; dist++) {
+    var _testPoint = new Point(from.x + ndx * dist, from.y + ndy * dist).round(precision);
+    if (map.isAccessible(_testPoint)) {
+      return _testPoint;
+    }
+  }
+
+  // If no closer point found, return the outer distance point
+  return new Point(from.x + ndx * outerDistance, from.y + ndy * outerDistance).round(precision);
+}
+
+/**
+ * Generate smart points based on position using extensionDistance and binary search
+ *
+ * Algorithm:
+ * 1. First try extensionDistance in the specified direction
+ * 2. If blocked, use binary search starting from step, halving until finding accessible point
+ * 3. For target points, approach from opposite direction
+ */
+function generateSmartPoints(anchor, bbox, position, grid, map, options) {
+  var isTarget = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+  var directionMap = {
+    'right': {
+      x: 1,
+      y: 0
+    },
+    'left': {
+      x: -1,
+      y: 0
+    },
+    'top': {
+      x: 0,
+      y: -1
+    },
+    'bottom': {
+      x: 0,
+      y: 1
+    }
+  };
+  var direction = directionMap[position];
+  if (!direction) {
+    console.warn("[generateSmartPoints] Unknown position: ".concat(position, ", falling back to anchor"));
+    return [anchor];
+  }
+
+  // Both source and target extend in the specified direction
+  // - Source: extends away from node in sourcePosition direction
+  // - Target: extends away from node in targetPosition direction (path approaches from this direction)
+  var actualDirection = direction;
+  var points = [];
+
+  // 1. First try extensionDistance
+  var extensionPoint = new Point(anchor.x + actualDirection.x * options.extensionDistance, anchor.y + actualDirection.y * options.extensionDistance).round(options.precision);
+  console.log("[generateSmartPoints] ".concat(isTarget ? 'Target' : 'Source', " position=").concat(position, ", trying extension point: (").concat(extensionPoint.x, ", ").concat(extensionPoint.y, ")"));
+  if (map.isAccessible(extensionPoint)) {
+    points.push(extensionPoint);
+    console.log("[generateSmartPoints] Extension point is accessible");
+    return points;
+  }
+  console.log("[generateSmartPoints] Extension point blocked, using step-based search");
+
+  // 2. Step-based search with binary refinement
+  // First, extend outward by step increments until we find an accessible point
+  var stepMultiplier = 1;
+  var maxSteps = 20; // Prevent infinite loop
+  var foundAccessibleDistance = -1;
+  console.log("[generateSmartPoints] Starting outward search with step=".concat(options.step));
+  while (stepMultiplier <= maxSteps) {
+    var distance = stepMultiplier * options.step;
+    var testPoint = new Point(anchor.x + actualDirection.x * distance, anchor.y + actualDirection.y * distance).round(options.precision);
+    console.log("[generateSmartPoints] Testing ".concat(stepMultiplier, "*step (distance=").concat(distance, "): (").concat(testPoint.x, ", ").concat(testPoint.y, ")"));
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      console.log("[generateSmartPoints] Found accessible point at ".concat(stepMultiplier, "*step (distance=").concat(distance, ")"));
+      break;
+    }
+    stepMultiplier++;
+  }
+
+  // 3. If we found an accessible point, refine by linear search within the last step interval
+  if (foundAccessibleDistance > 0) {
+    var outerDistance = foundAccessibleDistance;
+    var innerDistance = foundAccessibleDistance - options.step;
+    console.log("[generateSmartPoints] Refining between ".concat(innerDistance, " and ").concat(outerDistance));
+
+    // Linear search from innerDistance+1 to outerDistance to find the closest accessible point
+    var bestDistance = outerDistance;
+
+    // Search forward from inner to outer to find the first accessible point
+    for (var dist = innerDistance + 1; dist < outerDistance; dist++) {
+      var _testPoint2 = new Point(anchor.x + actualDirection.x * dist, anchor.y + actualDirection.y * dist).round(options.precision);
+      console.log("[generateSmartPoints] Linear search testing distance ".concat(dist, ": (").concat(_testPoint2.x, ", ").concat(_testPoint2.y, ")"));
+      if (map.isAccessible(_testPoint2)) {
+        bestDistance = dist;
+        console.log("[generateSmartPoints] Found closest accessible point at distance ".concat(dist));
+        break;
+      }
+    }
+
+    // Use the best distance found
+    var finalPoint = new Point(anchor.x + actualDirection.x * bestDistance, anchor.y + actualDirection.y * bestDistance).round(options.precision);
+    points.push(finalPoint);
+    console.log("[generateSmartPoints] Final point at distance ".concat(bestDistance, ": (").concat(finalPoint.x, ", ").concat(finalPoint.y, ")"));
+  } else {
+    // 4. If no accessible point found after maxSteps, use anchor as fallback
+    console.log("[generateSmartPoints] No accessible point found after ".concat(maxSteps, " steps, using anchor: (").concat(anchor.x, ", ").concat(anchor.y, ")"));
+    points.push(anchor);
+  }
+  return points;
+}
 
 /**
  * Find route between two points using A* algorithm
@@ -22,22 +178,43 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
   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, ")");
-  }));
+  // Use smart point generation based on position if available
+  var startPoints;
+  var endPoints;
 
-  // 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);
-  });
+  // Generate smart start points based on sourcePosition
+  if (options.sourcePosition) {
+    startPoints = generateSmartPoints(startPoint, sourceBBox, options.sourcePosition, grid, map, options, false);
+    console.log('[findRoute] Start points from smart generation:', startPoints.map(function (p) {
+      return "(".concat(p.x, ", ").concat(p.y, ")");
+    }));
+  } else {
+    startPoints = getRectPoints(startPoint, sourceBBox, options.startDirections, grid, options);
+    console.log('[findRoute] Start points from getRectPoints:', startPoints.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);
+    });
+  }
+
+  // Generate smart end points based on targetPosition
+  if (options.targetPosition) {
+    endPoints = generateSmartPoints(targetEndpoint, targetBBox, options.targetPosition, grid, map, options, true);
+    console.log('[findRoute] End points from smart generation:', endPoints.map(function (p) {
+      return "(".concat(p.x, ", ").concat(p.y, ")");
+    }));
+  } else {
+    endPoints = getRectPoints(targetEndpoint, targetBBox, options.endDirections, grid, options);
+    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
+    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, ")");
   }));
@@ -48,10 +225,10 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
   // 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)];
+    startPoints = [round(startPoint, precision)];
   }
   if (endPoints.length === 0) {
-    endPoints = [align(endPoint, grid, precision)];
+    endPoints = [round(endPoint, precision)];
   }
 
   // Initialize A* data structures
@@ -139,16 +316,78 @@ export function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, ma
           continue;
         }
 
-        // Calculate neighbor point
-        var neighborPoint = align(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), grid, precision);
+        // Find the closest accessible neighbor in this direction using binary search
+        var neighborPoint = findAccessibleNeighbor(currentPoint, direction.offsetX, direction.offsetY, options.step, map, precision);
+
+        // Skip if no accessible neighbor found in this direction
+        if (!neighborPoint) {
+          continue;
+        }
         var neighborKey = getKey(neighborPoint);
 
-        // Skip if closed or not accessible
-        if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+        // Skip if already closed
+        if (openSet.isClose(neighborKey)) {
           continue;
         }
 
-        // Check if neighbor is an end point
+        // Check if we can reach any end point directly from this neighbor
+        // This allows connecting to end points that are not on the grid
+        var canReachEndPoint = false;
+        var reachableEndPoint = null;
+        var _iterator3 = _createForOfIteratorHelper(endPoints),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var endPt = _step3.value;
+            var distanceToEnd = neighborPoint.manhattanDistance(endPt);
+
+            // If close enough to end point (within step distance), try direct connection
+            if (distanceToEnd < options.step * 1.5) {
+              // Check if we can move directly to the end point
+              var dx = endPt.x - neighborPoint.x;
+              var dy = endPt.y - neighborPoint.y;
+
+              // Allow direct connection if it's orthogonal or close to orthogonal
+              var isOrthogonal = Math.abs(dx) < 0.1 || Math.abs(dy) < 0.1;
+              if (isOrthogonal && map.isAccessible(endPt)) {
+                canReachEndPoint = true;
+                reachableEndPoint = endPt;
+                break;
+              }
+            }
+          }
+
+          // If we can reach an end point directly, add it as the final step
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        if (canReachEndPoint && reachableEndPoint) {
+          var endKey = getKey(reachableEndPoint);
+          var endCost = neighborPoint.manhattanDistance(reachableEndPoint);
+          var totalCost = currentCost + direction.cost + endCost;
+          if (!openSet.isOpen(endKey) || totalCost < (costs.get(endKey) || Infinity)) {
+            points.set(endKey, reachableEndPoint);
+            parents.set(endKey, neighborPoint);
+            costs.set(endKey, totalCost);
+
+            // Also add the neighbor point if not already added
+            if (!points.has(neighborKey)) {
+              points.set(neighborKey, neighborPoint);
+              parents.set(neighborKey, currentPoint);
+              costs.set(neighborKey, currentCost + direction.cost);
+            }
+
+            // Check if this is our target end point
+            if (endPointsKeys.has(endKey)) {
+              options.previousDirectionAngle = directionAngle;
+              return reconstructRoute(parents, points, reachableEndPoint, startPoint, endPoint);
+            }
+          }
+        }
+
+        // Check if neighbor is an end point (exact match)
         if (endPointsKeys.has(neighborKey)) {
           var isEndPoint = neighborPoint.equals(endPoint);
           if (!isEndPoint) {

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

@@ -1 +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"}
+{"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,CA2EjG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAgCzE"}

package/esm/svg/pathConverter.js

@@ -38,31 +38,42 @@ export function pointsToPath(points, precision) {
     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));
+    // Calculate direction vectors
+    var dx1 = current.x - prev.x;
+    var dy1 = current.y - prev.y;
+    var dx2 = next.x - current.x;
+    var dy2 = next.y - current.y;
+
+    // Calculate distances
+    var dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    var dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
 
     // Use the smaller of borderRadius or half the segment length
-    var radius = Math.min(borderRadius, distToPrev / 2, distToNext / 2);
+    var radius = Math.min(borderRadius, dist1 / 2, dist2 / 2);
+
+    // Normalize direction vectors
+    var ndx1 = dx1 / dist1;
+    var ndy1 = dy1 / dist1;
+    var ndx2 = dx2 / dist2;
+    var ndy2 = dy2 / dist2;
 
-    // Calculate the point before the corner (on the line from prev to current)
-    var beforeCornerRatio = (distToPrev - radius) / distToPrev;
+    // Calculate the point before the corner
     var beforeCorner = {
-      x: prev.x + (current.x - prev.x) * beforeCornerRatio,
-      y: prev.y + (current.y - prev.y) * beforeCornerRatio
+      x: current.x - ndx1 * radius,
+      y: current.y - ndy1 * radius
     };
 
-    // Calculate the point after the corner (on the line from current to next)
-    var afterCornerRatio = radius / distToNext;
+    // Calculate the point after the corner
     var afterCorner = {
-      x: current.x + (next.x - current.x) * afterCornerRatio,
-      y: current.y + (next.y - current.y) * afterCornerRatio
+      x: current.x + ndx2 * radius,
+      y: current.y + ndy2 * radius
     };
 
     // 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
+    // The control point is the actual corner point
     path += " Q ".concat(roundCoord(current.x), " ").concat(roundCoord(current.y), " ").concat(roundCoord(afterCorner.x), " ").concat(roundCoord(afterCorner.y));
   }
 

package/esm/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/esm/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,CA0DT"}

package/esm/utils/getAnchorPoints.js

@@ -0,0 +1,69 @@
+import { Point } from "../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
+ */
+export function getAnchorPoints(anchor, position, extensionDistance, step, obstacleMap) {
+  var points = [];
+
+  // Determine direction vector based on position
+  var directionMap = {
+    'right': {
+      dx: 1,
+      dy: 0
+    },
+    'left': {
+      dx: -1,
+      dy: 0
+    },
+    'top': {
+      dx: 0,
+      dy: -1
+    },
+    'bottom': {
+      dx: 0,
+      dy: 1
+    }
+  };
+  var dir = directionMap[position];
+  if (!dir) {
+    console.warn("[getAnchorPoints] Invalid position: ".concat(position));
+    return [anchor];
+  }
+  console.log("[getAnchorPoints] Finding points for position '".concat(position, "' from (").concat(anchor.x, ", ").concat(anchor.y, ")"));
+
+  // 1. First try extensionDistance
+  var extensionPoint = new Point(anchor.x + dir.dx * extensionDistance, anchor.y + dir.dy * extensionDistance);
+  if (obstacleMap.isAccessible(extensionPoint)) {
+    console.log("[getAnchorPoints] Extension point (".concat(extensionPoint.x, ", ").concat(extensionPoint.y, ") is accessible"));
+    points.push(extensionPoint);
+    return points;
+  }
+  console.log("[getAnchorPoints] Extension point (".concat(extensionPoint.x, ", ").concat(extensionPoint.y, ") is blocked, trying binary search"));
+
+  // 2. If extensionDistance point is blocked, use binary search with step
+  // Try: step -> step/2 -> step/4 -> ... -> 1px
+  var distance = step;
+  while (distance >= 1) {
+    var testPoint = new Point(anchor.x + dir.dx * distance, anchor.y + dir.dy * distance);
+    if (obstacleMap.isAccessible(testPoint)) {
+      console.log("[getAnchorPoints] Found accessible point at distance ".concat(distance, "px: (").concat(testPoint.x, ", ").concat(testPoint.y, ")"));
+      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: (".concat(anchor.x, ", ").concat(anchor.y, ")"));
+  points.push(anchor);
+  return points;
+}

package/esm/utils/index.d.ts

@@ -4,4 +4,5 @@ export * from './rect';
 export * from './route';
 export * from './node';
 export * from './pathValidation';
+export * from './getAnchorPoints';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AACtB,cAAc,kBAAkB,CAAA"}
+{"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;AACtB,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}

package/esm/utils/index.js

@@ -3,4 +3,5 @@ export * from "./direction";
 export * from "./rect";
 export * from "./route";
 export * from "./node";
-export * from "./pathValidation";
+export * from "./pathValidation";
+export * from "./getAnchorPoints";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflow/manhattan",
-  "version": "0.0.1-alpha.11",
+  "version": "0.0.1-alpha.13",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",