@rxflow/manhattan 0.0.1-alpha.0

package/esm/utils/rect.js

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

package/esm/utils/route.d.ts

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

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

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

package/esm/utils/route.js

@@ -0,0 +1,80 @@
+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";
+
+/**
+ * Normalize a point to a unit direction vector
+ */
+export function normalizePoint(point) {
+  return new Point(point.x === 0 ? 0 : Math.abs(point.x) / point.x, point.y === 0 ? 0 : Math.abs(point.y) / point.y);
+}
+
+/**
+ * Get string key for a point
+ */
+export function getKey(point) {
+  return point.toString();
+}
+
+/**
+ * Calculate minimum Manhattan distance from a point to multiple anchors
+ */
+export function getCost(from, anchors) {
+  var min = Infinity;
+  var _iterator = _createForOfIteratorHelper(anchors),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var anchor = _step.value;
+      var dist = from.manhattanDistance(anchor);
+      if (dist < min) {
+        min = dist;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return min;
+}
+
+/**
+ * Reconstruct route by concatenating points with their parents
+ * Removes redundant points in the same direction
+ */
+export function reconstructRoute(parents, points, tailPoint, startPoint, endPoint) {
+  var route = [];
+  var prevDiff = normalizePoint(endPoint.diff(tailPoint));
+
+  // tailPoint is assumed to be aligned already
+  var currentKey = getKey(tailPoint);
+  var parent = parents.get(currentKey);
+  var point;
+  while (parent) {
+    // point is assumed to be aligned already
+    point = points.get(currentKey);
+    if (point) {
+      var diff = normalizePoint(point.diff(parent));
+      if (!diff.equals(prevDiff)) {
+        route.unshift(point);
+        prevDiff = diff;
+      }
+    }
+
+    // parent is assumed to be aligned already
+    currentKey = getKey(parent);
+    parent = parents.get(currentKey);
+  }
+
+  // leadPoint is assumed to be aligned already
+  var leadPoint = points.get(currentKey);
+  if (leadPoint) {
+    var fromDiff = normalizePoint(leadPoint.diff(startPoint));
+    if (!fromDiff.equals(prevDiff)) {
+      route.unshift(leadPoint);
+    }
+  }
+  return route;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rxflow/manhattan",
+  "version": "0.0.1-alpha.0",
+  "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
+  "keywords": [
+    "reactflow",
+    "manhattan",
+    "router",
+    "pathfinding",
+    "a-star",
+    "orthogonal",
+    "edge-routing"
+  ],
+  "homepage": "https://tree-graph.publib.cn/",
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.caijj.net:yanfaerbu/qianduan/tree-graph.git"
+  },
+  "license": "MIT",
+  "author": "yanxianliang@outlook.com",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./esm/index.d.ts",
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    }
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "cjs"
+  ],
+  "scripts": {
+    "build": "father build"
+  },
+  "peerDependencies": {
+    "@xyflow/react": ">=12.8.6"
+  },
+  "gitHead": "dcdc06b5032aac044fa2094877d28c509c30d9eb"
+}