@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/options/resolver.js

@@ -1,5 +1,31 @@
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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); }
 import { Point } from "../geometry";
 import { defaults, directionMap } from "./defaults";
+import { DEFAULT_ADAPTIVE_STEP_CONFIG } from "../utils/AdaptiveStepCalculator";
+
+/**
+ * Default performance configuration
+ */
+var DEFAULT_PERFORMANCE_CONFIG = {
+  enableCache: true,
+  cacheSize: 100,
+  enableQuadTree: true,
+  earlyTermination: false
+};
+
+/**
+ * Default debug configuration
+ */
+var DEFAULT_DEBUG_CONFIG = {
+  enableLogging: false,
+  enableMetrics: false,
+  logLevel: 'info'
+};
 
 /**
  * Normalize padding value to box format
@@ -29,28 +55,123 @@ export function normalizeAngle(angle) {
   return angle;
 }
 
+/**
+ * Validate and fix configuration options
+ */
+function validateAndFixOptions(options) {
+  var fixed = _objectSpread({}, options);
+
+  // Validate step
+  if (fixed.step !== undefined && fixed.step <= 0) {
+    console.warn('[ManhattanRouter] Invalid step value, using default');
+    fixed.step = defaults.step;
+  }
+
+  // Validate maxLoopCount
+  if (fixed.maxLoopCount !== undefined && fixed.maxLoopCount <= 0) {
+    console.warn('[ManhattanRouter] Invalid maxLoopCount, using default');
+    fixed.maxLoopCount = defaults.maxLoopCount;
+  }
+
+  // Validate borderRadius
+  if (fixed.borderRadius !== undefined && fixed.borderRadius < 0) {
+    console.warn('[ManhattanRouter] Invalid borderRadius, using default');
+    fixed.borderRadius = defaults.borderRadius;
+  }
+
+  // Validate extensionDistance
+  if (fixed.extensionDistance !== undefined && fixed.extensionDistance < 0) {
+    console.warn('[ManhattanRouter] Invalid extensionDistance, using default');
+    fixed.extensionDistance = defaults.extensionDistance;
+  }
+
+  // Validate precision
+  if (fixed.precision !== undefined && (fixed.precision < 0 || fixed.precision > 10)) {
+    console.warn('[ManhattanRouter] Invalid precision, using default');
+    fixed.precision = defaults.precision;
+  }
+  return fixed;
+}
+
+/**
+ * Resolve adaptive step configuration
+ */
+function resolveAdaptiveStepConfig(config) {
+  var _config$enabled, _config$minStep, _config$maxStep, _config$densityBased$, _config$densityBased, _config$densityBased$2, _config$densityBased2, _config$distanceBased, _config$distanceBased2, _config$distanceBased3, _config$distanceBased4, _config$distanceBased5, _config$distanceBased6;
+  if (!config) {
+    return _objectSpread({}, DEFAULT_ADAPTIVE_STEP_CONFIG);
+  }
+  return {
+    enabled: (_config$enabled = config.enabled) !== null && _config$enabled !== void 0 ? _config$enabled : DEFAULT_ADAPTIVE_STEP_CONFIG.enabled,
+    minStep: (_config$minStep = config.minStep) !== null && _config$minStep !== void 0 ? _config$minStep : DEFAULT_ADAPTIVE_STEP_CONFIG.minStep,
+    maxStep: (_config$maxStep = config.maxStep) !== null && _config$maxStep !== void 0 ? _config$maxStep : DEFAULT_ADAPTIVE_STEP_CONFIG.maxStep,
+    densityBased: {
+      enabled: (_config$densityBased$ = (_config$densityBased = config.densityBased) === null || _config$densityBased === void 0 ? void 0 : _config$densityBased.enabled) !== null && _config$densityBased$ !== void 0 ? _config$densityBased$ : DEFAULT_ADAPTIVE_STEP_CONFIG.densityBased.enabled,
+      threshold: (_config$densityBased$2 = (_config$densityBased2 = config.densityBased) === null || _config$densityBased2 === void 0 ? void 0 : _config$densityBased2.threshold) !== null && _config$densityBased$2 !== void 0 ? _config$densityBased$2 : DEFAULT_ADAPTIVE_STEP_CONFIG.densityBased.threshold
+    },
+    distanceBased: {
+      enabled: (_config$distanceBased = (_config$distanceBased2 = config.distanceBased) === null || _config$distanceBased2 === void 0 ? void 0 : _config$distanceBased2.enabled) !== null && _config$distanceBased !== void 0 ? _config$distanceBased : DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.enabled,
+      shortPathThreshold: (_config$distanceBased3 = (_config$distanceBased4 = config.distanceBased) === null || _config$distanceBased4 === void 0 ? void 0 : _config$distanceBased4.shortPathThreshold) !== null && _config$distanceBased3 !== void 0 ? _config$distanceBased3 : DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.shortPathThreshold,
+      longPathThreshold: (_config$distanceBased5 = (_config$distanceBased6 = config.distanceBased) === null || _config$distanceBased6 === void 0 ? void 0 : _config$distanceBased6.longPathThreshold) !== null && _config$distanceBased5 !== void 0 ? _config$distanceBased5 : DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.longPathThreshold
+    }
+  };
+}
+
+/**
+ * Resolve performance configuration
+ */
+function resolvePerformanceConfig(config) {
+  var _config$enableCache, _config$cacheSize, _config$enableQuadTre, _config$earlyTerminat;
+  if (!config) {
+    return _objectSpread({}, DEFAULT_PERFORMANCE_CONFIG);
+  }
+  return {
+    enableCache: (_config$enableCache = config.enableCache) !== null && _config$enableCache !== void 0 ? _config$enableCache : DEFAULT_PERFORMANCE_CONFIG.enableCache,
+    cacheSize: (_config$cacheSize = config.cacheSize) !== null && _config$cacheSize !== void 0 ? _config$cacheSize : DEFAULT_PERFORMANCE_CONFIG.cacheSize,
+    enableQuadTree: (_config$enableQuadTre = config.enableQuadTree) !== null && _config$enableQuadTre !== void 0 ? _config$enableQuadTre : DEFAULT_PERFORMANCE_CONFIG.enableQuadTree,
+    earlyTermination: (_config$earlyTerminat = config.earlyTermination) !== null && _config$earlyTerminat !== void 0 ? _config$earlyTerminat : DEFAULT_PERFORMANCE_CONFIG.earlyTermination
+  };
+}
+
+/**
+ * Resolve debug configuration
+ */
+function resolveDebugConfig(config) {
+  var _config$enableLogging, _config$enableMetrics, _config$logLevel;
+  if (!config) {
+    return _objectSpread({}, DEFAULT_DEBUG_CONFIG);
+  }
+  return {
+    enableLogging: (_config$enableLogging = config.enableLogging) !== null && _config$enableLogging !== void 0 ? _config$enableLogging : DEFAULT_DEBUG_CONFIG.enableLogging,
+    enableMetrics: (_config$enableMetrics = config.enableMetrics) !== null && _config$enableMetrics !== void 0 ? _config$enableMetrics : DEFAULT_DEBUG_CONFIG.enableMetrics,
+    logLevel: (_config$logLevel = config.logLevel) !== null && _config$logLevel !== void 0 ? _config$logLevel : DEFAULT_DEBUG_CONFIG.logLevel
+  };
+}
+
 /**
  * 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$borderRadius, _options$extensionDis, _options$penalties, _options$padding;
+  var _validatedOptions$ste, _validatedOptions$max, _validatedOptions$pre, _validatedOptions$max2, _validatedOptions$sta, _validatedOptions$end, _validatedOptions$exc, _validatedOptions$exc2, _validatedOptions$exc3, _validatedOptions$bor, _validatedOptions$ext, _validatedOptions$pen, _validatedOptions$pad;
   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 borderRadius = (_options$borderRadius = options.borderRadius) !== null && _options$borderRadius !== void 0 ? _options$borderRadius : defaults.borderRadius;
-  var extensionDistance = (_options$extensionDis = options.extensionDistance) !== null && _options$extensionDis !== void 0 ? _options$extensionDis : defaults.extensionDistance;
-  var penalties = (_options$penalties = options.penalties) !== null && _options$penalties !== void 0 ? _options$penalties : defaults.penalties;
-  var fallbackRoute = options.fallbackRoute;
+  // Validate and fix options first
+  var validatedOptions = validateAndFixOptions(options);
+  var step = (_validatedOptions$ste = validatedOptions.step) !== null && _validatedOptions$ste !== void 0 ? _validatedOptions$ste : defaults.step;
+  var maxLoopCount = (_validatedOptions$max = validatedOptions.maxLoopCount) !== null && _validatedOptions$max !== void 0 ? _validatedOptions$max : defaults.maxLoopCount;
+  var precision = (_validatedOptions$pre = validatedOptions.precision) !== null && _validatedOptions$pre !== void 0 ? _validatedOptions$pre : defaults.precision;
+  var maxDirectionChange = (_validatedOptions$max2 = validatedOptions.maxDirectionChange) !== null && _validatedOptions$max2 !== void 0 ? _validatedOptions$max2 : defaults.maxDirectionChange;
+  var startDirections = (_validatedOptions$sta = validatedOptions.startDirections) !== null && _validatedOptions$sta !== void 0 ? _validatedOptions$sta : defaults.startDirections;
+  var endDirections = (_validatedOptions$end = validatedOptions.endDirections) !== null && _validatedOptions$end !== void 0 ? _validatedOptions$end : defaults.endDirections;
+  var excludeNodes = (_validatedOptions$exc = validatedOptions.excludeNodes) !== null && _validatedOptions$exc !== void 0 ? _validatedOptions$exc : defaults.excludeNodes;
+  var excludeShapes = (_validatedOptions$exc2 = validatedOptions.excludeShapes) !== null && _validatedOptions$exc2 !== void 0 ? _validatedOptions$exc2 : defaults.excludeShapes;
+  var excludeTerminals = (_validatedOptions$exc3 = validatedOptions.excludeTerminals) !== null && _validatedOptions$exc3 !== void 0 ? _validatedOptions$exc3 : defaults.excludeTerminals;
+  var borderRadius = (_validatedOptions$bor = validatedOptions.borderRadius) !== null && _validatedOptions$bor !== void 0 ? _validatedOptions$bor : defaults.borderRadius;
+  var extensionDistance = (_validatedOptions$ext = validatedOptions.extensionDistance) !== null && _validatedOptions$ext !== void 0 ? _validatedOptions$ext : defaults.extensionDistance;
+  var penalties = (_validatedOptions$pen = validatedOptions.penalties) !== null && _validatedOptions$pen !== void 0 ? _validatedOptions$pen : defaults.penalties;
+  var fallbackRoute = validatedOptions.fallbackRoute;
 
   // Convert padding to paddingBox
-  var padding = (_options$padding = options.padding) !== null && _options$padding !== void 0 ? _options$padding : defaults.padding;
+  var padding = (_validatedOptions$pad = validatedOptions.padding) !== null && _validatedOptions$pad !== void 0 ? _validatedOptions$pad : defaults.padding;
   var sides = normalizePadding(padding);
   var paddingBox = {
     x: -sides.left,
@@ -91,6 +212,11 @@ export function resolveOptions() {
     var point2 = new Point(direction.offsetX, direction.offsetY);
     direction.angle = normalizeAngle(point1.theta(point2));
   });
+
+  // Resolve new configuration sections
+  var adaptiveStep = resolveAdaptiveStepConfig(validatedOptions.adaptiveStep);
+  var performance = resolvePerformanceConfig(validatedOptions.performance);
+  var debug = resolveDebugConfig(validatedOptions.debug);
   return {
     step: step,
     maxLoopCount: maxLoopCount,
@@ -104,13 +230,16 @@ export function resolveOptions() {
     paddingBox: paddingBox,
     borderRadius: borderRadius,
     extensionDistance: extensionDistance,
-    sourcePosition: options.sourcePosition,
-    targetPosition: options.targetPosition,
+    sourcePosition: validatedOptions.sourcePosition,
+    targetPosition: validatedOptions.targetPosition,
     directionMap: directionMap,
     directions: directions,
     penalties: penalties,
     cost: cost,
     fallbackRoute: fallbackRoute,
-    previousDirectionAngle: undefined
+    previousDirectionAngle: undefined,
+    adaptiveStep: adaptiveStep,
+    performance: performance,
+    debug: debug
   };
 }

package/esm/pathfinder/PathCache.js

@@ -0,0 +1,278 @@
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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); }
+/**
+ * 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
+ */
+var DEFAULT_CONFIG = {
+  maxSize: 1000,
+  ttl: 60000,
+  // 1 minute
+  enabled: true
+};
+
+/**
+ * Generate a cache key from path parameters
+ */
+export function generateCacheKey(sourceBBox, targetBBox, sourceAnchor, targetAnchor, options) {
+  // Include key configuration options that affect path calculation
+  var optionsKey = [options.step, options.extensionDistance, options.maxDirectionChange, options.sourcePosition || '', options.targetPosition || '', options.borderRadius].join(',');
+  return [// Source bbox
+  "s:".concat(sourceBBox.x, ",").concat(sourceBBox.y, ",").concat(sourceBBox.width, ",").concat(sourceBBox.height), // Target bbox
+  "t:".concat(targetBBox.x, ",").concat(targetBBox.y, ",").concat(targetBBox.width, ",").concat(targetBBox.height), // Anchors
+  "sa:".concat(sourceAnchor.x, ",").concat(sourceAnchor.y), "ta:".concat(targetAnchor.x, ",").concat(targetAnchor.y), // Options
+  "o:".concat(optionsKey)].join('|');
+}
+
+/**
+ * LRU Cache for computed paths
+ */
+export var PathCache = /*#__PURE__*/function () {
+  function PathCache() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, PathCache);
+    _defineProperty(this, "cache", void 0);
+    _defineProperty(this, "config", void 0);
+    _defineProperty(this, "hits", 0);
+    _defineProperty(this, "misses", 0);
+    this.config = _objectSpread(_objectSpread({}, DEFAULT_CONFIG), config);
+    this.cache = new Map();
+  }
+
+  /**
+   * Get a cached path if available and not expired
+   */
+  _createClass(PathCache, [{
+    key: "get",
+    value: function get(key) {
+      if (!this.config.enabled) {
+        this.misses++;
+        return null;
+      }
+      var entry = this.cache.get(key);
+      if (!entry) {
+        this.misses++;
+        return null;
+      }
+
+      // Check TTL expiration
+      if (this.config.ttl > 0) {
+        var 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(function (p) {
+        return p.clone();
+      });
+    }
+
+    /**
+     * Store a path in the cache
+     */
+  }, {
+    key: "set",
+    value: function set(key, path) {
+      if (!this.config.enabled) {
+        return;
+      }
+
+      // Evict oldest entries if at capacity
+      while (this.cache.size >= this.config.maxSize) {
+        var oldestKey = this.cache.keys().next().value;
+        if (oldestKey) {
+          this.cache.delete(oldestKey);
+        }
+      }
+      this.cache.set(key, {
+        path: path.map(function (p) {
+          return p.clone();
+        }),
+        // Clone points to prevent mutation
+        timestamp: Date.now(),
+        hitCount: 0
+      });
+    }
+
+    /**
+     * Check if a key exists in the cache (without updating LRU order)
+     */
+  }, {
+    key: "has",
+    value: function has(key) {
+      if (!this.config.enabled) {
+        return false;
+      }
+      var entry = this.cache.get(key);
+      if (!entry) {
+        return false;
+      }
+
+      // Check TTL expiration
+      if (this.config.ttl > 0) {
+        var age = Date.now() - entry.timestamp;
+        if (age > this.config.ttl) {
+          this.cache.delete(key);
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /**
+     * Clear all cached entries
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.cache.clear();
+      this.hits = 0;
+      this.misses = 0;
+    }
+
+    /**
+     * Get cache statistics
+     */
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      var 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
+     */
+  }, {
+    key: "updateConfig",
+    value: function updateConfig(config) {
+      this.config = _objectSpread(_objectSpread({}, 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) {
+        var oldestKey = this.cache.keys().next().value;
+        if (oldestKey) {
+          this.cache.delete(oldestKey);
+        }
+      }
+    }
+
+    /**
+     * Get current configuration
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+
+    /**
+     * Remove expired entries (useful for periodic cleanup)
+     */
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      if (this.config.ttl <= 0) {
+        return 0;
+      }
+      var now = Date.now();
+      var removed = 0;
+      var _iterator = _createForOfIteratorHelper(this.cache.entries()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            key = _step$value[0],
+            entry = _step$value[1];
+          if (now - entry.timestamp > this.config.ttl) {
+            this.cache.delete(key);
+            removed++;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return removed;
+    }
+  }]);
+  return PathCache;
+}();
+
+/**
+ * Global path cache instance (singleton)
+ */
+var globalPathCache = null;
+
+/**
+ * Get the global path cache instance
+ */
+export function getGlobalPathCache() {
+  if (!globalPathCache) {
+    globalPathCache = new PathCache();
+  }
+  return globalPathCache;
+}
+
+/**
+ * Reset the global path cache (useful for testing)
+ */
+export function resetGlobalPathCache() {
+  if (globalPathCache) {
+    globalPathCache.clear();
+  }
+  globalPathCache = null;
+}