@rxflow/manhattan 0.0.1-alpha.0

package/cjs/options/defaults.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.directionMap = exports.defaults = void 0;
+var _geometry = require("../geometry");
+/**
+ * Default configuration for Manhattan router
+ */
+const defaults = exports.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
+ */
+const directionMap = exports.directionMap = {
+  top: new _geometry.Point(0, -1),
+  right: new _geometry.Point(1, 0),
+  bottom: new _geometry.Point(0, 1),
+  left: new _geometry.Point(-1, 0)
+};

package/cjs/options/index.d.ts

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

package/cjs/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/cjs/options/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _defaults = require("./defaults");
+Object.keys(_defaults).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _defaults[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _defaults[key];
+    }
+  });
+});
+var _resolver = require("./resolver");
+Object.keys(_resolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolver[key];
+    }
+  });
+});

package/cjs/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/cjs/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/cjs/options/resolver.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeAngle = normalizeAngle;
+exports.resolveOptions = resolveOptions;
+var _geometry = require("../geometry");
+var _defaults = require("./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
+ */
+function normalizeAngle(angle) {
+  while (angle < 0) {
+    angle += 360;
+  }
+  while (angle >= 360) {
+    angle -= 360;
+  }
+  return angle;
+}
+
+/**
+ * Resolve options by merging user options with defaults
+ */
+function resolveOptions(options = {}) {
+  const step = options.step ?? _defaults.defaults.step;
+  const maxLoopCount = options.maxLoopCount ?? _defaults.defaults.maxLoopCount;
+  const precision = options.precision ?? _defaults.defaults.precision;
+  const maxDirectionChange = options.maxDirectionChange ?? _defaults.defaults.maxDirectionChange;
+  const startDirections = options.startDirections ?? _defaults.defaults.startDirections;
+  const endDirections = options.endDirections ?? _defaults.defaults.endDirections;
+  const excludeNodes = options.excludeNodes ?? _defaults.defaults.excludeNodes;
+  const excludeShapes = options.excludeShapes ?? _defaults.defaults.excludeShapes;
+  const excludeTerminals = options.excludeTerminals ?? _defaults.defaults.excludeTerminals;
+  const snapToGrid = options.snapToGrid ?? _defaults.defaults.snapToGrid;
+  const borderRadius = options.borderRadius ?? _defaults.defaults.borderRadius;
+  const penalties = options.penalties ?? _defaults.defaults.penalties;
+  const fallbackRoute = options.fallbackRoute;
+
+  // Convert padding to paddingBox
+  const padding = options.padding ?? _defaults.defaults.padding;
+  const sides = normalizePadding(padding);
+  const paddingBox = {
+    x: -sides.left,
+    y: -sides.top,
+    width: sides.left + sides.right,
+    height: sides.top + sides.bottom
+  };
+
+  // Calculate cost (same as step)
+  const cost = step;
+
+  // Calculate directions array with offsets and costs
+  const directions = [{
+    cost,
+    offsetX: step,
+    offsetY: 0,
+    angle: 0
+  }, {
+    cost,
+    offsetX: -step,
+    offsetY: 0,
+    angle: 0
+  }, {
+    cost,
+    offsetX: 0,
+    offsetY: step,
+    angle: 0
+  }, {
+    cost,
+    offsetX: 0,
+    offsetY: -step,
+    angle: 0
+  }];
+
+  // Calculate angle for each direction
+  directions.forEach(direction => {
+    const point1 = new _geometry.Point(0, 0);
+    const point2 = new _geometry.Point(direction.offsetX, direction.offsetY);
+    direction.angle = normalizeAngle(point1.theta(point2));
+  });
+  return {
+    step,
+    maxLoopCount,
+    precision,
+    maxDirectionChange,
+    startDirections,
+    endDirections,
+    excludeNodes,
+    excludeShapes,
+    excludeTerminals,
+    paddingBox,
+    snapToGrid,
+    borderRadius,
+    directionMap: _defaults.directionMap,
+    directions,
+    penalties,
+    cost,
+    fallbackRoute,
+    previousDirectionAngle: undefined
+  };
+}

package/cjs/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/cjs/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/cjs/options/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/cjs/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/cjs/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/cjs/pathfinder/SortedSet.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SortedSet = void 0;
+const OPEN = 1;
+const CLOSE = 2;
+
+/**
+ * SortedSet class for managing open and closed sets in A* algorithm
+ * Maintains items sorted by their values
+ */
+class SortedSet {
+  items;
+  hash;
+  values;
+  constructor() {
+    this.items = [];
+    this.hash = new Map();
+    this.values = new Map();
+  }
+
+  /**
+   * Add an item with its value, maintaining sorted order
+   */
+  add(item, value) {
+    if (this.hash.get(item)) {
+      // Item removal - remove from items array
+      const 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
+    const index = this.sortedIndexBy(item);
+    this.items.splice(index, 0, item);
+  }
+
+  /**
+   * Pop the item with minimum value and mark it as closed
+   */
+  pop() {
+    const item = this.items.shift();
+    if (item) {
+      this.hash.set(item, CLOSE);
+    }
+    return item;
+  }
+
+  /**
+   * Check if item is in open set
+   */
+  isOpen(item) {
+    return this.hash.get(item) === OPEN;
+  }
+
+  /**
+   * Check if item is in closed set
+   */
+  isClose(item) {
+    return this.hash.get(item) === CLOSE;
+  }
+
+  /**
+   * Check if open set is empty
+   */
+  isEmpty() {
+    return this.items.length === 0;
+  }
+
+  /**
+   * Find sorted insertion index for an item
+   */
+  sortedIndexBy(item) {
+    const value = this.values.get(item);
+    let low = 0;
+    let high = this.items.length;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      const midValue = this.values.get(this.items[mid]);
+      if (midValue < value) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return low;
+  }
+}
+exports.SortedSet = SortedSet;

package/cjs/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/cjs/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"}