@rxflow/manhattan 0.0.2-alpha.8 → 0.0.3

package/cjs/svg/pathConverter.js

@@ -3,8 +3,47 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.countCorners = countCorners;
+exports.hasRoundedCorners = hasRoundedCorners;
 exports.pointsToPath = pointsToPath;
+exports.pointsToPathCubic = pointsToPathCubic;
 exports.snapPathToGrid = snapPathToGrid;
+/**
+ * Check if three points form a corner (direction change)
+ */
+function isCorner(prev, current, next) {
+  const dx1 = current.x - prev.x;
+  const dy1 = current.y - prev.y;
+  const dx2 = next.x - current.x;
+  const dy2 = next.y - current.y;
+
+  // Check if direction changes (not collinear)
+  // For Manhattan paths, this means one segment is horizontal and the other is vertical
+  const isHorizontal1 = Math.abs(dy1) < 0.001;
+  const isVertical1 = Math.abs(dx1) < 0.001;
+  const isHorizontal2 = Math.abs(dy2) < 0.001;
+  const isVertical2 = Math.abs(dx2) < 0.001;
+
+  // Corner exists if one segment is horizontal and the other is vertical
+  return isHorizontal1 && isVertical2 || isVertical1 && isHorizontal2;
+}
+
+/**
+ * Calculate optimal border radius for a corner
+ * Ensures the radius doesn't exceed half the length of adjacent segments
+ */
+function calculateOptimalRadius(prev, current, next, maxRadius) {
+  const dx1 = current.x - prev.x;
+  const dy1 = current.y - prev.y;
+  const dx2 = next.x - current.x;
+  const dy2 = next.y - current.y;
+  const dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+  const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+
+  // Use the smaller of maxRadius or half the segment length
+  return Math.min(maxRadius, dist1 / 2, dist2 / 2);
+}
+
 /**
  * Convert array of points to SVG path string
  */
@@ -36,6 +75,13 @@ function pointsToPath(points, precision, borderRadius = 0) {
     const current = points[i];
     const next = points[i + 1];
 
+    // Check if this is actually a corner
+    if (!isCorner(prev, current, next)) {
+      // Not a corner, just draw a line to current point
+      path += ` L ${roundCoord(current.x)} ${roundCoord(current.y)}`;
+      continue;
+    }
+
     // Calculate direction vectors
     const dx1 = current.x - prev.x;
     const dy1 = current.y - prev.y;
@@ -47,7 +93,13 @@ function pointsToPath(points, precision, borderRadius = 0) {
     const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
 
     // Use the smaller of borderRadius or half the segment length
-    const radius = Math.min(borderRadius, dist1 / 2, dist2 / 2);
+    const radius = calculateOptimalRadius(prev, current, next, borderRadius);
+
+    // Skip if radius is too small
+    if (radius < 0.5) {
+      path += ` L ${roundCoord(current.x)} ${roundCoord(current.y)}`;
+      continue;
+    }
 
     // Normalize direction vectors
     const ndx1 = dx1 / dist1;
@@ -81,6 +133,103 @@ function pointsToPath(points, precision, borderRadius = 0) {
   return path;
 }
 
+/**
+ * Convert array of points to SVG path string with cubic bezier curves
+ * Provides smoother corners than quadratic bezier
+ */
+function pointsToPathCubic(points, precision, borderRadius = 0) {
+  if (points.length === 0) {
+    return '';
+  }
+  const factor = Math.pow(10, precision);
+  const roundCoord = value => Math.round(value * factor) / factor;
+
+  // If no border radius or only 2 points, use simple line path
+  if (borderRadius === 0 || points.length <= 2) {
+    const firstPoint = points[0];
+    let path = `M ${roundCoord(firstPoint.x)} ${roundCoord(firstPoint.y)}`;
+    for (let i = 1; i < points.length; i++) {
+      const point = points[i];
+      path += ` L ${roundCoord(point.x)} ${roundCoord(point.y)}`;
+    }
+    return path;
+  }
+
+  // Start with M (moveTo) command for first point
+  const firstPoint = points[0];
+  let path = `M ${roundCoord(firstPoint.x)} ${roundCoord(firstPoint.y)}`;
+
+  // Process each segment with rounded corners using cubic bezier
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const current = points[i];
+    const next = points[i + 1];
+
+    // Check if this is actually a corner
+    if (!isCorner(prev, current, next)) {
+      path += ` L ${roundCoord(current.x)} ${roundCoord(current.y)}`;
+      continue;
+    }
+
+    // Calculate direction vectors
+    const dx1 = current.x - prev.x;
+    const dy1 = current.y - prev.y;
+    const dx2 = next.x - current.x;
+    const dy2 = next.y - current.y;
+
+    // Calculate distances
+    const dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+
+    // Use the smaller of borderRadius or half the segment length
+    const radius = calculateOptimalRadius(prev, current, next, borderRadius);
+
+    // Skip if radius is too small
+    if (radius < 0.5) {
+      path += ` L ${roundCoord(current.x)} ${roundCoord(current.y)}`;
+      continue;
+    }
+
+    // Normalize direction vectors
+    const ndx1 = dx1 / dist1;
+    const ndy1 = dy1 / dist1;
+    const ndx2 = dx2 / dist2;
+    const ndy2 = dy2 / dist2;
+
+    // Calculate the point before the corner
+    const beforeCorner = {
+      x: current.x - ndx1 * radius,
+      y: current.y - ndy1 * radius
+    };
+
+    // Calculate the point after the corner
+    const afterCorner = {
+      x: current.x + ndx2 * radius,
+      y: current.y + ndy2 * radius
+    };
+
+    // Draw line to the point before corner
+    path += ` L ${roundCoord(beforeCorner.x)} ${roundCoord(beforeCorner.y)}`;
+
+    // Draw cubic bezier curve for smoother rounded corner
+    // Control points are positioned to create a smooth arc
+    const cp1 = {
+      x: beforeCorner.x + ndx1 * radius * 0.55,
+      y: beforeCorner.y + ndy1 * radius * 0.55
+    };
+    const cp2 = {
+      x: afterCorner.x - ndx2 * radius * 0.55,
+      y: afterCorner.y - ndy2 * radius * 0.55
+    };
+    path += ` C ${roundCoord(cp1.x)} ${roundCoord(cp1.y)} ${roundCoord(cp2.x)} ${roundCoord(cp2.y)} ${roundCoord(afterCorner.x)} ${roundCoord(afterCorner.y)}`;
+  }
+
+  // Draw line to the last point
+  const lastPoint = points[points.length - 1];
+  path += ` L ${roundCoord(lastPoint.x)} ${roundCoord(lastPoint.y)}`;
+  return path;
+}
+
 /**
  * Snap path to grid by aligning consecutive points
  */
@@ -113,4 +262,24 @@ function snapPathToGrid(points, gridSize) {
     }
   }
   return snappedPoints;
