@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/svg/pathConverter.js

@@ -0,0 +1,285 @@
+"use strict";
+
+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
+ */
+function pointsToPath(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
+  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)) {
+      // 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;
+    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 quadratic bezier curve for the rounded corner
+    // The control point is the actual corner point
+    path += ` Q ${roundCoord(current.x)} ${roundCoord(current.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;
+}
+
+/**
+ * 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
+ */
+function snapPathToGrid(points, gridSize) {
+  if (points.length <= 1) {
+    return points;
+  }
+  const snappedPoints = [...points];
+
+  // Don't snap the first and last points (anchors)
+  // Don't snap the second and second-to-last points (extension points)
+  // Only snap intermediate segments
+  for (let i = 2; i < snappedPoints.length - 3; i++) {
+    const first = snappedPoints[i];
+    const second = snappedPoints[i + 1];
+    if (first.x === second.x) {
+      // Vertical line - snap X coordinate
+      const x = gridSize * Math.round(first.x / gridSize);
+      if (first.x !== x) {
+        first.x = x;
+        second.x = x;
+      }
+    } else if (first.y === second.y) {
+      // Horizontal line - snap Y coordinate
+      const y = gridSize * Math.round(first.y / gridSize);
+      if (first.y !== y) {
+        first.y = y;
+        second.y = y;
+      }
+    }
+  }
+  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/svg/pathParser.d.ts

@@ -0,0 +1,11 @@
+import { Point } from '../geometry';
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+export declare function parseSVGPath(pathString: string): Point[];
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+export declare function simplifyPath(points: Point[]): Point[];
+//# sourceMappingURL=pathParser.d.ts.map

package/cjs/svg/pathParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA2CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}

package/cjs/svg/pathParser.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSVGPath = parseSVGPath;
+exports.simplifyPath = simplifyPath;
+var _geometry = require("../geometry");
+/**
+ * Parse SVG path string to extract points
+ * Simplified parser that handles M, L, Q commands
+ */
+function parseSVGPath(pathString) {
+  const points = [];
+  const commands = pathString.match(/[MLQ][^MLQ]*/g);
+  if (!commands) return points;
+  for (const command of commands) {
+    const type = command[0];
+    const coords = command.slice(1).trim().split(/[\s,]+/).map(Number);
+    if (type === 'M' || type === 'L') {
+      // MoveTo or LineTo: x, y
+      if (coords.length >= 2) {
+        points.push(new _geometry.Point(coords[0], coords[1]));
+      }
+    } else if (type === 'Q') {
+      // Quadratic Bezier: cx, cy, x, y
+      // We sample points along the curve for collision detection
+      if (coords.length >= 4) {
+        const prevPoint = points[points.length - 1];
+        if (prevPoint) {
+          const cx = coords[0];
+          const cy = coords[1];
+          const x = coords[2];
+          const y = coords[3];
+
+          // Sample 10 points along the bezier curve for better accuracy
+          // This ensures we don't miss intersections with obstacles
+          for (let t = 0.1; t <= 1; t += 0.1) {
+            const bx = (1 - t) * (1 - t) * prevPoint.x + 2 * (1 - t) * t * cx + t * t * x;
+            const by = (1 - t) * (1 - t) * prevPoint.y + 2 * (1 - t) * t * cy + t * t * y;
+            points.push(new _geometry.Point(bx, by));
+          }
+        }
+      }
+    }
+  }
+  return points;
+}
+
+/**
+ * Simplify path by removing collinear intermediate points
+ */
+function simplifyPath(points) {
+  if (points.length <= 2) {
+    return points;
+  }
+  const simplified = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = simplified[simplified.length - 1];
+    const current = points[i];
+    const next = points[i + 1];
+
+    // Check if current point is collinear with prev and next
+    const isHorizontalLine = prev.y === current.y && current.y === next.y;
+    const isVerticalLine = prev.x === current.x && current.x === next.x;
+
+    // Only keep the point if it's not collinear (i.e., it's a corner)
+    if (!isHorizontalLine && !isVerticalLine) {
+      simplified.push(current);
+    }
+  }
+
+  // Always add the last point
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}

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;