@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/utils/GlobalGrid.js

@@ -0,0 +1,259 @@
+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); }
+/**
+ * GlobalGrid class for consistent path alignment
+ * Feature: manhattan-optimization
+ *
+ * This class ensures all paths align to a unified global grid,
+ * solving the path overlap problem where paths should share segments.
+ */
+import { Point } from "../geometry";
+
+/**
+ * Global grid configuration
+ */
+
+/**
+ * GlobalGrid class for managing grid alignment
+ *
+ * Key features:
+ * - Uses a fixed global origin (0, 0) for consistent alignment across all paths
+ * - Supports configurable step sizes
+ * - Provides methods for snapping points to grid
+ * - Ensures path segments can properly overlap when they should
+ */
+export var GlobalGrid = /*#__PURE__*/function () {
+  function GlobalGrid(config) {
+    var _config$origin;
+    _classCallCheck(this, GlobalGrid);
+    /** Grid origin point */
+    _defineProperty(this, "origin", void 0);
+    /** Grid step size in X direction */
+    _defineProperty(this, "stepX", void 0);
+    /** Grid step size in Y direction */
+    _defineProperty(this, "stepY", void 0);
+    this.origin = (_config$origin = config.origin) !== null && _config$origin !== void 0 ? _config$origin : new Point(0, 0);
+    this.stepX = config.stepX;
+    this.stepY = config.stepY;
+
+    // Validate step sizes
+    if (this.stepX <= 0 || this.stepY <= 0) {
+      throw new Error('Grid step sizes must be positive');
+    }
+  }
+
+  /**
+   * Create a GlobalGrid with uniform step size
+   */
+  _createClass(GlobalGrid, [{
+    key: "snapValue",
+    value:
+    /**
+     * Snap a single value to the grid
+     */
+    function snapValue(value, step) {
+      var originOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var adjusted = value - originOffset;
+      var snapped = Math.round(adjusted / step) * step;
+      return snapped + originOffset;
+    }
+
+    /**
+     * Snap a point to the global grid
+     */
+  }, {
+    key: "snapToGrid",
+    value: function snapToGrid(point) {
+      return new Point(this.snapValue(point.x, this.stepX, this.origin.x), this.snapValue(point.y, this.stepY, this.origin.y));
+    }
+
+    /**
+     * Snap a point to grid and apply precision rounding
+     */
+  }, {
+    key: "snapToGridWithPrecision",
+    value: function snapToGridWithPrecision(point, precision) {
+      return this.snapToGrid(point).round(precision);
+    }
+
+    /**
+     * Check if a point is on the grid (within tolerance)
+     */
+  }, {
+    key: "isOnGrid",
+    value: function isOnGrid(point) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.001;
+      var snapped = this.snapToGrid(point);
+      return Math.abs(point.x - snapped.x) < tolerance && Math.abs(point.y - snapped.y) < tolerance;
+    }
+
+    /**
+     * Get the nearest grid point in a specific direction
+     */
+  }, {
+    key: "getNearestGridPoint",
+    value: function getNearestGridPoint(point, direction) {
+      var adjustedX = point.x - this.origin.x;
+      var adjustedY = point.y - this.origin.y;
+      var snappedX;
+      var snappedY;
+      switch (direction) {
+        case 'up':
+          snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+          snappedY = Math.floor(adjustedY / this.stepY) * this.stepY;
+          break;
+        case 'down':
+          snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+          snappedY = Math.ceil(adjustedY / this.stepY) * this.stepY;
+          break;
+        case 'left':
+          snappedX = Math.floor(adjustedX / this.stepX) * this.stepX;
+          snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+          break;
+        case 'right':
+          snappedX = Math.ceil(adjustedX / this.stepX) * this.stepX;
+          snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+          break;
+        case 'nearest':
+        default:
+          snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+          snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+          break;
+      }
+      return new Point(snappedX + this.origin.x, snappedY + this.origin.y);
+    }
+
+    /**
+     * Get all grid points within a rectangle
+     */
+  }, {
+    key: "getGridPointsInRect",
+    value: function getGridPointsInRect(minX, minY, maxX, maxY) {
+      var points = [];
+
+      // Snap bounds to grid
+      var startX = this.snapValue(minX, this.stepX, this.origin.x);
+      var startY = this.snapValue(minY, this.stepY, this.origin.y);
+      var endX = this.snapValue(maxX, this.stepX, this.origin.x);
+      var endY = this.snapValue(maxY, this.stepY, this.origin.y);
+      for (var x = startX; x <= endX; x += this.stepX) {
+        for (var y = startY; y <= endY; y += this.stepY) {
+          points.push(new Point(x, y));
+        }
+      }
+      return points;
+    }
+
+    /**
+     * Calculate the grid distance between two points
+     * (number of grid steps, not actual distance)
+     */
+  }, {
+    key: "gridDistance",
+    value: function gridDistance(p1, p2) {
+      var dx = Math.abs(p2.x - p1.x) / this.stepX;
+      var dy = Math.abs(p2.y - p1.y) / this.stepY;
+      return {
+        x: Math.round(dx),
+        y: Math.round(dy),
+        total: Math.round(dx) + Math.round(dy)
+      };
+    }
+
+    /**
+     * Snap an array of points to the grid
+     */
+  }, {
+    key: "snapPathToGrid",
+    value: function snapPathToGrid(points) {
+      var _this = this;
+      return points.map(function (p) {
+        return _this.snapToGrid(p);
+      });
+    }
+
+    /**
+     * Snap path to grid and remove duplicate consecutive points
+     */
+  }, {
+    key: "snapAndSimplifyPath",
+    value: function snapAndSimplifyPath(points) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.001;
+      if (points.length === 0) return [];
+      var snapped = this.snapPathToGrid(points);
+      var simplified = [snapped[0]];
+      for (var i = 1; i < snapped.length; i++) {
+        var prev = simplified[simplified.length - 1];
+        var curr = snapped[i];
+
+        // Skip if same as previous point
+        if (Math.abs(prev.x - curr.x) < tolerance && Math.abs(prev.y - curr.y) < tolerance) {
+          continue;
+        }
+        simplified.push(curr);
+      }
+      return simplified;
+    }
+
+    /**
+     * Get grid offset for a direction
+     */
+  }, {
+    key: "getDirectionOffset",
+    value: function getDirectionOffset(direction) {
+      switch (direction) {
+        case 'up':
+          return new Point(0, -this.stepY);
+        case 'down':
+          return new Point(0, this.stepY);
+        case 'left':
+          return new Point(-this.stepX, 0);
+        case 'right':
+          return new Point(this.stepX, 0);
+      }
+    }
+
+    /**
+     * Clone this grid with optional overrides
+     */
+  }, {
+    key: "clone",
+    value: function clone(overrides) {
+      var _overrides$stepX, _overrides$stepY, _overrides$origin;
+      return new GlobalGrid({
+        stepX: (_overrides$stepX = overrides === null || overrides === void 0 ? void 0 : overrides.stepX) !== null && _overrides$stepX !== void 0 ? _overrides$stepX : this.stepX,
+        stepY: (_overrides$stepY = overrides === null || overrides === void 0 ? void 0 : overrides.stepY) !== null && _overrides$stepY !== void 0 ? _overrides$stepY : this.stepY,
+        origin: (_overrides$origin = overrides === null || overrides === void 0 ? void 0 : overrides.origin) !== null && _overrides$origin !== void 0 ? _overrides$origin : this.origin.clone()
+      });
+    }
+
+    /**
+     * Create a string representation for debugging
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "GlobalGrid(origin: ".concat(this.origin.toString(), ", stepX: ").concat(this.stepX, ", stepY: ").concat(this.stepY, ")");
+    }
+  }], [{
+    key: "uniform",
+    value: function uniform(step, origin) {
+      return new GlobalGrid({
+        stepX: step,
+        stepY: step,
+        origin: origin
+      });
+    }
+  }]);
+  return GlobalGrid;
+}();
+
+/**
+ * Default global grid instance with step size 10
+ */
+export var defaultGlobalGrid = GlobalGrid.uniform(10);

package/esm/utils/PerformanceMonitor.js

@@ -0,0 +1,360 @@
+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); }
+/**
+ * PerformanceMonitor - 性能监控器
+ *
+ * 提供路径计算的性能监控和调试信息
+ * - 计时功能
+ * - 指标收集（迭代次数、查询次数等）
+ * - 指标导出和日志
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 3.5, 5.5
+ */
+
+/**
+ * 性能指标接口
+ */
+
+/**
+ * 日志级别
+ */
+
+/**
+ * 性能监控配置
+ */
+
+/**
+ * 默认性能监控配置
+ */
+export var DEFAULT_PERFORMANCE_MONITOR_CONFIG = {
+  enableLogging: false,
+  enableMetrics: false,
+  logLevel: 'info'
+};
+
+/**
+ * 创建空的性能指标
+ */
+function createEmptyMetrics() {
+  return {
+    pathfindingTime: 0,
+    iterations: 0,
+    obstacleQueries: 0,
+    cacheHitRate: 0,
+    pathPointCount: 0
+  };
+}
+
+/**
+ * 性能监控器
+ */
+export var PerformanceMonitor = /*#__PURE__*/function () {
+  function PerformanceMonitor() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, PerformanceMonitor);
+    _defineProperty(this, "config", void 0);
+    _defineProperty(this, "metrics", new Map());
+    _defineProperty(this, "activeTimers", new Map());
+    _defineProperty(this, "globalCounters", {
+      totalCacheHits: 0,
+      totalCacheQueries: 0
+    });
+    this.config = _objectSpread(_objectSpread({}, DEFAULT_PERFORMANCE_MONITOR_CONFIG), config);
+  }
+
+  /**
+   * 开始监控
+   */
+  _createClass(PerformanceMonitor, [{
+    key: "startMonitoring",
+    value: function startMonitoring(label) {
+      if (!this.config.enableMetrics) return;
+      var startTime = performance.now();
+      this.activeTimers.set(label, startTime);
+
+      // 初始化指标
+      this.metrics.set(label, _objectSpread(_objectSpread({}, createEmptyMetrics()), {}, {
+        startTime: startTime
+      }));
+      this.log('debug', "[PerformanceMonitor] Started monitoring: ".concat(label));
+    }
+
+    /**
+     * 结束监控并记录
+     */
+  }, {
+    key: "endMonitoring",
+    value: function endMonitoring(label) {
+      var endTime = performance.now();
+      var startTime = this.activeTimers.get(label);
+      if (!startTime) {
+        this.log('warn', "[PerformanceMonitor] No active timer for: ".concat(label));
+        return createEmptyMetrics();
+      }
+      var metrics = this.metrics.get(label) || createEmptyMetrics();
+      metrics.pathfindingTime = endTime - startTime;
+      metrics.endTime = endTime;
+      metrics.cacheHitRate = this.calculateCacheHitRate();
+      this.metrics.set(label, metrics);
+      this.activeTimers.delete(label);
+      this.log('info', "[PerformanceMonitor] ".concat(label, ": ").concat(metrics.pathfindingTime.toFixed(2), "ms, ").concat(metrics.iterations, " iterations, ").concat(metrics.pathPointCount, " points"));
+      return metrics;
+    }
+
+    /**
+     * 记录迭代次数
+     */
+  }, {
+    key: "recordIterations",
+    value: function recordIterations(label, count) {
+      if (!this.config.enableMetrics) return;
+      var metrics = this.metrics.get(label);
+      if (metrics) {
+        metrics.iterations = count;
+      }
+    }
+
+    /**
+     * 增加障碍物查询计数
+     */
+  }, {
+    key: "incrementObstacleQueries",
+    value: function incrementObstacleQueries(label) {
+      var count = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      if (!this.config.enableMetrics) return;
+      var metrics = this.metrics.get(label);
+      if (metrics) {
+        metrics.obstacleQueries += count;
+      }
+    }
+
+    /**
+     * 记录路径点数量
+     */
+  }, {
+    key: "recordPathPointCount",
+    value: function recordPathPointCount(label, count) {
+      if (!this.config.enableMetrics) return;
+      var metrics = this.metrics.get(label);
+      if (metrics) {
+        metrics.pathPointCount = count;
+      }
+    }
+
+    /**
+     * 记录缓存命中
+     */
+  }, {
+    key: "recordCacheHit",
+    value: function recordCacheHit() {
+      if (!this.config.enableMetrics) return;
+      this.globalCounters.totalCacheHits++;
+      this.globalCounters.totalCacheQueries++;
+    }
+
+    /**
+     * 记录缓存未命中
+     */
+  }, {
+    key: "recordCacheMiss",
+    value: function recordCacheMiss() {
+      if (!this.config.enableMetrics) return;
+      this.globalCounters.totalCacheQueries++;
+    }
+
+    /**
+     * 计算缓存命中率
+     */
+  }, {
+    key: "calculateCacheHitRate",
+    value: function calculateCacheHitRate() {
+      if (this.globalCounters.totalCacheQueries === 0) return 0;
+      return this.globalCounters.totalCacheHits / this.globalCounters.totalCacheQueries;
+    }
+
+    /**
+     * 获取指定标签的指标
+     */
+  }, {
+    key: "getMetrics",
+    value: function getMetrics(label) {
+      return this.metrics.get(label);
+    }
+
+    /**
+     * 获取所有指标
+     */
+  }, {
+    key: "getAllMetrics",
+    value: function getAllMetrics() {
+      return new Map(this.metrics);
+    }
+
+    /**
+     * 清除指标
+     */
+  }, {
+    key: "clearMetrics",
+    value: function clearMetrics() {
+      this.metrics.clear();
+      this.activeTimers.clear();
+      this.globalCounters = {
+        totalCacheHits: 0,
+        totalCacheQueries: 0
+      };
+    }
+
+    /**
+     * 导出为日志字符串
+     */
+  }, {
+    key: "exportToLog",
+    value: function exportToLog() {
+      var lines = ['=== Performance Metrics ==='];
+      var _iterator = _createForOfIteratorHelper(this.metrics),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            label = _step$value[0],
+            metrics = _step$value[1];
+          lines.push("\n[".concat(label, "]"));
+          lines.push("  Time: ".concat(metrics.pathfindingTime.toFixed(2), "ms"));
+          lines.push("  Iterations: ".concat(metrics.iterations));
+          lines.push("  Obstacle Queries: ".concat(metrics.obstacleQueries));
+          lines.push("  Path Points: ".concat(metrics.pathPointCount));
+          lines.push("  Cache Hit Rate: ".concat((metrics.cacheHitRate * 100).toFixed(1), "%"));
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      lines.push('\n=== Global Stats ===');
+      lines.push("  Total Cache Queries: ".concat(this.globalCounters.totalCacheQueries));
+      lines.push("  Total Cache Hits: ".concat(this.globalCounters.totalCacheHits));
+      lines.push("  Overall Cache Hit Rate: ".concat((this.calculateCacheHitRate() * 100).toFixed(1), "%"));
+      return lines.join('\n');
+    }
+
+    /**
+     * 获取摘要统计
+     */
+  }, {
+    key: "getSummary",
+    value: function getSummary() {
+      var totalTime = 0;
+      var maxTime = 0;
+      var minTime = Infinity;
+      var totalIterations = 0;
+      var _iterator2 = _createForOfIteratorHelper(this.metrics.values()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var metrics = _step2.value;
+          totalTime += metrics.pathfindingTime;
+          maxTime = Math.max(maxTime, metrics.pathfindingTime);
+          minTime = Math.min(minTime, metrics.pathfindingTime);
+          totalIterations += metrics.iterations;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var count = this.metrics.size;
+      return {
+        totalTime: totalTime,
+        avgTime: count > 0 ? totalTime / count : 0,
+        maxTime: count > 0 ? maxTime : 0,
+        minTime: count > 0 && minTime !== Infinity ? minTime : 0,
+        totalIterations: totalIterations,
+        cacheHitRate: this.calculateCacheHitRate()
+      };
+    }
+
+    /**
+     * 内部日志方法
+     */
+  }, {
+    key: "log",
+    value: function log(level, message) {
+      if (!this.config.enableLogging) return;
+      var levels = ['error', 'warn', 'info', 'debug'];
+      var configLevelIndex = levels.indexOf(this.config.logLevel);
+      var messageLevelIndex = levels.indexOf(level);
+      if (messageLevelIndex <= configLevelIndex) {
+        switch (level) {
+          case 'error':
+            console.error(message);
+            break;
+          case 'warn':
+            console.warn(message);
+            break;
+          case 'info':
+            console.info(message);
+            break;
+          case 'debug':
+            console.debug(message);
+            break;
+        }
+      }
+    }
+
+    /**
+     * 更新配置
+     */
+  }, {
+    key: "updateConfig",
+    value: function updateConfig(config) {
+      this.config = _objectSpread(_objectSpread({}, this.config), config);
+    }
+
+    /**
+     * 获取当前配置
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+  }]);
+  return PerformanceMonitor;
+}();
+
+/**
+ * 全局性能监控器实例（可选使用）
+ */
+var globalMonitor = null;
+
+/**
+ * 获取全局性能监控器
+ */
+export function getGlobalPerformanceMonitor() {
+  if (!globalMonitor) {
+    globalMonitor = new PerformanceMonitor();
+  }
+  return globalMonitor;
+}
+
+/**
+ * 重置全局性能监控器
+ */
+export function resetGlobalPerformanceMonitor() {
+  globalMonitor = null;
+}

package/esm/utils/getAnchorPoints.js

@@ -36,16 +36,13 @@ export function getAnchorPoints(anchor, position, extensionDistance, step, obsta
     console.warn("[getAnchorPoints] Invalid position: ".concat(position));
     return [anchor];
   }
-  console.log("[getAnchorPoints] Finding points for position '".concat(position, "' from (").concat(anchor.x, ", ").concat(anchor.y, ")"));
 
   // 1. First try extensionDistance
   var extensionPoint = new Point(anchor.x + dir.dx * extensionDistance, anchor.y + dir.dy * extensionDistance);
   if (obstacleMap.isAccessible(extensionPoint)) {
-    console.log("[getAnchorPoints] Extension point (".concat(extensionPoint.x, ", ").concat(extensionPoint.y, ") is accessible"));
     points.push(extensionPoint);
     return points;
   }
-  console.log("[getAnchorPoints] Extension point (".concat(extensionPoint.x, ", ").concat(extensionPoint.y, ") is blocked, trying binary search"));
 
   // 2. If extensionDistance point is blocked, use binary search with step
   // Try: step -> step/2 -> step/4 -> ... -> 1px
@@ -53,7 +50,6 @@ export function getAnchorPoints(anchor, position, extensionDistance, step, obsta
   while (distance >= 1) {
     var testPoint = new Point(anchor.x + dir.dx * distance, anchor.y + dir.dy * distance);
     if (obstacleMap.isAccessible(testPoint)) {
-      console.log("[getAnchorPoints] Found accessible point at distance ".concat(distance, "px: (").concat(testPoint.x, ", ").concat(testPoint.y, ")"));
       points.push(testPoint);
       return points;
     }