+}
+
+/**
+ * Check if an SVG path contains rounded corners (Q or C commands)
+ */
+function hasRoundedCorners(path) {
+  return /[QC]\s/.test(path);
+}
+
+/**
+ * Count the number of corners in a path
+ */
+function countCorners(points) {
+  let corners = 0;
+  for (let i = 1; i < points.length - 1; i++) {
+    if (isCorner(points[i - 1], points[i], points[i + 1])) {
+      corners++;
+    }
+  }
+  return corners;
 }

package/cjs/utils/AdaptiveStepCalculator.d.ts

@@ -0,0 +1,90 @@
+/**
+ * AdaptiveStepCalculator - 自适应步长计算器
+ *
+ * 根据场景自动调整网格步长，平衡性能和路径质量
+ * - 高密度区域使用小步长，提高路径精度
+ * - 长距离路径使用大步长，提高计算性能
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 2.3, 2.4
+ */
+import type { InternalNode, NodeLookup } from '../options/types';
+import { Point } from '../geometry';
+/**
+ * 自适应步长配置
+ */
+export interface AdaptiveStepConfig {
+    /** 是否启用自适应步长 */
+    enabled: boolean;
+    /** 最小步长 */
+    minStep: number;
+    /** 最大步长 */
+    maxStep: number;
+    /** 基于密度的调整配置 */
+    densityBased: {
+        enabled: boolean;
+        /** 节点密度阈值（节点数/10000平方像素） */
+        threshold: number;
+    };
+    /** 基于距离的调整配置 */
+    distanceBased: {
+        enabled: boolean;
+        /** 短路径阈值（像素） */
+        shortPathThreshold: number;
+        /** 长路径阈值（像素） */
+        longPathThreshold: number;
+    };
+}
+/**
+ * 默认自适应步长配置
+ */
+export declare const DEFAULT_ADAPTIVE_STEP_CONFIG: AdaptiveStepConfig;
+/**
+ * 自适应步长计算器
+ */
+export declare class AdaptiveStepCalculator {
+    private config;
+    constructor(config?: Partial<AdaptiveStepConfig>);
+    /**
+     * 合并配置与默认值
+     */
+    private mergeConfig;
+    /**
+     * 计算节点密度
+     * @param nodeLookup 节点查找表
+     * @returns 密度值（节点数/10000平方像素）
+     */
+    calculateNodeDensity(nodeLookup: NodeLookup): number;
+    /**
+     * 计算两点之间的曼哈顿距离
+     */
+    calculateDistance(source: Point | {
+        x: number;
+        y: number;
+    }, target: Point | {
+        x: number;
+        y: number;
+    }): number;
+    /**
+     * 基于距离计算步长
+     */
+    calculateDistanceBasedStep(distance: number): number;
+    /**
+     * 基于密度计算步长
+     */
+    calculateDensityBasedStep(density: number): number;
+    /**
+     * 计算自适应步长
+     * 综合考虑距离和密度因素
+     */
+    calculateStep(sourceNode: InternalNode, targetNode: InternalNode, nodeLookup: NodeLookup): number;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): AdaptiveStepConfig;
+    /**
+     * 更新配置
+     */
+    updateConfig(config: Partial<AdaptiveStepConfig>): void;
+}
+//# sourceMappingURL=AdaptiveStepCalculator.d.ts.map

