@rxflow/manhattan 0.0.2-alpha.8 → 0.0.3

package/esm/utils/AdaptiveStepCalculator.js

@@ -0,0 +1,252 @@
+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 _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 _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); }
+/**
+ * AdaptiveStepCalculator - 自适应步长计算器
+ *
+ * 根据场景自动调整网格步长，平衡性能和路径质量
+ * - 高密度区域使用小步长，提高路径精度
+ * - 长距离路径使用大步长，提高计算性能
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 2.3, 2.4
+ */
+
+/**
+ * 自适应步长配置
+ */
+
+/**
+ * 默认自适应步长配置
+ */
+export var DEFAULT_ADAPTIVE_STEP_CONFIG = {
+  enabled: false,
+  minStep: 5,
+  maxStep: 20,
+  densityBased: {
+    enabled: true,
+    threshold: 0.5 // 每10000平方像素0.5个节点
+  },
+  distanceBased: {
+    enabled: true,
+    shortPathThreshold: 200,
+    longPathThreshold: 800
+  }
+};
+
+/**
+ * 自适应步长计算器
+ */
+export var AdaptiveStepCalculator = /*#__PURE__*/function () {
+  function AdaptiveStepCalculator() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, AdaptiveStepCalculator);
+    _defineProperty(this, "config", void 0);
+    this.config = this.mergeConfig(config);
+  }
+
+  /**
+   * 合并配置与默认值
+   */
+  _createClass(AdaptiveStepCalculator, [{
+    key: "mergeConfig",
+    value: function mergeConfig(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;
+      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
+        }
+      };
+    }
+
+    /**
+     * 计算节点密度
+     * @param nodeLookup 节点查找表
+     * @returns 密度值（节点数/10000平方像素）
+     */
+  }, {
+    key: "calculateNodeDensity",
+    value: function calculateNodeDensity(nodeLookup) {
+      if (nodeLookup.size === 0) return 0;
+      var minX = Infinity,
+        minY = Infinity;
+      var maxX = -Infinity,
+        maxY = -Infinity;
+      var _iterator = _createForOfIteratorHelper(nodeLookup.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _node$internals$posit, _node$internals, _ref, _node$measured$width, _node$measured, _ref2, _node$measured$height, _node$measured2;
+          var node = _step.value;
+          var pos = (_node$internals$posit = (_node$internals = node.internals) === null || _node$internals === void 0 ? void 0 : _node$internals.positionAbsolute) !== null && _node$internals$posit !== void 0 ? _node$internals$posit : node.position;
+          var _width = (_ref = (_node$measured$width = (_node$measured = node.measured) === null || _node$measured === void 0 ? void 0 : _node$measured.width) !== null && _node$measured$width !== void 0 ? _node$measured$width : node.width) !== null && _ref !== void 0 ? _ref : 100;
+          var _height = (_ref2 = (_node$measured$height = (_node$measured2 = node.measured) === null || _node$measured2 === void 0 ? void 0 : _node$measured2.height) !== null && _node$measured$height !== void 0 ? _node$measured$height : node.height) !== null && _ref2 !== void 0 ? _ref2 : 50;
+          minX = Math.min(minX, pos.x);
+          minY = Math.min(minY, pos.y);
+          maxX = Math.max(maxX, pos.x + _width);
+          maxY = Math.max(maxY, pos.y + _height);
+        }
+
+        // 计算边界框面积（以10000平方像素为单位）
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var width = maxX - minX;
+      var height = maxY - minY;
+      var area = width * height / 10000;
+      if (area <= 0) return 0;
+      return nodeLookup.size / area;
+    }
+
+    /**
+     * 计算两点之间的曼哈顿距离
+     */
+  }, {
+    key: "calculateDistance",
+    value: function calculateDistance(source, target) {
+      return Math.abs(target.x - source.x) + Math.abs(target.y - source.y);
+    }
+
+    /**
+     * 基于距离计算步长
+     */
+  }, {
+    key: "calculateDistanceBasedStep",
+    value: function calculateDistanceBasedStep(distance) {
+      var _this$config = this.config,
+        minStep = _this$config.minStep,
+        maxStep = _this$config.maxStep,
+        distanceBased = _this$config.distanceBased;
+      if (!distanceBased.enabled) {
+        return minStep;
+      }
+      var shortPathThreshold = distanceBased.shortPathThreshold,
+        longPathThreshold = distanceBased.longPathThreshold;
+      if (distance <= shortPathThreshold) {
+        return minStep;
+      }
+      if (distance >= longPathThreshold) {
+        return maxStep;
+      }
+
+      // 线性插值
+      var ratio = (distance - shortPathThreshold) / (longPathThreshold - shortPathThreshold);
+      return Math.round(minStep + ratio * (maxStep - minStep));
+    }
+
+    /**
+     * 基于密度计算步长
+     */
+  }, {
+    key: "calculateDensityBasedStep",
+    value: function calculateDensityBasedStep(density) {
+      var _this$config2 = this.config,
+        minStep = _this$config2.minStep,
+        maxStep = _this$config2.maxStep,
+        densityBased = _this$config2.densityBased;
+      if (!densityBased.enabled) {
+        return maxStep;
+      }
+
+      // 高密度使用小步长
+      if (density >= densityBased.threshold) {
+        return minStep;
+      }
+
+      // 低密度使用大步长
+      if (density <= densityBased.threshold / 2) {
+        return maxStep;
+      }
+
+      // 线性插值
+      var ratio = (densityBased.threshold - density) / (densityBased.threshold / 2);
+      return Math.round(minStep + ratio * (maxStep - minStep));
+    }
+
+    /**
+     * 计算自适应步长
+     * 综合考虑距离和密度因素
+     */
+  }, {
+    key: "calculateStep",
+    value: function calculateStep(sourceNode, targetNode, nodeLookup) {
+      var _sourceNode$internals, _sourceNode$internals2, _targetNode$internals, _targetNode$internals2, _ref3, _sourceNode$measured$, _sourceNode$measured, _ref4, _sourceNode$measured$2, _sourceNode$measured2, _ref5, _targetNode$measured$, _targetNode$measured, _ref6, _targetNode$measured$2, _targetNode$measured2;
+      if (!this.config.enabled) {
+        return this.config.minStep;
+      }
+
+      // 获取源和目标位置
+      var sourcePos = (_sourceNode$internals = (_sourceNode$internals2 = sourceNode.internals) === null || _sourceNode$internals2 === void 0 ? void 0 : _sourceNode$internals2.positionAbsolute) !== null && _sourceNode$internals !== void 0 ? _sourceNode$internals : sourceNode.position;
+      var targetPos = (_targetNode$internals = (_targetNode$internals2 = targetNode.internals) === null || _targetNode$internals2 === void 0 ? void 0 : _targetNode$internals2.positionAbsolute) !== null && _targetNode$internals !== void 0 ? _targetNode$internals : targetNode.position;
+
+      // 计算节点中心点
+      var sourceWidth = (_ref3 = (_sourceNode$measured$ = (_sourceNode$measured = sourceNode.measured) === null || _sourceNode$measured === void 0 ? void 0 : _sourceNode$measured.width) !== null && _sourceNode$measured$ !== void 0 ? _sourceNode$measured$ : sourceNode.width) !== null && _ref3 !== void 0 ? _ref3 : 100;
+      var sourceHeight = (_ref4 = (_sourceNode$measured$2 = (_sourceNode$measured2 = sourceNode.measured) === null || _sourceNode$measured2 === void 0 ? void 0 : _sourceNode$measured2.height) !== null && _sourceNode$measured$2 !== void 0 ? _sourceNode$measured$2 : sourceNode.height) !== null && _ref4 !== void 0 ? _ref4 : 50;
+      var targetWidth = (_ref5 = (_targetNode$measured$ = (_targetNode$measured = targetNode.measured) === null || _targetNode$measured === void 0 ? void 0 : _targetNode$measured.width) !== null && _targetNode$measured$ !== void 0 ? _targetNode$measured$ : targetNode.width) !== null && _ref5 !== void 0 ? _ref5 : 100;
+      var targetHeight = (_ref6 = (_targetNode$measured$2 = (_targetNode$measured2 = targetNode.measured) === null || _targetNode$measured2 === void 0 ? void 0 : _targetNode$measured2.height) !== null && _targetNode$measured$2 !== void 0 ? _targetNode$measured$2 : targetNode.height) !== null && _ref6 !== void 0 ? _ref6 : 50;
+      var sourceCenter = {
+        x: sourcePos.x + sourceWidth / 2,
+        y: sourcePos.y + sourceHeight / 2
+      };
+      var targetCenter = {
+        x: targetPos.x + targetWidth / 2,
+        y: targetPos.y + targetHeight / 2
+      };
+
+      // 计算距离
+      var distance = this.calculateDistance(sourceCenter, targetCenter);
+
+      // 计算密度
+      var density = this.calculateNodeDensity(nodeLookup);
+
+      // 获取基于距离和密度的步长
+      var distanceStep = this.calculateDistanceBasedStep(distance);
+      var densityStep = this.calculateDensityBasedStep(density);
+
+      // 取两者中较小的值（更保守的选择）
+      var step = Math.min(distanceStep, densityStep);
+
+      // 确保步长在有效范围内
+      return Math.max(this.config.minStep, Math.min(this.config.maxStep, step));
+    }
+
+    /**
+     * 获取当前配置
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+
+    /**
+     * 更新配置
+     */
+  }, {
+    key: "updateConfig",
+    value: function updateConfig(config) {
+      this.config = this.mergeConfig(_objectSpread(_objectSpread({}, this.config), config));
+    }
+  }]);
+  return AdaptiveStepCalculator;
+}();

