@logicflow/core 2.1.9 → 2.1.11

package/es/model/edge/PolylineEdgeModel.d.ts

@@ -12,6 +12,13 @@ export declare class PolylineEdgeModel extends BaseEdgeModel {
     offset?: number;
     dbClickPosition?: Point;
     initEdgeData(data: LogicFlow.EdgeConfig): void;
+    setAttributes(): void;
+    orthogonalizePath(points: Point[]): Point[];
+    /**
+     * 计算默认 offset：箭头与折线重叠长度 + 5
+     * 重叠长度采用箭头样式中的 offset（沿边方向的长度）
+     */
+    private getDefaultOffset;
     getEdgeStyle(): {
         [x: string]: unknown;
         fill?: string | undefined;

package/es/model/edge/PolylineEdgeModel.js

@@ -69,12 +69,139 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
         return _this;
     }
     PolylineEdgeModel.prototype.initEdgeData = function (data) {
-        this.offset = get(data, 'properties.offset', 30);
+        var providedOffset = get(data, 'properties.offset');
+        // 当用户未传入 offset 时，按“箭头与折线重叠长度 + 5”作为默认值
+        // 其中“重叠长度”采用箭头样式中的 offset（沿边方向的长度）
+        this.offset =
+            typeof providedOffset === 'number'
+                ? providedOffset
+                : this.getDefaultOffset();
         if (data.pointsList) {
-            this.pointsList = data.pointsList;
+            var corrected = this.orthogonalizePath(data.pointsList);
+            data.pointsList = corrected;
+            this.pointsList = corrected;
         }
         _super.prototype.initEdgeData.call(this, data);
     };
+    PolylineEdgeModel.prototype.setAttributes = function () {
+        var newOffset = this.properties.offset;
+        if (newOffset && newOffset !== this.offset) {
+            this.offset = newOffset;
+            this.updatePoints();
+        }
+    };
+    PolylineEdgeModel.prototype.orthogonalizePath = function (points) {
+        // 输入非法或不足两点时直接返回副本
+        if (!Array.isArray(points) || points.length < 2) {
+            return points;
+        }
+        // pushUnique: 向数组中添加唯一点，避免重复
+        var pushUnique = function (arr, p) {
+            var last = arr[arr.length - 1];
+            if (!last || last.x !== p.x || last.y !== p.y) {
+                arr.push({ x: p.x, y: p.y });
+            }
+        };
+        // isAxisAligned: 检查两点是否在同一条轴上
+        var isAxisAligned = function (a, b) { return a.x === b.x || a.y === b.y; };
+        // manhattanDistance: 计算两点在曼哈顿距离上的距离
+        var manhattanDistance = function (a, b) {
+            return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+        };
+        // 1) 生成严格正交路径，尽量延续前一段方向以减少折点
+        var orthogonal = [];
+        pushUnique(orthogonal, points[0]);
+        // previousDirection: 记录前一段的方向，用于判断当前段的PreferredCorner
+        var previousDirection;
+        // 遍历所有点对，生成正交路径
+        for (var i = 0; i < points.length - 1; i++) {
+            var current = orthogonal[orthogonal.length - 1];
+            var next = points[i + 1];
+            if (!current || !next)
+                continue;
+            if (isAxisAligned(current, next)) {
+                pushUnique(orthogonal, next);
+                previousDirection =
+                    current.x === next.x
+                        ? SegmentDirection.VERTICAL
+                        : SegmentDirection.HORIZONTAL;
+                continue;
+            }
+            var cornerHV = { x: next.x, y: current.y };
+            var cornerVH = { x: current.x, y: next.y };
+            // 根据前一段的方向，优先选择能延续该方向的拐角点，以减少折点数量；
+            // 若前一段为垂直方向，则优先选择垂直-水平拐角(cornerVH)；
+            // 若前一段为水平方向，则优先选择水平-垂直拐角(cornerHV)；
+            // 若前一段无方向（初始情况），则比较两个拐角的曼哈顿距离，选更近者。
+            var preferredCorner = previousDirection === SegmentDirection.VERTICAL
+                ? cornerVH
+                : previousDirection === SegmentDirection.HORIZONTAL
+                    ? cornerHV
+                    : manhattanDistance(current, cornerHV) <=
+                        manhattanDistance(current, cornerVH)
+                        ? cornerHV
+                        : cornerVH;
+            if (preferredCorner.x !== current.x || preferredCorner.y !== current.y) {
+                pushUnique(orthogonal, preferredCorner);
+            }
+            pushUnique(orthogonal, next);
+            var a = orthogonal[orthogonal.length - 2];
+            var b = orthogonal[orthogonal.length - 1];
+            previousDirection =
+                a && b
+                    ? a.x === b.x
+                        ? SegmentDirection.VERTICAL
+                        : SegmentDirection.HORIZONTAL
+                    : previousDirection;
+        }
+        // 2) 去除冗余共线中间点
+        var simplified = [];
+        for (var i = 0; i < orthogonal.length; i++) {
+            var prev = orthogonal[i - 1];
+            var curr = orthogonal[i];
+            var next = orthogonal[i + 1];
+            // 如果当前点与前一个点和后一个点在同一条水平线或垂直线上，则跳过该点，去除冗余的共线中间点
+            if (prev &&
+                curr &&
+                next &&
+                ((prev.x === curr.x && curr.x === next.x) || // 水平共线
+                    (prev.y === curr.y && curr.y === next.y)) // 垂直共线
+            ) {
+                continue;
+            }
+            pushUnique(simplified, curr);
+        }
+        // 3) 保留原始起点与终点位置
+        if (simplified.length >= 2) {
+            simplified[0] = { x: points[0].x, y: points[0].y };
+            simplified[simplified.length - 1] = {
+                x: points[points.length - 1].x,
+                y: points[points.length - 1].y,
+            };
+        }
+        // 4) 结果校验：任意相邻段都必须为水平/垂直；失败则退化为起止两点
+        var isOrthogonal = simplified.length < 2 ||
+            simplified.every(function (_, idx, arr) {
+                if (idx === 0)
+                    return true;
+                return isAxisAligned(arr[idx - 1], arr[idx]);
+            });
+        return isOrthogonal
+            ? simplified
+            : [
+                { x: points[0].x, y: points[0].y },
+                { x: points[points.length - 1].x, y: points[points.length - 1].y },
+            ];
+    };
+    /**
+     * 计算默认 offset：箭头与折线重叠长度 + 5
+     * 重叠长度采用箭头样式中的 offset（沿边方向的长度）
+     */
+    PolylineEdgeModel.prototype.getDefaultOffset = function () {
+        var arrowStyle = this.getArrowStyle();
+        var arrowOverlap = typeof arrowStyle.offset === 'number' ? arrowStyle.offset : 0;
+        return arrowOverlap + 5;
+    };
     PolylineEdgeModel.prototype.getEdgeStyle = function () {
         var polyline = this.graphModel.theme.polyline;
         var style = _super.prototype.getEdgeStyle.call(this);
@@ -286,7 +413,7 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
         return list;
     };
     PolylineEdgeModel.prototype.updatePath = function (pointList) {
-        this.pointsList = pointList;
+        this.pointsList = this.orthogonalizePath(pointList);
         this.points = this.getPath(this.pointsList);
     };
     PolylineEdgeModel.prototype.getData = function () {
@@ -321,8 +448,10 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
             x: this.endPoint.x,
             y: this.endPoint.y,
         }, this.sourceNode, this.targetNode, this.offset || 0);