package/cjs/utils/AdaptiveStepCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveStepCalculator.d.ts","sourceRoot":"","sources":["../../src/utils/AdaptiveStepCalculator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,gBAAgB;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW;IACX,OAAO,EAAE,MAAM,CAAA;IACf,WAAW;IACX,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB;IAChB,YAAY,EAAE;QACZ,OAAO,EAAE,OAAO,CAAA;QAChB,4BAA4B;QAC5B,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;IACD,gBAAgB;IAChB,aAAa,EAAE;QACb,OAAO,EAAE,OAAO,CAAA;QAChB,gBAAgB;QAChB,kBAAkB,EAAE,MAAM,CAAA;QAC1B,gBAAgB;QAChB,iBAAiB,EAAE,MAAM,CAAA;KAC1B,CAAA;CACF;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,EAAE,kBAa1C,CAAA;AAED;;GAEG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,MAAM,CAAoB;gBAEtB,MAAM,GAAE,OAAO,CAAC,kBAAkB,CAAM;IAIpD;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;;;OAIG;IACH,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;IA2BpD;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,KAAK,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,MAAM,EAAE,KAAK,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAI7G;;OAEG;IACH,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAsBpD;;OAEG;IACH,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAsBlD;;;OAGG;IACH,aAAa,CACX,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE,UAAU,GACrB,MAAM;IAyCT;;OAEG;IACH,SAAS,IAAI,kBAAkB;IAI/B;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI;CAGxD"}

