@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/obstacle/QuadTree.js

@@ -0,0 +1,334 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.QuadTree = void 0;
+exports.createQuadTreeFromRects = createQuadTreeFromRects;
+var _geometry = require("../geometry");
+/**
+ * QuadTree implementation for efficient spatial queries
+ * Feature: manhattan-optimization
+ *
+ * A QuadTree is a tree data structure that recursively subdivides 2D space
+ * into four quadrants. This enables O(log n) spatial queries instead of O(n).
+ */
+
+/**
+ * Item stored in the QuadTree
+ */
+
+/**
+ * QuadTree configuration
+ */
+
+/**
+ * Default QuadTree configuration
+ */
+const DEFAULT_CONFIG = {
+  maxItems: 8,
+  maxDepth: 8,
+  minSize: 10
+};
+
+/**
+ * QuadTree node for spatial partitioning
+ */
+class QuadTree {
+  bounds;
+  items;
+  children;
+  depth;
+  config;
+  constructor(bounds, config = {}, depth = 0) {
+    this.bounds = bounds;
+    this.items = [];
+    this.children = null;
+    this.depth = depth;
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  }
+
+  /**
+   * Insert an item into the QuadTree
+   */
+  insert(item) {
+    // Check if item intersects this node's bounds
+    if (!this.intersects(item.bounds)) {
+      return false;
+    }
+
+    // If we have children, try to insert into them
+    if (this.children !== null) {
+      return this.insertIntoChildren(item);
+    }
+
+    // Add to this node
+    this.items.push(item);
+
+    // Check if we need to split
+    if (this.shouldSplit()) {
+      this.split();
+    }
+    return true;
+  }
+
+  /**
+   * Insert an item with just bounds and data
+   */
+  insertRect(bounds, data) {
+    return this.insert({
+      bounds,
+      data
+    });
+  }
+
+  /**
+   * Query all items that intersect with the given bounds
+   */
+  query(bounds) {
+    const results = [];
+    this.queryInternal(bounds, results);
+    return results;
+  }
+
+  /**
+   * Query all items that contain the given point
+   */
+  queryPoint(point) {
+    const results = [];
+    this.queryPointInternal(point, results);
+    return results;
+  }
+
+  /**
+   * Get all items in the tree
+   */
+  getAllItems() {
+    const results = [...this.items];
+    if (this.children !== null) {
+      for (const child of this.children) {
+        results.push(...child.getAllItems());
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Clear all items from the tree
+   */
+  clear() {
+    this.items = [];
+    this.children = null;
+  }
+
+  /**
+   * Get the total number of items in the tree
+   */
+  get size() {
+    let count = this.items.length;
+    if (this.children !== null) {
+      for (const child of this.children) {
+        count += child.size;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Get the depth of the tree
+   */
+  getMaxDepth() {
+    if (this.children === null) {
+      return this.depth;
+    }
+    let maxChildDepth = this.depth;
+    for (const child of this.children) {
+      maxChildDepth = Math.max(maxChildDepth, child.getMaxDepth());
+    }
+    return maxChildDepth;
+  }
+
+  /**
+   * Internal query implementation
+   */
+  queryInternal(bounds, results) {
+    // Check if query bounds intersects this node
+    if (!this.intersects(bounds)) {
+      return;
+    }
+
+    // Check items in this node
+    for (const item of this.items) {
+      if (this.rectanglesIntersect(item.bounds, bounds)) {
+        results.push(item);
+      }
+    }
+
+    // Query children
+    if (this.children !== null) {
+      for (const child of this.children) {
+        child.queryInternal(bounds, results);
+      }
+    }
+  }
+
+  /**
+   * Internal point query implementation
+   */
+  queryPointInternal(point, results) {
+    // Check if point is within this node's bounds
+    if (!this.containsPoint(point)) {
+      return;
+    }
+
+    // Check items in this node
+    for (const item of this.items) {
+      if (item.bounds.containsPoint(point)) {
+        results.push(item);
+      }
+    }
+
+    // Query children
+    if (this.children !== null) {
+      for (const child of this.children) {
+        child.queryPointInternal(point, results);
+      }
+    }
+  }
+
+  /**
+   * Check if this node should split
+   */
+  shouldSplit() {
+    return this.items.length > this.config.maxItems && this.depth < this.config.maxDepth && this.bounds.width > this.config.minSize * 2 && this.bounds.height > this.config.minSize * 2;
+  }
+
+  /**
+   * Split this node into four children
+   */
+  split() {
+    const halfWidth = this.bounds.width / 2;
+    const halfHeight = this.bounds.height / 2;
+    const x = this.bounds.x;
+    const y = this.bounds.y;
+    const nextDepth = this.depth + 1;
+    this.children = [
+    // Top-left
+    new QuadTree(new _geometry.Rectangle(x, y, halfWidth, halfHeight), this.config, nextDepth),
+    // Top-right
+    new QuadTree(new _geometry.Rectangle(x + halfWidth, y, halfWidth, halfHeight), this.config, nextDepth),
+    // Bottom-left
+    new QuadTree(new _geometry.Rectangle(x, y + halfHeight, halfWidth, halfHeight), this.config, nextDepth),
+    // Bottom-right
+    new QuadTree(new _geometry.Rectangle(x + halfWidth, y + halfHeight, halfWidth, halfHeight), this.config, nextDepth)];
+
+    // Redistribute items to children
+    const itemsToRedistribute = this.items;
+    this.items = [];
+    for (const item of itemsToRedistribute) {
+      this.insertIntoChildren(item);
+    }
+  }
+
+  /**
+   * Insert item into appropriate children
+   */
+  insertIntoChildren(item) {
+    if (this.children === null) {
+      return false;
+    }
+    let inserted = false;
+    for (const child of this.children) {
+      if (child.insert(item)) {
+        inserted = true;
+      }
+    }
+
+    // If item doesn't fit in any child (spans multiple), keep in this node
+    if (!inserted) {
+      this.items.push(item);
+      inserted = true;
+    }
+    return inserted;
+  }
+
+  /**
+   * Check if a rectangle intersects this node's bounds
+   */
+  intersects(rect) {
+    return this.rectanglesIntersect(this.bounds, rect);
+  }
+
+  /**
+   * Check if two rectangles intersect
+   */
+  rectanglesIntersect(a, b) {
+    return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+  }
+
+  /**
+   * Check if this node's bounds contain a point
+   */
+  containsPoint(point) {
+    return point.x >= this.bounds.x && point.x <= this.bounds.x + this.bounds.width && point.y >= this.bounds.y && point.y <= this.bounds.y + this.bounds.height;
+  }
+
+  /**
+   * Get statistics about the tree
+   */
+  getStats() {
+    const stats = {
+      totalItems: 0,
+      maxDepth: 0,
+      nodeCount: 0,
+      itemsPerNode: 0
+    };
+    this.collectStats(stats);
+    stats.itemsPerNode = stats.nodeCount > 0 ? stats.totalItems / stats.nodeCount : 0;
+    return stats;
+  }
+  collectStats(stats) {
+    stats.totalItems += this.items.length;
+    stats.maxDepth = Math.max(stats.maxDepth, this.depth);
+    stats.nodeCount++;
+    if (this.children !== null) {
+      for (const child of this.children) {
+        child.collectStats(stats);
+      }
+    }
+  }
+}
+
+/**
+ * Create a QuadTree with bounds that cover all given rectangles
+ */
+exports.QuadTree = QuadTree;
+function createQuadTreeFromRects(items, config) {
+  if (items.length === 0) {
+    return new QuadTree(new _geometry.Rectangle(0, 0, 1000, 1000), config);
+  }
+
+  // Calculate bounding box of all items
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const item of items) {
+    minX = Math.min(minX, item.bounds.x);
+    minY = Math.min(minY, item.bounds.y);
+    maxX = Math.max(maxX, item.bounds.x + item.bounds.width);
+    maxY = Math.max(maxY, item.bounds.y + item.bounds.height);
+  }
+
+  // Add some padding
+  const padding = 100;
+  const bounds = new _geometry.Rectangle(minX - padding, minY - padding, maxX - minX + padding * 2, maxY - minY + padding * 2);
+  const tree = new QuadTree(bounds, config);
+  for (const item of items) {
+    tree.insert(item);
+  }
+  return tree;
+}

package/cjs/obstacle/index.d.ts

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

package/cjs/obstacle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/obstacle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/cjs/obstacle/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ObstacleMap", {
+  enumerable: true,
+  get: function () {
+    return _ObstacleMap.ObstacleMap;
+  }
+});
+var _ObstacleMap = require("./ObstacleMap");

package/cjs/options/defaults.d.ts

@@ -0,0 +1,16 @@
+import { Point } from '../geometry';
+import type { ManhattanRouterOptions } from './types';
+/**
+ * Default configuration for Manhattan router
+ */
+export declare const defaults: Required<Omit<ManhattanRouterOptions, 'fallbackRoute' | 'sourcePosition' | 'targetPosition' | 'performance' | 'adaptiveStep' | 'debug'>>;
+/**
+ * Direction map - maps direction names to unit vectors
+ */
+export declare const directionMap: {
+    top: Point;
+    right: Point;
+    bottom: Point;
+    left: Point;
+};
+//# sourceMappingURL=defaults.d.ts.map

package/cjs/options/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/options/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAa,MAAM,SAAS,CAAA;AAEhE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,sBAAsB,EAAE,eAAe,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,aAAa,GAAG,cAAc,GAAG,OAAO,CAAC,CAkB7J,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA"}

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: 15,
+  borderRadius: 5,
+  extensionDistance: 20,
+  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,EAAkC,MAAM,SAAS,CAAA;AAmCtG;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAgGD;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA4EpF"}