@rxflow/manhattan 0.0.1-alpha.0

package/esm/options/defaults.js

@@ -0,0 +1,33 @@
+import { Point } from "../geometry";
+/**
+ * Default configuration for Manhattan router
+ */
+export var defaults = {
+  step: 10,
+  maxLoopCount: 2000,
+  precision: 1,
+  maxDirectionChange: 90,
+  startDirections: ['top', 'right', 'bottom', 'left'],
+  endDirections: ['top', 'right', 'bottom', 'left'],
+  excludeNodes: [],
+  excludeShapes: [],
+  excludeTerminals: [],
+  padding: 0,
+  snapToGrid: true,
+  borderRadius: 5,
+  penalties: {
+    0: 0,
+    45: 5,
+    90: 5
+  }
+};
+
+/**
+ * Direction map - maps direction names to unit vectors
+ */
+export var directionMap = {
+  top: new Point(0, -1),
+  right: new Point(1, 0),
+  bottom: new Point(0, 1),
+  left: new Point(-1, 0)
+};

package/esm/options/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './defaults';
+export * from './resolver';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/options/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/esm/options/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./defaults";
+export * from "./resolver";

package/esm/options/resolver.d.ts

@@ -0,0 +1,10 @@
+import type { ManhattanRouterOptions, ResolvedOptions } from './types';
+/**
+ * Normalize angle to 0-360 range
+ */
+export declare function normalizeAngle(angle: number): number;
+/**
+ * Resolve options by merging user options with defaults
+ */
+export declare function resolveOptions(options?: ManhattanRouterOptions): ResolvedOptions;
+//# sourceMappingURL=resolver.d.ts.map

package/esm/options/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/options/resolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAetE;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA+DpF"}

package/esm/options/resolver.js

@@ -0,0 +1,114 @@
+import { Point } from "../geometry";
+import { defaults, directionMap } from "./defaults";
+
+/**
+ * Normalize padding value to box format
+ */
+function normalizePadding(padding) {
+  if (typeof padding === 'number') {
+    return {
+      top: padding,
+      right: padding,
+      bottom: padding,
+      left: padding
+    };
+  }
+  return padding;
+}
+
+/**
+ * Normalize angle to 0-360 range
+ */
+export function normalizeAngle(angle) {
+  while (angle < 0) {
+    angle += 360;
+  }
+  while (angle >= 360) {
+    angle -= 360;
+  }
+  return angle;
+}
+
+/**
+ * Resolve options by merging user options with defaults
+ */
+export function resolveOptions() {
+  var _options$step, _options$maxLoopCount, _options$precision, _options$maxDirection, _options$startDirecti, _options$endDirection, _options$excludeNodes, _options$excludeShape, _options$excludeTermi, _options$snapToGrid, _options$borderRadius, _options$penalties, _options$padding;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var step = (_options$step = options.step) !== null && _options$step !== void 0 ? _options$step : defaults.step;
+  var maxLoopCount = (_options$maxLoopCount = options.maxLoopCount) !== null && _options$maxLoopCount !== void 0 ? _options$maxLoopCount : defaults.maxLoopCount;
+  var precision = (_options$precision = options.precision) !== null && _options$precision !== void 0 ? _options$precision : defaults.precision;
+  var maxDirectionChange = (_options$maxDirection = options.maxDirectionChange) !== null && _options$maxDirection !== void 0 ? _options$maxDirection : defaults.maxDirectionChange;
+  var startDirections = (_options$startDirecti = options.startDirections) !== null && _options$startDirecti !== void 0 ? _options$startDirecti : defaults.startDirections;
+  var endDirections = (_options$endDirection = options.endDirections) !== null && _options$endDirection !== void 0 ? _options$endDirection : defaults.endDirections;
+  var excludeNodes = (_options$excludeNodes = options.excludeNodes) !== null && _options$excludeNodes !== void 0 ? _options$excludeNodes : defaults.excludeNodes;
+  var excludeShapes = (_options$excludeShape = options.excludeShapes) !== null && _options$excludeShape !== void 0 ? _options$excludeShape : defaults.excludeShapes;
+  var excludeTerminals = (_options$excludeTermi = options.excludeTerminals) !== null && _options$excludeTermi !== void 0 ? _options$excludeTermi : defaults.excludeTerminals;
+  var snapToGrid = (_options$snapToGrid = options.snapToGrid) !== null && _options$snapToGrid !== void 0 ? _options$snapToGrid : defaults.snapToGrid;
+  var borderRadius = (_options$borderRadius = options.borderRadius) !== null && _options$borderRadius !== void 0 ? _options$borderRadius : defaults.borderRadius;
+  var penalties = (_options$penalties = options.penalties) !== null && _options$penalties !== void 0 ? _options$penalties : defaults.penalties;
+  var fallbackRoute = options.fallbackRoute;
+
+  // Convert padding to paddingBox
+  var padding = (_options$padding = options.padding) !== null && _options$padding !== void 0 ? _options$padding : defaults.padding;
+  var sides = normalizePadding(padding);
+  var paddingBox = {
+    x: -sides.left,
+    y: -sides.top,
+    width: sides.left + sides.right,
+    height: sides.top + sides.bottom
+  };
+
+  // Calculate cost (same as step)
+  var cost = step;
+
+  // Calculate directions array with offsets and costs
+  var directions = [{
+    cost: cost,
+    offsetX: step,
+    offsetY: 0,
+    angle: 0
+  }, {
+    cost: cost,
+    offsetX: -step,
+    offsetY: 0,
+    angle: 0
+  }, {
+    cost: cost,
+    offsetX: 0,
+    offsetY: step,
+    angle: 0
+  }, {
+    cost: cost,
+    offsetX: 0,
+    offsetY: -step,
+    angle: 0
+  }];
+
+  // Calculate angle for each direction
+  directions.forEach(function (direction) {
+    var point1 = new Point(0, 0);
+    var point2 = new Point(direction.offsetX, direction.offsetY);
+    direction.angle = normalizeAngle(point1.theta(point2));
+  });
+  return {
+    step: step,
+    maxLoopCount: maxLoopCount,
+    precision: precision,
+    maxDirectionChange: maxDirectionChange,
+    startDirections: startDirections,
+    endDirections: endDirections,
+    excludeNodes: excludeNodes,
+    excludeShapes: excludeShapes,
+    excludeTerminals: excludeTerminals,
+    paddingBox: paddingBox,
+    snapToGrid: snapToGrid,
+    borderRadius: borderRadius,
+    directionMap: directionMap,
+    directions: directions,
+    penalties: penalties,
+    cost: cost,
+    fallbackRoute: fallbackRoute,
+    previousDirectionAngle: undefined
+  };
+}