package/esm/utils/ErrorRecovery.d.ts

@@ -0,0 +1,182 @@
+/**
+ * ErrorRecovery - 错误恢复和降级策略
+ *
+ * 提供路径计算失败时的恢复机制，包括：
+ * - 超时检测和处理
+ * - 降级路径生成
+ * - 错误分类和报告
+ *
+ * Implements: Requirements 4.2, 3.6
+ */
+import { Point, Rectangle } from '../geometry';
+/**
+ * 错误类型枚举
+ */
+export declare enum PathfindingErrorType {
+    /** 超时错误 - 计算时间超过限制 */
+    TIMEOUT = "TIMEOUT",
+    /** 无路径错误 - 无法找到有效路径 */
+    NO_PATH = "NO_PATH",
+    /** 无效输入错误 - 输入参数无效 */
+    INVALID_INPUT = "INVALID_INPUT",
+    /** 障碍物阻塞错误 - 起点或终点被障碍物阻塞 */
+    BLOCKED = "BLOCKED",
+    /** 内部错误 - 算法内部错误 */
+    INTERNAL = "INTERNAL"
+}
+/**
+ * 路径计算错误
+ */
+export declare class PathfindingError extends Error {
+    readonly type: PathfindingErrorType;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(type: PathfindingErrorType, message: string, details?: Record<string, unknown> | undefined);
+}
+/**
+ * 恢复策略类型
+ */
+export declare enum RecoveryStrategy {
+    /** 直线连接 */
+    DIRECT_LINE = "DIRECT_LINE",
+    /** L形路径 */
+    L_SHAPE = "L_SHAPE",
+    /** Z形路径 */
+    Z_SHAPE = "Z_SHAPE",
+    /** 简化曼哈顿路径 */
+    SIMPLE_MANHATTAN = "SIMPLE_MANHATTAN",
+    /** 无恢复 */
+    NONE = "NONE"
+}
+/**
+ * 恢复结果
+ */
+export interface RecoveryResult {
+    /** 是否成功恢复 */
+    success: boolean;
+    /** 恢复后的路径 */
+    path: Point[];
+    /** 使用的恢复策略 */
+    strategy: RecoveryStrategy;
+    /** 原始错误 */
+    originalError?: PathfindingError;
+    /** 恢复耗时（毫秒） */
+    recoveryTime: number;
+}
+/**
+ * 错误恢复配置
+ */
+export interface ErrorRecoveryConfig {
+    /** 是否启用自动恢复 */
+    enabled: boolean;
+    /** 最大恢复尝试次数 */
+    maxAttempts: number;
+    /** 恢复策略优先级 */
+    strategyPriority: RecoveryStrategy[];
+    /** 是否记录恢复日志 */
+    logRecovery: boolean;
+}
+/**
+ * 默认恢复配置
+ */
+export declare const DEFAULT_RECOVERY_CONFIG: ErrorRecoveryConfig;
+/**
+ * 错误恢复类
+ */
+export declare class ErrorRecovery {
+    private config;
+    private recoveryAttempts;
+    constructor(config?: Partial<ErrorRecoveryConfig>);
+    /**
+     * 尝试恢复路径计算
+     */
+    recover(from: Point, to: Point, error: PathfindingError, obstacles?: Rectangle[]): RecoveryResult;
+    /**
+     * 应用恢复策略
+     */
+    private applyStrategy;
+    /**
+     * 直线连接策略
+     */
+    private directLine;
+    /**
+     * L形路径策略
+     */
+    private lShape;
+    /**
+     * Z形路径策略
+     */
+    private zShape;
+    /**
+     * 简化曼哈顿路径策略
+     */
+    private simpleManhattan;
+    /**
+     * 检查路径是否与障碍物相交
+     */
+    private pathIntersectsObstacles;
+    /**
+     * 检查线段是否与矩形相交
+     */
+    private lineIntersectsRect;
+    /**
+     * 检查点是否在矩形内部
+     */
+    private pointInRect;
+    /**
+     * 检查两条线段是否相交
+     */
+    private lineIntersectsLine;
+    /**
+     * 计算叉积方向
+     */
+    private direction;
+    /**
+     * 检查点是否在线段上
+     */
+    private onSegment;
+    /**
+     * 创建超时错误
+     */
+    static createTimeoutError(iterations: number, maxIterations: number): PathfindingError;
+    /**
+     * 创建无路径错误
+     */
+    static createNoPathError(from: Point, to: Point): PathfindingError;
+    /**
+     * 创建无效输入错误
+     */
+    static createInvalidInputError(message: string): PathfindingError;
+    /**
+     * 创建阻塞错误
+     */
+    static createBlockedError(point: Point, type: 'source' | 'target'): PathfindingError;
+    /**
+     * 创建内部错误
+     */
+    static createInternalError(message: string, cause?: Error): PathfindingError;
+    /**
+     * 生成回退路径（静态方法）
+     */
+    static generateFallbackPath(source: Point, target: Point): Point[];
+    /**
+     * 验证并修复配置选项
+     */
+    static validateAndFixOptions<T extends Record<string, unknown>>(options: T, defaults: T): T;
+    /**
+     * 获取恢复尝试次数
+     */
+    getRecoveryAttempts(): number;
+    /**
+     * 重置恢复状态
+     */
+    reset(): void;
+    /**
+     * 更新配置
+     */
+    updateConfig(config: Partial<ErrorRecoveryConfig>): void;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): ErrorRecoveryConfig;
+}
+//# sourceMappingURL=ErrorRecovery.d.ts.map

package/esm/utils/ErrorRecovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorRecovery.d.ts","sourceRoot":"","sources":["../../src/utils/ErrorRecovery.ts"],"names":[],"mappings":"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"}