@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/esm/utils/ErrorRecovery.js

@@ -0,0 +1,499 @@
+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 _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 _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 _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 _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); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/**
+ * ErrorRecovery - 错误恢复和降级策略
+ *
+ * 提供路径计算失败时的恢复机制，包括：
+ * - 超时检测和处理
+ * - 降级路径生成
+ * - 错误分类和报告
+ *
+ * Implements: Requirements 4.2, 3.6
+ */
+
+import { Point } from "../geometry";
+
+/**
+ * 错误类型枚举
+ */
+export var PathfindingErrorType = /*#__PURE__*/function (PathfindingErrorType) {
+  PathfindingErrorType["TIMEOUT"] = "TIMEOUT";
+  PathfindingErrorType["NO_PATH"] = "NO_PATH";
+  PathfindingErrorType["INVALID_INPUT"] = "INVALID_INPUT";
+  PathfindingErrorType["BLOCKED"] = "BLOCKED";
+  PathfindingErrorType["INTERNAL"] = "INTERNAL";
+  return PathfindingErrorType;
+}({});
+
+/**
+ * 路径计算错误
+ */
+export var PathfindingError = /*#__PURE__*/function (_Error) {
+  _inherits(PathfindingError, _Error);
+  var _super = _createSuper(PathfindingError);
+  function PathfindingError(type, message, details) {
+    var _this;
+    _classCallCheck(this, PathfindingError);
+    _this = _super.call(this, message);
+    _this.type = type;
+    _this.details = details;
+    _this.name = 'PathfindingError';
+    return _this;
+  }
+  return _createClass(PathfindingError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+/**
+ * 恢复策略类型
+ */
+export var RecoveryStrategy = /*#__PURE__*/function (RecoveryStrategy) {
+  RecoveryStrategy["DIRECT_LINE"] = "DIRECT_LINE";
+  RecoveryStrategy["L_SHAPE"] = "L_SHAPE";
+  RecoveryStrategy["Z_SHAPE"] = "Z_SHAPE";
+  RecoveryStrategy["SIMPLE_MANHATTAN"] = "SIMPLE_MANHATTAN";
+  RecoveryStrategy["NONE"] = "NONE";
+  return RecoveryStrategy;
+}({});
+
+/**
+ * 恢复结果
+ */
+
+/**
+ * 错误恢复配置
+ */
+
+/**
+ * 默认恢复配置
+ */
+export var DEFAULT_RECOVERY_CONFIG = {
+  enabled: true,
+  maxAttempts: 3,
+  strategyPriority: [RecoveryStrategy.SIMPLE_MANHATTAN, RecoveryStrategy.L_SHAPE, RecoveryStrategy.Z_SHAPE, RecoveryStrategy.DIRECT_LINE],
+  logRecovery: false
+};
+
+/**
+ * 错误恢复类
+ */
+export var ErrorRecovery = /*#__PURE__*/function () {
+  function ErrorRecovery() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, ErrorRecovery);
+    _defineProperty(this, "config", void 0);
+    _defineProperty(this, "recoveryAttempts", 0);
+    this.config = _objectSpread(_objectSpread({}, DEFAULT_RECOVERY_CONFIG), config);
+  }
+
+  /**
+   * 尝试恢复路径计算
+   */
+  _createClass(ErrorRecovery, [{
+    key: "recover",
+    value: function recover(from, to, error, obstacles) {
+      var startTime = performance.now();
+      if (!this.config.enabled) {
+        return {
+          success: false,
+          path: [],
+          strategy: RecoveryStrategy.NONE,
+          originalError: error,
+          recoveryTime: performance.now() - startTime
+        };
+      }
+      this.recoveryAttempts = 0;
+      var _iterator = _createForOfIteratorHelper(this.config.strategyPriority),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var strategy = _step.value;
+          if (this.recoveryAttempts >= this.config.maxAttempts) {
+            break;
+          }
+          this.recoveryAttempts++;
+          var path = this.applyStrategy(strategy, from, to, obstacles);
+          if (path.length > 0) {
+            if (this.config.logRecovery) {
+              console.info("[ErrorRecovery] Recovered using ".concat(strategy, " after ").concat(this.recoveryAttempts, " attempts"));
+            }
+            return {
+              success: true,
+              path: path,
+              strategy: strategy,
+              originalError: error,
+              recoveryTime: performance.now() - startTime
+            };
+          }
+        }
+
+        // 所有策略都失败，返回直线作为最后手段
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return {
+        success: true,
+        path: [from, to],
+        strategy: RecoveryStrategy.DIRECT_LINE,
+        originalError: error,
+        recoveryTime: performance.now() - startTime
+      };
+    }
+
+    /**
+     * 应用恢复策略
+     */
+  }, {
+    key: "applyStrategy",
+    value: function applyStrategy(strategy, from, to, obstacles) {
+      switch (strategy) {
+        case RecoveryStrategy.DIRECT_LINE:
+          return this.directLine(from, to);
+        case RecoveryStrategy.L_SHAPE:
+          return this.lShape(from, to, obstacles);
+        case RecoveryStrategy.Z_SHAPE:
+          return this.zShape(from, to, obstacles);
+        case RecoveryStrategy.SIMPLE_MANHATTAN:
+          return this.simpleManhattan(from, to, obstacles);
+        default:
+          return [];
+      }
+    }
+
+    /**
+     * 直线连接策略
+     */
+  }, {
+    key: "directLine",
+    value: function directLine(from, to) {
+      return [from, to];
+    }
+
+    /**
+     * L形路径策略
+     */
+  }, {
+    key: "lShape",
+    value: function lShape(from, to, obstacles) {
+      // 尝试先水平后垂直
+      var corner1 = new Point(to.x, from.y);
+      var path1 = [from, corner1, to];
+      if (!obstacles || !this.pathIntersectsObstacles(path1, obstacles)) {
+        return path1;
+      }
+
+      // 尝试先垂直后水平
+      var corner2 = new Point(from.x, to.y);
+      var path2 = [from, corner2, to];
+      if (!obstacles || !this.pathIntersectsObstacles(path2, obstacles)) {
+        return path2;
+      }
+      return [];
+    }
+
+    /**
+     * Z形路径策略
+     */
+  }, {
+    key: "zShape",
+    value: function zShape(from, to, obstacles) {
+      var midX = (from.x + to.x) / 2;
+      var midY = (from.y + to.y) / 2;
+
+      // 尝试水平-垂直-水平 Z形
+      var path1 = [from, new Point(midX, from.y), new Point(midX, to.y), to];
+      if (!obstacles || !this.pathIntersectsObstacles(path1, obstacles)) {
+        return path1;
+      }
+
+      // 尝试垂直-水平-垂直 Z形
+      var path2 = [from, new Point(from.x, midY), new Point(to.x, midY), to];
+      if (!obstacles || !this.pathIntersectsObstacles(path2, obstacles)) {
+        return path2;
+      }
+      return [];
+    }
+
+    /**
+     * 简化曼哈顿路径策略
+     */
+  }, {
+    key: "simpleManhattan",
+    value: function simpleManhattan(from, to, obstacles) {
+      var offsets = [0.25, 0.5, 0.75, 0.1, 0.9];
+      for (var _i = 0, _offsets = offsets; _i < _offsets.length; _i++) {
+        var offset = _offsets[_i];
+        // 水平方向偏移
+        var midX = from.x + (to.x - from.x) * offset;
+        var path1 = [from, new Point(midX, from.y), new Point(midX, to.y), to];
+        if (!obstacles || !this.pathIntersectsObstacles(path1, obstacles)) {
+          return path1;
+        }
+
+        // 垂直方向偏移
+        var midY = from.y + (to.y - from.y) * offset;
+        var path2 = [from, new Point(from.x, midY), new Point(to.x, midY), to];
+        if (!obstacles || !this.pathIntersectsObstacles(path2, obstacles)) {
+          return path2;
+        }
+      }
+      return [];
+    }
+
+    /**
+     * 检查路径是否与障碍物相交
+     */
+  }, {
+    key: "pathIntersectsObstacles",
+    value: function pathIntersectsObstacles(path, obstacles) {
+      for (var i = 0; i < path.length - 1; i++) {
+        var p1 = path[i];
+        var p2 = path[i + 1];
+        var _iterator2 = _createForOfIteratorHelper(obstacles),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var obstacle = _step2.value;
+            if (this.lineIntersectsRect(p1, p2, obstacle)) {
+              return true;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+      return false;
+    }
+
+    /**
+     * 检查线段是否与矩形相交
+     */
+  }, {
+    key: "lineIntersectsRect",
+    value: function lineIntersectsRect(p1, p2, rect) {
+      var minX = rect.x;
+      var maxX = rect.x + rect.width;
+      var minY = rect.y;
+      var maxY = rect.y + rect.height;
+
+      // 检查线段是否完全在矩形外部
+      if (p1.x < minX && p2.x < minX || p1.x > maxX && p2.x > maxX || p1.y < minY && p2.y < minY || p1.y > maxY && p2.y > maxY) {
+        return false;
+      }
+
+      // 检查线段端点是否在矩形内部
+      if (this.pointInRect(p1, rect) || this.pointInRect(p2, rect)) {
+        return true;
+      }
+
+      // 检查线段是否与矩形的四条边相交
+      return this.lineIntersectsLine(p1, p2, new Point(minX, minY), new Point(maxX, minY)) || this.lineIntersectsLine(p1, p2, new Point(maxX, minY), new Point(maxX, maxY)) || this.lineIntersectsLine(p1, p2, new Point(maxX, maxY), new Point(minX, maxY)) || this.lineIntersectsLine(p1, p2, new Point(minX, maxY), new Point(minX, minY));
+    }
+
+    /**
+     * 检查点是否在矩形内部
+     */
+  }, {
+    key: "pointInRect",
+    value: function pointInRect(p, rect) {
+      return p.x > rect.x && p.x < rect.x + rect.width && p.y > rect.y && p.y < rect.y + rect.height;
+    }
+
+    /**
+     * 检查两条线段是否相交
+     */
+  }, {
+    key: "lineIntersectsLine",
+    value: function lineIntersectsLine(p1, p2, p3, p4) {
+      var d1 = this.direction(p3, p4, p1);
+      var d2 = this.direction(p3, p4, p2);
+      var d3 = this.direction(p1, p2, p3);
+      var d4 = this.direction(p1, p2, p4);
+      if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+        return true;
+      }
+      if (d1 === 0 && this.onSegment(p3, p4, p1)) return true;
+      if (d2 === 0 && this.onSegment(p3, p4, p2)) return true;
+      if (d3 === 0 && this.onSegment(p1, p2, p3)) return true;
+      if (d4 === 0 && this.onSegment(p1, p2, p4)) return true;
+      return false;
+    }
+
+    /**
+     * 计算叉积方向
+     */
+  }, {
+    key: "direction",
+    value: function direction(p1, p2, p3) {
+      return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+    }
+
+    /**
+     * 检查点是否在线段上
+     */
+  }, {
+    key: "onSegment",
+    value: function onSegment(p1, p2, p) {
+      return p.x >= Math.min(p1.x, p2.x) && p.x <= Math.max(p1.x, p2.x) && p.y >= Math.min(p1.y, p2.y) && p.y <= Math.max(p1.y, p2.y);
+    }
+
+    /**
+     * 创建超时错误
+     */
+  }, {
+    key: "getRecoveryAttempts",
+    value:
+    /**
+     * 获取恢复尝试次数
+     */
+    function getRecoveryAttempts() {
+      return this.recoveryAttempts;
+    }
+
+    /**
+     * 重置恢复状态
+     */
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.recoveryAttempts = 0;
+    }
+
+    /**
+     * 更新配置
+     */
+  }, {
+    key: "updateConfig",
+    value: function updateConfig(config) {
+      this.config = _objectSpread(_objectSpread({}, this.config), config);
+    }
+
+    /**
+     * 获取当前配置
+     */
+  }, {
+    key: "getConfig",
+    value: function getConfig() {
+      return _objectSpread({}, this.config);
+    }
+  }], [{
+    key: "createTimeoutError",
+    value: function createTimeoutError(iterations, maxIterations) {
+      return new PathfindingError(PathfindingErrorType.TIMEOUT, "Pathfinding timeout: exceeded ".concat(maxIterations, " iterations"), {
+        iterations: iterations,
+        maxIterations: maxIterations
+      });
+    }
+
+    /**
+     * 创建无路径错误
+     */
+  }, {
+    key: "createNoPathError",
+    value: function createNoPathError(from, to) {
+      return new PathfindingError(PathfindingErrorType.NO_PATH, "No path found from (".concat(from.x, ", ").concat(from.y, ") to (").concat(to.x, ", ").concat(to.y, ")"), {
+        from: {
+          x: from.x,
+          y: from.y
+        },
+        to: {
+          x: to.x,
+          y: to.y
+        }
+      });
+    }
+
+    /**
+     * 创建无效输入错误
+     */
+  }, {
+    key: "createInvalidInputError",
+    value: function createInvalidInputError(message) {
+      return new PathfindingError(PathfindingErrorType.INVALID_INPUT, message);
+    }
+
+    /**
+     * 创建阻塞错误
+     */
+  }, {
+    key: "createBlockedError",
+    value: function createBlockedError(point, type) {
+      return new PathfindingError(PathfindingErrorType.BLOCKED, "".concat(type === 'source' ? 'Source' : 'Target', " point (").concat(point.x, ", ").concat(point.y, ") is blocked"), {
+        point: {
+          x: point.x,
+          y: point.y
+        },
+        type: type
+      });
+    }
+
+    /**
+     * 创建内部错误
+     */
+  }, {
+    key: "createInternalError",
+    value: function createInternalError(message, cause) {
+      return new PathfindingError(PathfindingErrorType.INTERNAL, message, {
+        cause: cause === null || cause === void 0 ? void 0 : cause.message
+      });
+    }
+
+    /**
+     * 生成回退路径（静态方法）
+     */
+  }, {
+    key: "generateFallbackPath",
+    value: function generateFallbackPath(source, target) {
+      var midX = (source.x + target.x) / 2;
+      return [source, new Point(midX, source.y), new Point(midX, target.y), target];
+    }
+
+    /**
+     * 验证并修复配置选项
+     */
+  }, {
+    key: "validateAndFixOptions",
+    value: function validateAndFixOptions(options, defaults) {
+      var fixed = _objectSpread({}, options);
+      for (var _i2 = 0, _Object$keys = Object.keys(defaults); _i2 < _Object$keys.length; _i2++) {
+        var key = _Object$keys[_i2];
+        var value = fixed[key];
+        var defaultValue = defaults[key];
+        if (value === undefined || value === null) {
+          ;
+          fixed[key] = defaultValue;
+        } else if (typeof defaultValue === 'number' && typeof value === 'number') {
+          if (value <= 0 && defaultValue > 0) {
+            console.warn("Invalid ".concat(key, " value (").concat(value, "), using default (").concat(defaultValue, ")"));
+            fixed[key] = defaultValue;
+          }
+        }
+      }
+      return fixed;
+    }
+  }]);
+  return ErrorRecovery;
+}();