package/esm/options/types.d.ts

@@ -0,0 +1,156 @@
+import { Point } from '../geometry';
+/**
+ * Direction type for routing
+ */
+export type Direction = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * ReactFlow internal node structure
+ * Based on ReactFlow's InternalNodeBase type
+ */
+export interface InternalNode {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    internals: {
+        positionAbsolute: {
+            x: number;
+            y: number;
+        };
+    };
+    measured?: {
+        width?: number;
+        height?: number;
+    };
+    width?: number;
+    height?: number;
+    initialWidth?: number;
+    initialHeight?: number;
+    type?: string;
+    [key: string]: any;
+}
+/**
+ * Node lookup map type (ReactFlow's internal structure)
+ */
+export type NodeLookup = Map<string, InternalNode>;
+/**
+ * Manhattan router configuration options
+ */
+export interface ManhattanRouterOptions {
+    /**
+     * The size of step to find a route (the grid of the manhattan pathfinder)
+     * @default 10
+     */
+    step?: number;
+    /**
+     * The number of route finding loops that cause the router to abort and return fallback route instead
+     * @default 2000
+     */
+    maxLoopCount?: number;
+    /**
+     * The number of decimal places to round floating point coordinates
+     * @default 1
+     */
+    precision?: number;
+    /**
+     * The maximum change of direction (in degrees)
+     * @default 90
+     */
+    maxDirectionChange?: number;
+    /**
+     * Possible starting directions from a node
+     * @default ['top', 'right', 'bottom', 'left']
+     */
+    startDirections?: Direction[];
+    /**
+     * Possible ending directions to a node
+     * @default ['top', 'right', 'bottom', 'left']
+     */
+    endDirections?: Direction[];
+    /**
+     * Should certain nodes not be considered as obstacles?
+     */
+    excludeNodes?: string[];
+    /**
+     * Should certain types of nodes not be considered as obstacles?
+     */
+    excludeShapes?: string[];
+    /**
+     * Should the source and/or target not be considered as obstacles?
+     */
+    excludeTerminals?: ('source' | 'target')[];
+    /**
+     * The padding applied on the element bounding boxes
+     */
+    padding?: number | {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /**
+     * Whether the calculation results are aligned with the grid
+     * @default true
+     */
+    snapToGrid?: boolean;
+    /**
+     * Border radius for rounded corners at path turns (in pixels)
+     * Set to 0 for sharp corners
+     * @default 5
+     */
+    borderRadius?: number;
+    /**
+     * A penalty received for direction change
+     */
+    penalties?: {
+        [angle: number]: number;
+    };
+    /**
+     * Fallback route function when pathfinding fails
+     */
+    fallbackRoute?: (from: Point, to: Point) => Point[];
+}
+/**
+ * Resolved options with all defaults applied
+ */
+export interface ResolvedOptions {
+    step: number;
+    maxLoopCount: number;
+    precision: number;
+    maxDirectionChange: number;
+    startDirections: Direction[];
+    endDirections: Direction[];
+    excludeNodes: string[];
+    excludeShapes: string[];
+    excludeTerminals: ('source' | 'target')[];
+    paddingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    snapToGrid: boolean;
+    borderRadius: number;
+    directionMap: {
+        top: Point;
+        right: Point;
+        bottom: Point;
+        left: Point;
+    };
+    directions: Array<{
+        cost: number;
+        offsetX: number;
+        offsetY: number;
+        angle?: number;
+        gridOffsetX?: number;
+        gridOffsetY?: number;
+    }>;
+    penalties: {
+        [angle: number]: number;
+    };
+    cost: number;
+    fallbackRoute?: (from: Point, to: Point) => Point[];
+    previousDirectionAngle?: number | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/options/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/options/types.ts"],"names":[],"mappings":"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"}

package/esm/options/types.js

@@ -0,0 +1 @@
+export {};

package/esm/pathfinder/SortedSet.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SortedSet class for managing open and closed sets in A* algorithm
+ * Maintains items sorted by their values
+ */
+export declare class SortedSet {
+    private items;
+    private hash;
+    private values;
+    constructor();
+    /**
+     * Add an item with its value, maintaining sorted order
+     */
+    add(item: string, value: number): void;
+    /**
+     * Pop the item with minimum value and mark it as closed
+     */
+    pop(): string | undefined;
+    /**
+     * Check if item is in open set
+     */
+    isOpen(item: string): boolean;
+    /**
+     * Check if item is in closed set
+     */
+    isClose(item: string): boolean;
+    /**
+     * Check if open set is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Find sorted insertion index for an item
+     */
+    private sortedIndexBy;
+}
+//# sourceMappingURL=SortedSet.d.ts.map

package/esm/pathfinder/SortedSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortedSet.d.ts","sourceRoot":"","sources":["../../src/pathfinder/SortedSet.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,MAAM,CAAqB;;IAQnC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAkBtC;;OAEG;IACH,GAAG,IAAI,MAAM,GAAG,SAAS;IAQzB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI7B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,OAAO,CAAC,aAAa;CAiBtB"}

package/esm/pathfinder/SortedSet.js

@@ -0,0 +1,110 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var OPEN = 1;
+var CLOSE = 2;
+
+/**
+ * SortedSet class for managing open and closed sets in A* algorithm
+ * Maintains items sorted by their values
+ */
+export var SortedSet = /*#__PURE__*/function () {
+  function SortedSet() {
+    _classCallCheck(this, SortedSet);
+    _defineProperty(this, "items", void 0);
+    _defineProperty(this, "hash", void 0);
+    _defineProperty(this, "values", void 0);
+    this.items = [];
+    this.hash = new Map();
+    this.values = new Map();
+  }
+
+  /**
+   * Add an item with its value, maintaining sorted order
+   */
+  _createClass(SortedSet, [{
+    key: "add",
+    value: function add(item, value) {
+      if (this.hash.get(item)) {
+        // Item removal - remove from items array
+        var _index = this.items.indexOf(item);
+        if (_index !== -1) {
+          this.items.splice(_index, 1);
+        }
+      } else {
+        this.hash.set(item, OPEN);
+      }
+      this.values.set(item, value);
+
+      // Find insertion index using binary search
+      var index = this.sortedIndexBy(item);
+      this.items.splice(index, 0, item);
+    }
+
+    /**
+     * Pop the item with minimum value and mark it as closed
+     */
+  }, {
+    key: "pop",
+    value: function pop() {
+      var item = this.items.shift();
+      if (item) {
+        this.hash.set(item, CLOSE);
+      }
+      return item;
+    }
+
+    /**
+     * Check if item is in open set
+     */
+  }, {
+    key: "isOpen",
+    value: function isOpen(item) {
+      return this.hash.get(item) === OPEN;
+    }
+
+    /**
+     * Check if item is in closed set
+     */
+  }, {
+    key: "isClose",
+    value: function isClose(item) {
+      return this.hash.get(item) === CLOSE;
+    }
+
+    /**
+     * Check if open set is empty
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.items.length === 0;
+    }
+
+    /**
+     * Find sorted insertion index for an item
+     */
+  }, {
+    key: "sortedIndexBy",
+    value: function sortedIndexBy(item) {
+      var value = this.values.get(item);
+      var low = 0;
+      var high = this.items.length;
+      while (low < high) {
+        var mid = low + high >>> 1;
+        var midValue = this.values.get(this.items[mid]);
+        if (midValue < value) {
+          low = mid + 1;
+        } else {
+          high = mid;
+        }
+      }
+      return low;
+    }
+  }]);
+  return SortedSet;
+}();

package/esm/pathfinder/findRoute.d.ts

@@ -0,0 +1,8 @@
+import { Point, Rectangle } from '../geometry';
+import type { ResolvedOptions } from '../options';
+import type { ObstacleMap } from '../obstacle';
+/**
+ * Find route between two points using A* algorithm
+ */
+export declare function findRoute(sourceBBox: Rectangle, targetBBox: Rectangle, sourceAnchor: Point, targetAnchor: Point, map: ObstacleMap, options: ResolvedOptions): Point[] | null;
+//# sourceMappingURL=findRoute.d.ts.map

package/esm/pathfinder/findRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRoute.d.ts","sourceRoot":"","sources":["../../src/pathfinder/findRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAe9C;;GAEG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,EACrB,UAAU,EAAE,SAAS,EACrB,YAAY,EAAE,KAAK,EACnB,YAAY,EAAE,KAAK,EACnB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,GAAG,IAAI,CAsNhB"}