package/cjs/utils/AdaptiveStepCalculator.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_ADAPTIVE_STEP_CONFIG = exports.AdaptiveStepCalculator = void 0;
+/**
+ * AdaptiveStepCalculator - 自适应步长计算器
+ *
+ * 根据场景自动调整网格步长，平衡性能和路径质量
+ * - 高密度区域使用小步长，提高路径精度
+ * - 长距离路径使用大步长，提高计算性能
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 2.3, 2.4
+ */
+
+/**
+ * 自适应步长配置
+ */
+
+/**
+ * 默认自适应步长配置
+ */
+const DEFAULT_ADAPTIVE_STEP_CONFIG = exports.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
+  }
+};
+
+/**
+ * 自适应步长计算器
+ */
+class AdaptiveStepCalculator {
+  config;
+  constructor(config = {}) {
+    this.config = this.mergeConfig(config);
+  }
+
+  /**
+   * 合并配置与默认值
+   */
+  mergeConfig(config) {
+    return {
+      enabled: config.enabled ?? DEFAULT_ADAPTIVE_STEP_CONFIG.enabled,
+      minStep: config.minStep ?? DEFAULT_ADAPTIVE_STEP_CONFIG.minStep,
+      maxStep: config.maxStep ?? DEFAULT_ADAPTIVE_STEP_CONFIG.maxStep,
+      densityBased: {
+        enabled: config.densityBased?.enabled ?? DEFAULT_ADAPTIVE_STEP_CONFIG.densityBased.enabled,
+        threshold: config.densityBased?.threshold ?? DEFAULT_ADAPTIVE_STEP_CONFIG.densityBased.threshold
+      },
+      distanceBased: {
+        enabled: config.distanceBased?.enabled ?? DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.enabled,
+        shortPathThreshold: config.distanceBased?.shortPathThreshold ?? DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.shortPathThreshold,
+        longPathThreshold: config.distanceBased?.longPathThreshold ?? DEFAULT_ADAPTIVE_STEP_CONFIG.distanceBased.longPathThreshold
+      }
+    };
+  }
+
+  /**
+   * 计算节点密度
+   * @param nodeLookup 节点查找表
+   * @returns 密度值（节点数/10000平方像素）
+   */
+  calculateNodeDensity(nodeLookup) {
+    if (nodeLookup.size === 0) return 0;
+    let minX = Infinity,
+      minY = Infinity;
+    let maxX = -Infinity,
+      maxY = -Infinity;
+    for (const node of nodeLookup.values()) {
+      const pos = node.internals?.positionAbsolute ?? node.position;
+      const width = node.measured?.width ?? node.width ?? 100;
+      const height = node.measured?.height ?? node.height ?? 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平方像素为单位）
+    const width = maxX - minX;
+    const height = maxY - minY;
+    const area = width * height / 10000;
+    if (area <= 0) return 0;
+    return nodeLookup.size / area;
+  }
+
+  /**
+   * 计算两点之间的曼哈顿距离
+   */
+  calculateDistance(source, target) {
+    return Math.abs(target.x - source.x) + Math.abs(target.y - source.y);
+  }
+
+  /**
+   * 基于距离计算步长
+   */
+  calculateDistanceBasedStep(distance) {
+    const {
+      minStep,
+      maxStep,
+      distanceBased
+    } = this.config;
+    if (!distanceBased.enabled) {
+      return minStep;
+    }
+    const {
+      shortPathThreshold,
+      longPathThreshold
+    } = distanceBased;
+    if (distance <= shortPathThreshold) {
+      return minStep;
+    }
+    if (distance >= longPathThreshold) {
+      return maxStep;
+    }
+
+    // 线性插值
+    const ratio = (distance - shortPathThreshold) / (longPathThreshold - shortPathThreshold);
+    return Math.round(minStep + ratio * (maxStep - minStep));
+  }
+
+  /**
+   * 基于密度计算步长
+   */
+  calculateDensityBasedStep(density) {
+    const {
+      minStep,
+      maxStep,
+      densityBased
+    } = this.config;
+    if (!densityBased.enabled) {
+      return maxStep;
+    }
+
+    // 高密度使用小步长
+    if (density >= densityBased.threshold) {
+      return minStep;
+    }
+
+    // 低密度使用大步长
+    if (density <= densityBased.threshold / 2) {
+      return maxStep;
+    }
+
+    // 线性插值
+    const ratio = (densityBased.threshold - density) / (densityBased.threshold / 2);
+    return Math.round(minStep + ratio * (maxStep - minStep));
+  }
+
+  /**
+   * 计算自适应步长
+   * 综合考虑距离和密度因素
+   */
+  calculateStep(sourceNode, targetNode, nodeLookup) {
+    if (!this.config.enabled) {
+      return this.config.minStep;
+    }
+
+    // 获取源和目标位置
+    const sourcePos = sourceNode.internals?.positionAbsolute ?? sourceNode.position;
+    const targetPos = targetNode.internals?.positionAbsolute ?? targetNode.position;
+
+    // 计算节点中心点
+    const sourceWidth = sourceNode.measured?.width ?? sourceNode.width ?? 100;
+    const sourceHeight = sourceNode.measured?.height ?? sourceNode.height ?? 50;
+    const targetWidth = targetNode.measured?.width ?? targetNode.width ?? 100;
+    const targetHeight = targetNode.measured?.height ?? targetNode.height ?? 50;
+    const sourceCenter = {
+      x: sourcePos.x + sourceWidth / 2,
+      y: sourcePos.y + sourceHeight / 2
+    };
+    const targetCenter = {
+      x: targetPos.x + targetWidth / 2,
+      y: targetPos.y + targetHeight / 2
+    };
+
+    // 计算距离
+    const distance = this.calculateDistance(sourceCenter, targetCenter);
+
+    // 计算密度
+    const density = this.calculateNodeDensity(nodeLookup);
+
+    // 获取基于距离和密度的步长
+    const distanceStep = this.calculateDistanceBasedStep(distance);
+    const densityStep = this.calculateDensityBasedStep(density);
+
+    // 取两者中较小的值（更保守的选择）
+    const step = Math.min(distanceStep, densityStep);
+
+    // 确保步长在有效范围内
+    return Math.max(this.config.minStep, Math.min(this.config.maxStep, step));
+  }
+
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+
+  /**
+   * 更新配置
+   */
+  updateConfig(config) {
+    this.config = this.mergeConfig({
+      ...this.config,
+      ...config
+    });
+  }
+}
+exports.AdaptiveStepCalculator = AdaptiveStepCalculator;

package/cjs/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/cjs/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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"}