-        this.pointsList = pointsList;
-        this.points = pointsList.map(function (point) { return "".concat(point.x, ",").concat(point.y); }).join(' ');
+        this.pointsList = this.orthogonalizePath(pointsList);
+        this.points = this.pointsList
+            .map(function (point) { return "".concat(point.x, ",").concat(point.y); })
+            .join(' ');
     };
     PolylineEdgeModel.prototype.updateStartPoint = function (anchor) {
         this.startPoint = Object.assign({}, anchor);
@@ -544,13 +673,13 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
     // 起终点拖拽调整过程中，进行折线路径更新
     PolylineEdgeModel.prototype.updateAfterAdjustStartAndEnd = function (_a) {
         var startPoint = _a.startPoint, endPoint = _a.endPoint, sourceNode = _a.sourceNode, targetNode = _a.targetNode;
-        this.pointsList = getPolylinePoints({
+        this.pointsList = this.orthogonalizePath(getPolylinePoints({
             x: startPoint.x,
             y: startPoint.y,
         }, {
             x: endPoint.x,
             y: endPoint.y,
-        }, sourceNode, targetNode, this.offset || 0);
+        }, sourceNode, targetNode, this.offset || 0));
         this.initPoints();
     };
     __decorate([

package/es/tool/MultipleSelectTool.js

@@ -55,6 +55,10 @@ var MultipleSelect = /** @class */ (function (_super) {
     function MultipleSelect(props) {
         var _this = _super.call(this, props) || this;
         _this.handleMouseDown = function (ev) {
+            // 多选区域的拖拽步长随缩放变化
+            var _a = _this.props, gridSize = _a.graphModel.gridSize, lf = _a.lf;
+            var SCALE_X = lf.getTransform().SCALE_X;
+            _this.stepDrag.setStep(gridSize * SCALE_X);
             _this.stepDrag.handleMouseDown(ev);
         };
         // 使多选区域的滚轮事件可以触发画布的滚轮事件

package/es/util/edge.d.ts

@@ -14,6 +14,15 @@ export declare const filterRepeatPoints: (points: Point[]) => Point[];
 export declare const getSimplePolyline: (sPoint: Point, tPoint: Point) => Point[];
 export declare const getExpandedBBox: (bbox: BoxBounds, offset: number) => BoxBounds;
 export declare const pointDirection: (point: Point, bbox: BoxBounds) => Direction;
+/**
+ * 计算扩展包围盒上的相邻点（起点或终点的下一个/上一个拐点）
+ * - 使用原始节点 bbox 来判定点相对中心的方向，避免 offset 扩展后宽高改变导致方向误判
+ * - 若 start 相对中心为水平方向，则返回扩展盒在 x 上的边界，y 保持不变
+ * - 若为垂直方向，则返回扩展盒在 y 上的边界，x 保持不变
+ * @param expendBBox 扩展后的包围盒（包含 offset）
+ * @param bbox 原始节点包围盒（用于正确的方向判定）
+ * @param point 起点或终点坐标
+ */
 export declare const getExpandedBBoxPoint: (expendBBox: BoxBounds, bbox: BoxBounds, point: Point) => Point;
 export declare const mergeBBox: (b1: BoxBounds, b2: BoxBounds) => BoxBounds;
 export declare const getBBoxOfPoints: (points?: Point[], offset?: number) => BoxBounds;
@@ -32,10 +41,36 @@ export declare const rebuildPath: (pathPoints: Point[], pointById: PolyPointMap,
 export declare const removeClosePointFromOpenList: (arr: Point[], item: Point) => void;
 export declare const isSegmentsIntersected: (p0: Point, p1: Point, p2: Point, p3: Point) => boolean;
 export declare const isSegmentCrossingBBox: (p1: Point, p2: Point, bbox: BoxBounds) => boolean;
+/**
+ * 基于轴对齐规则获取某点的相邻可连通点（不穿越节点）
+ * - 仅考虑 x 或 y 相同的候选点，保证严格水平/垂直
+ * - 使用 isSegmentCrossingBBox 校验线段不穿越源/目标节点
+ */
 export declare const getNextNeighborPoints: (points: Point[], point: Point, bbox1: BoxBounds, bbox2: BoxBounds) => Point[];
+/**
+ * 使用 A* + 曼哈顿启发式在候选点图上查找正交路径
+ * - 开放集/关闭集管理遍历
+ * - gScore 为累计实际代价，fScore = gScore + 启发式
+ * - 邻居仅为与当前点 x 或 y 相同且不穿越节点的点
+ * 参考：https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
+ */
 export declare const pathFinder: (points: Point[], start: Point, goal: Point, sBBox: BoxBounds, tBBox: BoxBounds, os: Point, ot: Point) => Point[];
 export declare const getBoxByOriginNode: (node: BaseNodeModel) => BoxBounds;
+/**
+ * 去除共线冗余中间点，保持每条直线段仅保留两端点
+ * - 若三点在同一水平线或同一垂直线，移除中间点
+ */
 export declare const pointFilter: (points: Point[]) => Point[];
+/**
+ * 计算折线点（正交候选点 + A* 路径）
+ * 步骤：
+ * 1) 取源/目标节点的扩展包围盒与相邻点 sPoint/tPoint
+ * 2) 若两个扩展盒重合，使用简单路径 getSimplePoints
+ * 3) 构造 lineBBox/sMixBBox/tMixBBox，并收集其角点与中心交点
+ * 4) 过滤掉落在两个扩展盒内部的点，形成 connectPoints
+ * 5) 以 sPoint/tPoint 为起止，用 A* 查找路径
+ * 6) 拼入原始 start/end，并用 pointFilter 去除冗余共线点
+ */
 export declare const getPolylinePoints: (start: Point, end: Point, sNode: BaseNodeModel, tNode: BaseNodeModel, offset: number) => Point[];
 /**
  * 获取折线中最长的一个线
@@ -47,6 +82,10 @@ export declare const isSegmentsCrossNode: (start: Point, end: Point, node: BaseN
 export declare const getCrossPointInRect: (start: Point, end: Point, node: BaseNodeModel) => Point | false | undefined;
 export declare const segmentDirection: (start: Point, end: Point) => Direction | undefined;
 export declare const points2PointsList: (points: string) => Point[];
+/**
+ * 当扩展 bbox 重合时的简化拐点计算
+ * - 根据起止段的方向（水平/垂直）插入 1~2 个中间点，避免折线重合与穿越
+ */
 export declare const getSimplePoints: (start: Point, end: Point, sPoint: Point, tPoint: Point) => Point[];
 export declare const getBytesLength: (word: string) => number;
 export declare const getTextWidth: (text: string, font: string) => number;

package/es/util/edge.js

@@ -113,6 +113,15 @@ export var pointDirection = function (point, bbox) {
         : SegmentDirection.VERTICAL;
 };
 /* 获取扩展图形上的点，即起始终点相邻的点，上一个或者下一个节点 */
+/**
+ * 计算扩展包围盒上的相邻点（起点或终点的下一个/上一个拐点）
+ * - 使用原始节点 bbox 来判定点相对中心的方向，避免 offset 扩展后宽高改变导致方向误判
+ * - 若 start 相对中心为水平方向，则返回扩展盒在 x 上的边界，y 保持不变
+ * - 若为垂直方向，则返回扩展盒在 y 上的边界，x 保持不变
+ * @param expendBBox 扩展后的包围盒（包含 offset）
+ * @param bbox 原始节点包围盒（用于正确的方向判定）
+ * @param point 起点或终点坐标
+ */
 export var getExpandedBBoxPoint = function (expendBBox, bbox, point) {
     // https://github.com/didi/LogicFlow/issues/817
     // 没有修复前传入的参数bbox实际是expendBBox
@@ -313,7 +322,11 @@ export var isSegmentCrossingBBox = function (p1, p2, bbox) {
         isSegmentsIntersected(p1, p2, pb, pc) ||
         isSegmentsIntersected(p1, p2, pc, pd));
 };
-/* 获取下一个相邻的点 */
+/**
+ * 基于轴对齐规则获取某点的相邻可连通点（不穿越节点）
+ * - 仅考虑 x 或 y 相同的候选点，保证严格水平/垂直
+ * - 使用 isSegmentCrossingBBox 校验线段不穿越源/目标节点
+ */
 export var getNextNeighborPoints = function (points, point, bbox1, bbox2) {
     var neighbors = [];
     points.forEach(function (p) {
@@ -328,9 +341,12 @@ export var getNextNeighborPoints = function (points, point, bbox1, bbox2) {
     });
     return filterRepeatPoints(neighbors);
 };
-/* 路径查找,AStar查找+曼哈顿距离
- * 算法wiki:https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
- * 方法无法复用，且调用了很多polyline相关的方法，暂不抽离到src/algorithm中
+/**
+ * 使用 A* + 曼哈顿启发式在候选点图上查找正交路径
+ * - 开放集/关闭集管理遍历
+ * - gScore 为累计实际代价，fScore = gScore + 启发式
+ * - 邻居仅为与当前点 x 或 y 相同且不穿越节点的点
+ * 参考：https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
  */
 export var pathFinder = function (points, start, goal, sBBox, tBBox, os, ot) {
     // 定义已经遍历过的点
@@ -371,6 +387,7 @@ export var pathFinder = function (points, start, goal, sBBox, tBBox, os, ot) {
         removeClosePointFromOpenList(openSet, current);
         closedSet.push(current);
         getNextNeighborPoints(points, current, sBBox, tBBox).forEach(function (neighbor) {
+            var _a;
             if (closedSet.indexOf(neighbor) !== -1) {
                 return;
             }
@@ -378,7 +395,8 @@ export var pathFinder = function (points, start, goal, sBBox, tBBox, os, ot) {
                 openSet.push(neighbor);
             }
             if ((current === null || current === void 0 ? void 0 : current.id) && (neighbor === null || neighbor === void 0 ? void 0 : neighbor.id)) {
-                var tentativeGScore = fScore[current.id] + estimateDistance(current, neighbor);
+                // 修复：累计代价应基于 gScore[current] 而非 fScore[current]
+                var tentativeGScore = ((_a = gScore[current.id]) !== null && _a !== void 0 ? _a : 0) + estimateDistance(current, neighbor);
                 if (gScore[neighbor.id] && tentativeGScore >= gScore[neighbor.id]) {
                     return;
                 }
@@ -400,7 +418,10 @@ export var pathFinder = function (points, start, goal, sBBox, tBBox, os, ot) {
 export var getBoxByOriginNode = function (node) {
     return getNodeBBox(node);
 };
-/* 保证一条直线上只有2个节点： 删除x/y相同的中间节点 */
+/**
+ * 去除共线冗余中间点，保持每条直线段仅保留两端点
+ * - 若三点在同一水平线或同一垂直线，移除中间点
+ */
 export var pointFilter = function (points) {
     var i = 1;
     while (i < points.length - 1) {
@@ -417,7 +438,16 @@ export var pointFilter = function (points) {
     }
     return points;
 };
-/* 计算折线点 */
+/**
+ * 计算折线点（正交候选点 + A* 路径）
+ * 步骤：
+ * 1) 取源/目标节点的扩展包围盒与相邻点 sPoint/tPoint
+ * 2) 若两个扩展盒重合，使用简单路径 getSimplePoints
+ * 3) 构造 lineBBox/sMixBBox/tMixBBox，并收集其角点与中心交点
+ * 4) 过滤掉落在两个扩展盒内部的点，形成 connectPoints
+ * 5) 以 sPoint/tPoint 为起止，用 A* 查找路径
+ * 6) 拼入原始 start/end，并用 pointFilter 去除冗余共线点
+ */
 export var getPolylinePoints = function (start, end, sNode, tNode, offset) {
     var sBBox = getBoxByOriginNode(sNode);
     var tBBox = getBoxByOriginNode(tNode);
@@ -554,6 +584,10 @@ export var points2PointsList = function (points) {
         });
     return pointsList;
 };
+/**
+ * 当扩展 bbox 重合时的简化拐点计算
+ * - 根据起止段的方向（水平/垂直）插入 1~2 个中间点，避免折线重合与穿越
+ */
 export var getSimplePoints = function (start, end, sPoint, tPoint) {
     var points = [];
     // start,sPoint的方向，水平或者垂直，即路径第一条线段的方向

package/es/view/overlay/CanvasOverlay.js

@@ -103,6 +103,9 @@ var CanvasOverlay = /** @class */ (function (_super) {
                 if (selectElements.size > 0) {
                     graphModel.clearSelectElements();
                 }
+                // 如果是拖拽状态，不触发点击事件
+                if (_this.state.isDragging)
+                    return;
                 graphModel.eventCenter.emit(EventType.BLANK_CLICK, { e: ev });
             }
         };

package/lib/model/edge/PolylineEdgeModel.d.ts

@@ -12,6 +12,13 @@ export declare class PolylineEdgeModel extends BaseEdgeModel {
     offset?: number;
     dbClickPosition?: Point;
     initEdgeData(data: LogicFlow.EdgeConfig): void;
+    setAttributes(): void;
+    orthogonalizePath(points: Point[]): Point[];
+    /**
+     * 计算默认 offset：箭头与折线重叠长度 + 5
+     * 重叠长度采用箭头样式中的 offset（沿边方向的长度）
+     */
+    private getDefaultOffset;
     getEdgeStyle(): {
         [x: string]: unknown;
         fill?: string | undefined;

package/lib/model/edge/PolylineEdgeModel.js

@@ -72,12 +72,139 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
         return _this;
     }
     PolylineEdgeModel.prototype.initEdgeData = function (data) {
-        this.offset = (0, lodash_es_1.get)(data, 'properties.offset', 30);
+        var providedOffset = (0, lodash_es_1.get)(data, 'properties.offset');
+        // 当用户未传入 offset 时，按“箭头与折线重叠长度 + 5”作为默认值
+        // 其中“重叠长度”采用箭头样式中的 offset（沿边方向的长度）
+        this.offset =
+            typeof providedOffset === 'number'
+                ? providedOffset
+                : this.getDefaultOffset();
         if (data.pointsList) {
-            this.pointsList = data.pointsList;
+            var corrected = this.orthogonalizePath(data.pointsList);
+            data.pointsList = corrected;
+            this.pointsList = corrected;
         }
         _super.prototype.initEdgeData.call(this, data);
     };
+    PolylineEdgeModel.prototype.setAttributes = function () {
+        var newOffset = this.properties.offset;
+        if (newOffset && newOffset !== this.offset) {
+            this.offset = newOffset;
+            this.updatePoints();
+        }
+    };
+    PolylineEdgeModel.prototype.orthogonalizePath = function (points) {
+        // 输入非法或不足两点时直接返回副本
+        if (!Array.isArray(points) || points.length < 2) {
+            return points;
+        }
+        // pushUnique: 向数组中添加唯一点，避免重复
+        var pushUnique = function (arr, p) {
+            var last = arr[arr.length - 1];
+            if (!last || last.x !== p.x || last.y !== p.y) {
+                arr.push({ x: p.x, y: p.y });
+            }
+        };
+        // isAxisAligned: 检查两点是否在同一条轴上
+        var isAxisAligned = function (a, b) { return a.x === b.x || a.y === b.y; };
+        // manhattanDistance: 计算两点在曼哈顿距离上的距离
+        var manhattanDistance = function (a, b) {
+            return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+        };
+        // 1) 生成严格正交路径，尽量延续前一段方向以减少折点
+        var orthogonal = [];
+        pushUnique(orthogonal, points[0]);
+        // previousDirection: 记录前一段的方向，用于判断当前段的PreferredCorner
+        var previousDirection;
+        // 遍历所有点对，生成正交路径
+        for (var i = 0; i < points.length - 1; i++) {
+            var current = orthogonal[orthogonal.length - 1];
+            var next = points[i + 1];
+            if (!current || !next)
+                continue;
+            if (isAxisAligned(current, next)) {
+                pushUnique(orthogonal, next);
+                previousDirection =
+                    current.x === next.x
+                        ? constant_1.SegmentDirection.VERTICAL
+                        : constant_1.SegmentDirection.HORIZONTAL;
+                continue;
+            }
+            var cornerHV = { x: next.x, y: current.y };
+            var cornerVH = { x: current.x, y: next.y };
+            // 根据前一段的方向，优先选择能延续该方向的拐角点，以减少折点数量；
+            // 若前一段为垂直方向，则优先选择垂直-水平拐角(cornerVH)；
+            // 若前一段为水平方向，则优先选择水平-垂直拐角(cornerHV)；
+            // 若前一段无方向（初始情况），则比较两个拐角的曼哈顿距离，选更近者。
+            var preferredCorner = previousDirection === constant_1.SegmentDirection.VERTICAL
+                ? cornerVH
+                : previousDirection === constant_1.SegmentDirection.HORIZONTAL
+                    ? cornerHV
+                    : manhattanDistance(current, cornerHV) <=
+                        manhattanDistance(current, cornerVH)
+                        ? cornerHV
+                        : cornerVH;
+            if (preferredCorner.x !== current.x || preferredCorner.y !== current.y) {
+                pushUnique(orthogonal, preferredCorner);
+            }
+            pushUnique(orthogonal, next);
+            var a = orthogonal[orthogonal.length - 2];
+            var b = orthogonal[orthogonal.length - 1];
+            previousDirection =
+                a && b
+                    ? a.x === b.x
+                        ? constant_1.SegmentDirection.VERTICAL
+                        : constant_1.SegmentDirection.HORIZONTAL
+                    : previousDirection;
+        }
+        // 2) 去除冗余共线中间点
+        var simplified = [];
+        for (var i = 0; i < orthogonal.length; i++) {
+            var prev = orthogonal[i - 1];
+            var curr = orthogonal[i];
+            var next = orthogonal[i + 1];
+            // 如果当前点与前一个点和后一个点在同一条水平线或垂直线上，则跳过该点，去除冗余的共线中间点
+            if (prev &&
+                curr &&
+                next &&
+                ((prev.x === curr.x && curr.x === next.x) || // 水平共线
+                    (prev.y === curr.y && curr.y === next.y)) // 垂直共线
+            ) {
+                continue;
+            }
+            pushUnique(simplified, curr);
+        }
+        // 3) 保留原始起点与终点位置
+        if (simplified.length >= 2) {
+            simplified[0] = { x: points[0].x, y: points[0].y };
+            simplified[simplified.length - 1] = {
+                x: points[points.length - 1].x,
+                y: points[points.length - 1].y,
+            };
+        }
+        // 4) 结果校验：任意相邻段都必须为水平/垂直；失败则退化为起止两点
+        var isOrthogonal = simplified.length < 2 ||
+            simplified.every(function (_, idx, arr) {
+                if (idx === 0)
+                    return true;
+                return isAxisAligned(arr[idx - 1], arr[idx]);
+            });
+        return isOrthogonal
+            ? simplified
+            : [
+                { x: points[0].x, y: points[0].y },
+                { x: points[points.length - 1].x, y: points[points.length - 1].y },
+            ];
+    };
+    /**
+     * 计算默认 offset：箭头与折线重叠长度 + 5
+     * 重叠长度采用箭头样式中的 offset（沿边方向的长度）
+     */
+    PolylineEdgeModel.prototype.getDefaultOffset = function () {
+        var arrowStyle = this.getArrowStyle();
+        var arrowOverlap = typeof arrowStyle.offset === 'number' ? arrowStyle.offset : 0;
+        return arrowOverlap + 5;
+    };
     PolylineEdgeModel.prototype.getEdgeStyle = function () {
         var polyline = this.graphModel.theme.polyline;
         var style = _super.prototype.getEdgeStyle.call(this);
@@ -289,7 +416,7 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
         return list;
     };
     PolylineEdgeModel.prototype.updatePath = function (pointList) {
-        this.pointsList = pointList;
+        this.pointsList = this.orthogonalizePath(pointList);
         this.points = this.getPath(this.pointsList);
     };
     PolylineEdgeModel.prototype.getData = function () {
@@ -324,8 +451,10 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
             x: this.endPoint.x,
             y: this.endPoint.y,
         }, this.sourceNode, this.targetNode, this.offset || 0);
-        this.pointsList = pointsList;
-        this.points = pointsList.map(function (point) { return "".concat(point.x, ",").concat(point.y); }).join(' ');
+        this.pointsList = this.orthogonalizePath(pointsList);
+        this.points = this.pointsList
+            .map(function (point) { return "".concat(point.x, ",").concat(point.y); })
+            .join(' ');
     };
     PolylineEdgeModel.prototype.updateStartPoint = function (anchor) {
         this.startPoint = Object.assign({}, anchor);
@@ -547,13 +676,13 @@ var PolylineEdgeModel = /** @class */ (function (_super) {
     // 起终点拖拽调整过程中，进行折线路径更新
     PolylineEdgeModel.prototype.updateAfterAdjustStartAndEnd = function (_a) {
         var startPoint = _a.startPoint, endPoint = _a.endPoint, sourceNode = _a.sourceNode, targetNode = _a.targetNode;
-        this.pointsList = (0, util_1.getPolylinePoints)({
+        this.pointsList = this.orthogonalizePath((0, util_1.getPolylinePoints)({
             x: startPoint.x,
             y: startPoint.y,
         }, {
             x: endPoint.x,
             y: endPoint.y,
-        }, sourceNode, targetNode, this.offset || 0);
+        }, sourceNode, targetNode, this.offset || 0));
         this.initPoints();
     };
     __decorate([

package/lib/tool/MultipleSelectTool.js

@@ -57,6 +57,10 @@ var MultipleSelect = /** @class */ (function (_super) {
     function MultipleSelect(props) {
         var _this = _super.call(this, props) || this;
         _this.handleMouseDown = function (ev) {
+            // 多选区域的拖拽步长随缩放变化
+            var _a = _this.props, gridSize = _a.graphModel.gridSize, lf = _a.lf;
+            var SCALE_X = lf.getTransform().SCALE_X;
+            _this.stepDrag.setStep(gridSize * SCALE_X);
             _this.stepDrag.handleMouseDown(ev);
         };
         // 使多选区域的滚轮事件可以触发画布的滚轮事件

package/lib/util/edge.d.ts

@@ -14,6 +14,15 @@ export declare const filterRepeatPoints: (points: Point[]) => Point[];
 export declare const getSimplePolyline: (sPoint: Point, tPoint: Point) => Point[];
 export declare const getExpandedBBox: (bbox: BoxBounds, offset: number) => BoxBounds;
 export declare const pointDirection: (point: Point, bbox: BoxBounds) => Direction;
+/**
+ * 计算扩展包围盒上的相邻点（起点或终点的下一个/上一个拐点）
+ * - 使用原始节点 bbox 来判定点相对中心的方向，避免 offset 扩展后宽高改变导致方向误判
+ * - 若 start 相对中心为水平方向，则返回扩展盒在 x 上的边界，y 保持不变
+ * - 若为垂直方向，则返回扩展盒在 y 上的边界，x 保持不变
+ * @param expendBBox 扩展后的包围盒（包含 offset）
+ * @param bbox 原始节点包围盒（用于正确的方向判定）
+ * @param point 起点或终点坐标
+ */
 export declare const getExpandedBBoxPoint: (expendBBox: BoxBounds, bbox: BoxBounds, point: Point) => Point;
 export declare const mergeBBox: (b1: BoxBounds, b2: BoxBounds) => BoxBounds;
 export declare const getBBoxOfPoints: (points?: Point[], offset?: number) => BoxBounds;
@@ -32,10 +41,36 @@ export declare const rebuildPath: (pathPoints: Point[], pointById: PolyPointMap,
 export declare const removeClosePointFromOpenList: (arr: Point[], item: Point) => void;
 export declare const isSegmentsIntersected: (p0: Point, p1: Point, p2: Point, p3: Point) => boolean;
 export declare const isSegmentCrossingBBox: (p1: Point, p2: Point, bbox: BoxBounds) => boolean;
+/**
+ * 基于轴对齐规则获取某点的相邻可连通点（不穿越节点）
+ * - 仅考虑 x 或 y 相同的候选点，保证严格水平/垂直
+ * - 使用 isSegmentCrossingBBox 校验线段不穿越源/目标节点
+ */
 export declare const getNextNeighborPoints: (points: Point[], point: Point, bbox1: BoxBounds, bbox2: BoxBounds) => Point[];
+/**
+ * 使用 A* + 曼哈顿启发式在候选点图上查找正交路径
+ * - 开放集/关闭集管理遍历
+ * - gScore 为累计实际代价，fScore = gScore + 启发式
+ * - 邻居仅为与当前点 x 或 y 相同且不穿越节点的点
+ * 参考：https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
+ */
 export declare const pathFinder: (points: Point[], start: Point, goal: Point, sBBox: BoxBounds, tBBox: BoxBounds, os: Point, ot: Point) => Point[];
 export declare const getBoxByOriginNode: (node: BaseNodeModel) => BoxBounds;
+/**
+ * 去除共线冗余中间点，保持每条直线段仅保留两端点
+ * - 若三点在同一水平线或同一垂直线，移除中间点
+ */
 export declare const pointFilter: (points: Point[]) => Point[];
+/**
+ * 计算折线点（正交候选点 + A* 路径）
+ * 步骤：
+ * 1) 取源/目标节点的扩展包围盒与相邻点 sPoint/tPoint
+ * 2) 若两个扩展盒重合，使用简单路径 getSimplePoints
+ * 3) 构造 lineBBox/sMixBBox/tMixBBox，并收集其角点与中心交点
+ * 4) 过滤掉落在两个扩展盒内部的点，形成 connectPoints
+ * 5) 以 sPoint/tPoint 为起止，用 A* 查找路径
+ * 6) 拼入原始 start/end，并用 pointFilter 去除冗余共线点
+ */
 export declare const getPolylinePoints: (start: Point, end: Point, sNode: BaseNodeModel, tNode: BaseNodeModel, offset: number) => Point[];
 /**
  * 获取折线中最长的一个线
@@ -47,6 +82,10 @@ export declare const isSegmentsCrossNode: (start: Point, end: Point, node: BaseN
 export declare const getCrossPointInRect: (start: Point, end: Point, node: BaseNodeModel) => Point | false | undefined;
 export declare const segmentDirection: (start: Point, end: Point) => Direction | undefined;
 export declare const points2PointsList: (points: string) => Point[];
+/**
+ * 当扩展 bbox 重合时的简化拐点计算
+ * - 根据起止段的方向（水平/垂直）插入 1~2 个中间点，避免折线重合与穿越
+ */
 export declare const getSimplePoints: (start: Point, end: Point, sPoint: Point, tPoint: Point) => Point[];
 export declare const getBytesLength: (word: string) => number;
 export declare const getTextWidth: (text: string, font: string) => number;