@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/pathfinder/PathCache.js

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PathCache = void 0;
+exports.generateCacheKey = generateCacheKey;
+exports.getGlobalPathCache = getGlobalPathCache;
+exports.resetGlobalPathCache = resetGlobalPathCache;
+/**
+ * PathCache - LRU cache for computed paths
+ * Feature: manhattan-optimization
+ *
+ * Implements a Least Recently Used (LRU) cache for storing computed paths.
+ * This improves performance by avoiding redundant path calculations for
+ * identical source-target-options combinations.
+ *
+ * Requirements: 3.4
+ */
+
+/**
+ * Cache entry containing the computed path and metadata
+ */
+
+/**
+ * Configuration for PathCache
+ */
+
+/**
+ * Default cache configuration
+ */
+const DEFAULT_CONFIG = {
+  maxSize: 1000,
+  ttl: 60000,
+  // 1 minute
+  enabled: true
+};
+
+/**
+ * Generate a cache key from path parameters
+ */
+function generateCacheKey(sourceBBox, targetBBox, sourceAnchor, targetAnchor, options) {
+  // Include key configuration options that affect path calculation
+  const optionsKey = [options.step, options.extensionDistance, options.maxDirectionChange, options.sourcePosition || '', options.targetPosition || '', options.borderRadius].join(',');
+  return [
+  // Source bbox
+  `s:${sourceBBox.x},${sourceBBox.y},${sourceBBox.width},${sourceBBox.height}`,
+  // Target bbox
+  `t:${targetBBox.x},${targetBBox.y},${targetBBox.width},${targetBBox.height}`,
+  // Anchors
+  `sa:${sourceAnchor.x},${sourceAnchor.y}`, `ta:${targetAnchor.x},${targetAnchor.y}`,
+  // Options
+  `o:${optionsKey}`].join('|');
+}
+
+/**
+ * LRU Cache for computed paths
+ */
+class PathCache {
+  cache;
+  config;
+  hits = 0;
+  misses = 0;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.cache = new Map();
+  }
+
+  /**
+   * Get a cached path if available and not expired
+   */
+  get(key) {
+    if (!this.config.enabled) {
+      this.misses++;
+      return null;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+
+    // Check TTL expiration
+    if (this.config.ttl > 0) {
+      const age = Date.now() - entry.timestamp;
+      if (age > this.config.ttl) {
+        this.cache.delete(key);
+        this.misses++;
+        return null;
+      }
+    }
+
+    // Update hit count and move to end (most recently used)
+    entry.hitCount++;
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this.hits++;
+    // Return cloned path to prevent mutation
+    return entry.path.map(p => p.clone());
+  }
+
+  /**
+   * Store a path in the cache
+   */
+  set(key, path) {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    // Evict oldest entries if at capacity
+    while (this.cache.size >= this.config.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, {
+      path: path.map(p => p.clone()),
+      // Clone points to prevent mutation
+      timestamp: Date.now(),
+      hitCount: 0
+    });
+  }
+
+  /**
+   * Check if a key exists in the cache (without updating LRU order)
+   */
+  has(key) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    // Check TTL expiration
+    if (this.config.ttl > 0) {
+      const age = Date.now() - entry.timestamp;
+      if (age > this.config.ttl) {
+        this.cache.delete(key);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.config.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+
+  /**
+   * Update cache configuration
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+
+    // If cache is disabled, clear it
+    if (!this.config.enabled) {
+      this.clear();
+    }
+
+    // If maxSize reduced, evict excess entries
+    while (this.cache.size > this.config.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+
+  /**
+   * Remove expired entries (useful for periodic cleanup)
+   */
+  cleanup() {
+    if (this.config.ttl <= 0) {
+      return 0;
+    }
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.config.ttl) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+}
+
+/**
+ * Global path cache instance (singleton)
+ */
+exports.PathCache = PathCache;
+let globalPathCache = null;
+
+/**
+ * Get the global path cache instance
+ */
+function getGlobalPathCache() {
+  if (!globalPathCache) {
+    globalPathCache = new PathCache();
+  }
+  return globalPathCache;
+}
+
+/**
+ * Reset the global path cache (useful for testing)
+ */
+function resetGlobalPathCache() {
+  if (globalPathCache) {
+    globalPathCache.clear();
+  }
+  globalPathCache = null;
+}

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;AAiI9C;;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,CA2XhB"}