@plait/common 0.29.0 → 0.30.0

package/esm2022/utils/line-path.mjs

@@ -1,4 +1,4 @@
-import { Direction, distanceBetweenPointAndPoint } from '@plait/core';
+import { Direction, Point, distanceBetweenPointAndPoint } from '@plait/core';
 import { getDirectionFactor } from './direction';
 export function getOppositeDirection(direction) {
     switch (direction) {
@@ -143,4 +143,15 @@ export function isPointOnLineSegment(point, startPoint, endPoint) {
     const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
     return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-path.js","sourceRoot":"","sources":["../../../../packages/common/src/utils/line-path.ts"],"names":[],"mappings":"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","sourcesContent":["import { Direction, Point, distanceBetweenPointAndPoint } from '@plait/core';\nimport { getDirectionFactor } from './direction';\n\nexport function getOppositeDirection(direction: Direction) {\n    switch (direction) {\n        case Direction.left:\n            return Direction.right;\n        case Direction.right:\n            return Direction.left;\n        case Direction.top:\n            return Direction.bottom;\n        case Direction.bottom:\n            return Direction.top;\n    }\n}\n\nexport const getPoints = (source: Point, sourcePosition: Direction, target: Point, targetPosition: Direction, offset: number) => {\n    const sourceDir = getDirectionFactor(sourcePosition);\n    const targetDir = getDirectionFactor(targetPosition);\n    const sourceGapped: Point = [source[0] + sourceDir.x * offset, source[1] + sourceDir.y * offset];\n    const targetGapped: Point = [target[0] + targetDir.x * offset, target[1] + targetDir.y * offset];\n    const dir = getDirection(sourceGapped, sourcePosition, targetGapped);\n    const dirAccessor = dir.x !== 0 ? 'x' : 'y';\n    const currDir = dir[dirAccessor];\n\n    let points: Point[] = [];\n    let centerX, centerY;\n    const [defaultCenterX, defaultCenterY] = getEdgeCenter({\n        sourceX: source[0],\n        sourceY: source[1],\n        targetX: target[0],\n        targetY: target[1]\n    });\n    // opposite handle positions, default case\n    if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {\n        centerX = defaultCenterX;\n        centerY = defaultCenterY;\n        //    --->\n        //    |\n        // >---\n        const verticalSplit: Point[] = [\n            [centerX, sourceGapped[1]],\n            [centerX, targetGapped[1]]\n        ];\n        //    |\n        //  ---\n        //  |\n        const horizontalSplit: Point[] = [\n            [sourceGapped[0], centerY],\n            [targetGapped[0], centerY]\n        ];\n        if (sourceDir[dirAccessor] === currDir) {\n            points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;\n        } else {\n            points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;\n        }\n    } else {\n        // sourceTarget means we take x from source and y from target, targetSource is the opposite\n        const sourceTarget: Point[] = [[sourceGapped[0], targetGapped[1]]];\n        const targetSource: Point[] = [[targetGapped[0], sourceGapped[1]]];\n        // this handles edges with same handle positions\n        if (dirAccessor === 'x') {\n            points = sourceDir.x === currDir ? targetSource : sourceTarget;\n        } else {\n            points = sourceDir.y === currDir ? sourceTarget : targetSource;\n        }\n\n        // these are conditions for handling mixed handle positions like right -> bottom for example\n        let flipSourceTarget;\n        if (sourcePosition !== targetPosition) {\n            const dirAccessorOpposite = dirAccessor === 'x' ? 1 : 0;\n            const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessor === 'x' ? 'y' : 'x'];\n            const sourceGtTargetOppo = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];\n            const sourceLtTargetOppo = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];\n            flipSourceTarget =\n                (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||\n                (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));\n\n            if (flipSourceTarget) {\n                points = dirAccessor === 'x' ? sourceTarget : targetSource;\n            }\n        }\n    }\n    return [source, sourceGapped, ...points, targetGapped, target];\n};\n\nexport const getDirection = (source: Point, sourcePosition = Direction.bottom, target: Point) => {\n    if (sourcePosition === Direction.left || sourcePosition === Direction.right) {\n        return source[0] < target[0] ? { x: 1, y: 0 } : { x: -1, y: 0 };\n    }\n    return source[1] < target[1] ? { x: 0, y: 1 } : { x: 0, y: -1 };\n};\n\nexport function getEdgeCenter({\n    sourceX,\n    sourceY,\n    targetX,\n    targetY\n}: {\n    sourceX: number;\n    sourceY: number;\n    targetX: number;\n    targetY: number;\n}): [number, number, number, number] {\n    const xOffset = Math.abs(targetX - sourceX) / 2;\n    const centerX = targetX < sourceX ? targetX + xOffset : targetX - xOffset;\n\n    const yOffset = Math.abs(targetY - sourceY) / 2;\n    const centerY = targetY < sourceY ? targetY + yOffset : targetY - yOffset;\n\n    return [centerX, centerY, xOffset, yOffset];\n}\n\nexport function getPointOnPolyline(points: Point[], ratio: number) {\n    const totalLength = calculatePolylineLength(points);\n    const targetDistance = totalLength * ratio;\n\n    let accumulatedDistance = 0;\n    for (let i = 0; i < points.length - 1; i++) {\n        const [x1, y1] = points[i];\n        const [x2, y2] = points[i + 1];\n        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);\n\n        if (accumulatedDistance + segmentLength >= targetDistance) {\n            const remainingDistance = targetDistance - accumulatedDistance;\n            const ratioInSegment = remainingDistance / segmentLength;\n\n            const targetX = x1 + (x2 - x1) * ratioInSegment;\n            const targetY = y1 + (y2 - y1) * ratioInSegment;\n            return [targetX, targetY];\n        }\n\n        accumulatedDistance += segmentLength;\n    }\n\n    return points[points.length - 1];\n}\n\nexport function calculatePolylineLength(points: Point[]) {\n    let length = 0;\n    for (let i = 0; i < points.length - 1; i++) {\n        const [x1, y1] = points[i];\n        const [x2, y2] = points[i + 1];\n        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);\n    }\n    return length;\n}\n\nexport function getRatioByPoint(points: Point[], point: Point) {\n    const totalLength = calculatePolylineLength(points);\n\n    let distance = 0;\n\n    for (let i = 0; i < points.length - 1; i++) {\n        const isOverlap = isPointOnLineSegment(point, points[i], points[i + 1]);\n\n        if (isOverlap) {\n            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);\n            return distance / totalLength;\n        } else {\n            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);\n        }\n    }\n    throw new Error('Cannot get ratio by point');\n}\n\nexport function isPointOnLineSegment(point: Point, startPoint: Point, endPoint: Point) {\n    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);\n    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);\n\n    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);\n\n    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;\n}\n"]}
+export const removeDuplicatePoints = (points) => {
+    const newArray = [];
+    points.forEach(point => {
+        const index = newArray.findIndex(otherPoint => {
+            return Point.isEquals(point, otherPoint);
+        });
+        if (index === -1)
+            newArray.push(point);
+    });
+    return newArray;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-path.js","sourceRoot":"","sources":["../../../../packages/common/src/utils/line-path.ts"],"names":[],"mappings":"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","sourcesContent":["import { Direction, Point, distanceBetweenPointAndPoint } from '@plait/core';\nimport { getDirectionFactor } from './direction';\n\nexport function getOppositeDirection(direction: Direction) {\n    switch (direction) {\n        case Direction.left:\n            return Direction.right;\n        case Direction.right:\n            return Direction.left;\n        case Direction.top:\n            return Direction.bottom;\n        case Direction.bottom:\n            return Direction.top;\n    }\n}\n\nexport const getPoints = (source: Point, sourcePosition: Direction, target: Point, targetPosition: Direction, offset: number) => {\n    const sourceDir = getDirectionFactor(sourcePosition);\n    const targetDir = getDirectionFactor(targetPosition);\n    const sourceGapped: Point = [source[0] + sourceDir.x * offset, source[1] + sourceDir.y * offset];\n    const targetGapped: Point = [target[0] + targetDir.x * offset, target[1] + targetDir.y * offset];\n    const dir = getDirection(sourceGapped, sourcePosition, targetGapped);\n    const dirAccessor = dir.x !== 0 ? 'x' : 'y';\n    const currDir = dir[dirAccessor];\n\n    let points: Point[] = [];\n    let centerX, centerY;\n    const [defaultCenterX, defaultCenterY] = getEdgeCenter({\n        sourceX: source[0],\n        sourceY: source[1],\n        targetX: target[0],\n        targetY: target[1]\n    });\n    // opposite handle positions, default case\n    if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {\n        centerX = defaultCenterX;\n        centerY = defaultCenterY;\n        //    --->\n        //    |\n        // >---\n        const verticalSplit: Point[] = [\n            [centerX, sourceGapped[1]],\n            [centerX, targetGapped[1]]\n        ];\n        //    |\n        //  ---\n        //  |\n        const horizontalSplit: Point[] = [\n            [sourceGapped[0], centerY],\n            [targetGapped[0], centerY]\n        ];\n        if (sourceDir[dirAccessor] === currDir) {\n            points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;\n        } else {\n            points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;\n        }\n    } else {\n        // sourceTarget means we take x from source and y from target, targetSource is the opposite\n        const sourceTarget: Point[] = [[sourceGapped[0], targetGapped[1]]];\n        const targetSource: Point[] = [[targetGapped[0], sourceGapped[1]]];\n        // this handles edges with same handle positions\n        if (dirAccessor === 'x') {\n            points = sourceDir.x === currDir ? targetSource : sourceTarget;\n        } else {\n            points = sourceDir.y === currDir ? sourceTarget : targetSource;\n        }\n\n        // these are conditions for handling mixed handle positions like right -> bottom for example\n        let flipSourceTarget;\n        if (sourcePosition !== targetPosition) {\n            const dirAccessorOpposite = dirAccessor === 'x' ? 1 : 0;\n            const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessor === 'x' ? 'y' : 'x'];\n            const sourceGtTargetOppo = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];\n            const sourceLtTargetOppo = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];\n            flipSourceTarget =\n                (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||\n                (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));\n\n            if (flipSourceTarget) {\n                points = dirAccessor === 'x' ? sourceTarget : targetSource;\n            }\n        }\n    }\n    return [source, sourceGapped, ...points, targetGapped, target];\n};\n\nexport const getDirection = (source: Point, sourcePosition = Direction.bottom, target: Point) => {\n    if (sourcePosition === Direction.left || sourcePosition === Direction.right) {\n        return source[0] < target[0] ? { x: 1, y: 0 } : { x: -1, y: 0 };\n    }\n    return source[1] < target[1] ? { x: 0, y: 1 } : { x: 0, y: -1 };\n};\n\nexport function getEdgeCenter({\n    sourceX,\n    sourceY,\n    targetX,\n    targetY\n}: {\n    sourceX: number;\n    sourceY: number;\n    targetX: number;\n    targetY: number;\n}): [number, number, number, number] {\n    const xOffset = Math.abs(targetX - sourceX) / 2;\n    const centerX = targetX < sourceX ? targetX + xOffset : targetX - xOffset;\n\n    const yOffset = Math.abs(targetY - sourceY) / 2;\n    const centerY = targetY < sourceY ? targetY + yOffset : targetY - yOffset;\n\n    return [centerX, centerY, xOffset, yOffset];\n}\n\nexport function getPointOnPolyline(points: Point[], ratio: number) {\n    const totalLength = calculatePolylineLength(points);\n    const targetDistance = totalLength * ratio;\n\n    let accumulatedDistance = 0;\n    for (let i = 0; i < points.length - 1; i++) {\n        const [x1, y1] = points[i];\n        const [x2, y2] = points[i + 1];\n        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);\n\n        if (accumulatedDistance + segmentLength >= targetDistance) {\n            const remainingDistance = targetDistance - accumulatedDistance;\n            const ratioInSegment = remainingDistance / segmentLength;\n\n            const targetX = x1 + (x2 - x1) * ratioInSegment;\n            const targetY = y1 + (y2 - y1) * ratioInSegment;\n            return [targetX, targetY];\n        }\n\n        accumulatedDistance += segmentLength;\n    }\n\n    return points[points.length - 1];\n}\n\nexport function calculatePolylineLength(points: Point[]) {\n    let length = 0;\n    for (let i = 0; i < points.length - 1; i++) {\n        const [x1, y1] = points[i];\n        const [x2, y2] = points[i + 1];\n        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);\n    }\n    return length;\n}\n\nexport function getRatioByPoint(points: Point[], point: Point) {\n    const totalLength = calculatePolylineLength(points);\n\n    let distance = 0;\n\n    for (let i = 0; i < points.length - 1; i++) {\n        const isOverlap = isPointOnLineSegment(point, points[i], points[i + 1]);\n\n        if (isOverlap) {\n            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);\n            return distance / totalLength;\n        } else {\n            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);\n        }\n    }\n    throw new Error('Cannot get ratio by point');\n}\n\nexport function isPointOnLineSegment(point: Point, startPoint: Point, endPoint: Point) {\n    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);\n    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);\n\n    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);\n\n    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;\n}\n\nexport const removeDuplicatePoints = (points: Point[]) => {\n    const newArray: Point[] = [];\n    points.forEach(point => {\n        const index = newArray.findIndex(otherPoint => {\n            return Point.isEquals(point, otherPoint);\n        });\n        if (index === -1) newArray.push(point);\n    });\n    return newArray;\n};\n"]}

package/fesm2022/plait-common.mjs

@@ -1,4 +1,4 @@
-import { createG, RectangleClient, drawRectangle, drawCircle, PlaitBoard, createForeignObject, updateForeignObject, getSelectedElements, PlaitElement, Transforms, PlaitPointerType, isMainPointer, transformPoint, toPoint, preventTouchMove, distanceBetweenPointAndPoint, PRESS_AND_MOVE_BUFFER, throttleRAF, handleTouchTarget, MERGING, Direction, hotkeys, PlaitContextService, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
+import { createG, RectangleClient, drawRectangle, drawCircle, PlaitBoard, createForeignObject, updateForeignObject, getSelectedElements, PlaitElement, Transforms, PlaitPointerType, isMainPointer, transformPoint, toPoint, preventTouchMove, distanceBetweenPointAndPoint, PRESS_AND_MOVE_BUFFER, throttleRAF, handleTouchTarget, MERGING, Direction, Point, hotkeys, PlaitContextService, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
 import { isKeyHotkey } from 'is-hotkey';
 import * as i0 from '@angular/core';
 import { Directive, Input } from '@angular/core';
@@ -7,6 +7,7 @@ const BASE = 4;
 const PRIMARY_COLOR = '#6698FF';
 const RESIZE_HANDLE_DIAMETER = 8;
 const WithTextPluginKey = 'plait-text-plugin-key';
+const DEFAULT_ROUTE_MARGIN = 30;
 
 var MediaKeys;
 (function (MediaKeys) {
@@ -614,6 +615,17 @@ function isPointOnLineSegment(point, startPoint, endPoint) {
     const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
     return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
 }
+const removeDuplicatePoints = (points) => {
+    const newArray = [];
+    points.forEach(point => {
+        const index = newArray.findIndex(otherPoint => {
+            return Point.isEquals(point, otherPoint);
+        });
+        if (index === -1)
+            newArray.push(point);
+    });
+    return newArray;
+};
 
 function isVirtualKey(e) {
     const isMod = e.ctrlKey || e.metaKey;
@@ -725,6 +737,376 @@ function getImageSize(file, defaultImageWidth) {
         };
     });
 }
+const BOARD_TO_ELEMENT_OF_FOCUSED_IMAGE = new WeakMap();
+const getElementOfFocusedImage = (board) => {
+    return BOARD_TO_ELEMENT_OF_FOCUSED_IMAGE.get(board);
+};
+const addElementOfFocusedImage = (board, element) => {
+    BOARD_TO_ELEMENT_OF_FOCUSED_IMAGE.set(board, element);
+};
+const removeElementOfFocusedImage = (board) => {
+    BOARD_TO_ELEMENT_OF_FOCUSED_IMAGE.delete(board);
+};
+
+class PriorityQueue {
+    constructor() {
+        this.list = [];
+    }
+    enqueue(item) {
+        this.list.push(item);
+        this.list = this.list.sort((item1, item2) => item1.priority - item2.priority);
+    }
+    dequeue() {
+        return this.list.shift();
+    }
+}
+
+class AStar {
+    constructor(graph) {
+        this.graph = graph;
+        this.cameFrom = new Map();
+    }
+    heuristic(a, b) {
+        return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
+    }
+    search(start, end, previousStart) {
+        const frontier = new PriorityQueue();
+        const startNode = this.graph.get(start);
+        this.cameFrom = new Map();
+        const costSoFar = new Map();
+        costSoFar.set(startNode, 0);
+        frontier.enqueue({ node: startNode, priority: 0 });
+        while (frontier.list.length > 0) {
+            var current = frontier.dequeue();
+            if (!current) {
+                throw new Error(`can't find current`);
+            }
+            const currentPoint = current.node.data;
+            if (currentPoint[0] === end[0] && currentPoint[1] === end[1]) {
+                break;
+            }
+            current.node.adjacentNodes.forEach(next => {
+                let newCost = costSoFar.get(current.node) + this.heuristic(next.data, current.node.data);
+                const previousNode = this.cameFrom.get(current.node);
+                // 拐点权重
+                const previousPoint = previousNode ? previousNode.data : previousStart;
+                const x = previousPoint[0] === current?.node.data[0] && previousPoint[0] === next.data[0];
+                const y = previousPoint[1] === current?.node.data[1] && previousPoint[1] === next.data[1];
+                if (!x && !y) {
+                    newCost = newCost + 1;
+                }
+                if (!costSoFar.has(next) || (costSoFar.get(next) && newCost < costSoFar.get(next))) {
+                    costSoFar.set(next, newCost);
+                    const priority = newCost + this.heuristic(next.data, end);
+                    frontier.enqueue({ node: next, priority });
+                    this.cameFrom.set(next, current.node);
+                }
+            });
+        }
+    }
+    getRoute(start, end) {
+        const result = [];
+        let temp = end;
+        while (temp[0] !== start[0] || temp[1] !== start[1]) {
+            const node = this.graph.get(temp);
+            const preNode = this.cameFrom.get(node);
+            result.unshift(preNode.data);
+            temp = preNode.data;
+        }
+        return result;
+    }
+}
+
+class PointNode {
+    constructor(data) {
+        this.data = data;
+        this.distance = Number.MAX_SAFE_INTEGER;
+        this.adjacentNodes = [];
+    }
+}
+class PointGraph {
+    constructor() {
+        this.index = {};
+    }
+    add(p) {
+        const x = p[0];
+        const y = p[1];
+        const xs = x.toString(), ys = y.toString();
+        if (!(xs in this.index)) {
+            this.index[xs] = {};
+        }
+        if (!(ys in this.index[xs])) {
+            this.index[xs][ys] = new PointNode(p);
+        }
+    }
+    connect(a, b) {
+        const nodeA = this.get(a);
+        const nodeB = this.get(b);
+        if (!nodeA || !nodeB) {
+            throw new Error(`A point was not found`);
+        }
+        nodeA.adjacentNodes.push(nodeB);
+    }
+    has(p) {
+        const x = p[0];
+        const y = p[1];
+        const xs = x.toString(), ys = y.toString();
+        return xs in this.index && ys in this.index[xs];
+    }
+    get(p) {
+        const x = p[0];
+        const y = p[1];
+        const xs = x.toString(), ys = y.toString();
+        if (xs in this.index && ys in this.index[xs]) {
+            return this.index[xs][ys];
+        }
+        return null;
+    }
+}
+
+const generateElbowLineRoute = (options) => {
+    const { nextSourcePoint, nextTargetPoint } = options;
+    const points = getGraphPoints(options);
+    const graph = createGraph(points);
+    const aStar = new AStar(graph);
+    aStar.search(nextSourcePoint, nextTargetPoint, options.sourcePoint);
+    let route = aStar.getRoute(nextSourcePoint, nextTargetPoint);
+    route = [options.sourcePoint, ...route, nextTargetPoint, options.targetPoint];
+    const isHitX = RectangleClient.isHitX(options.sourceOuterRectangle, options.targetOuterRectangle);
+    const isHitY = RectangleClient.isHitY(options.sourceOuterRectangle, options.targetOuterRectangle);
+    const xAxis = isHitX ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, false);
+    const yAxis = isHitY ? undefined : RectangleClient.getGapCenter(options.sourceOuterRectangle, options.targetOuterRectangle, true);
+    route = routeAdjust(route, { xAxis, yAxis, sourceRectangle: options.sourceRectangle, targetRectangle: options.targetRectangle });
+    return route;
+};
+const routeAdjust = (path, options) => {
+    // 基于 middleX/middleY 中线纠正 path
+    // 1. 找垂直/水平的线段
+    // 2. 找到和middleX/middleY相交的点
+    // 3. 基于垂直/水平的线段分别和相交点构建矩形
+    // 4. 判断矩形相交
+    // 5. 处理 path
+    const { sourceRectangle, targetRectangle, xAxis, yAxis } = options;
+    if (xAxis !== undefined) {
+        const optionsX = getAdjustOptions(path, xAxis, true);
+        const resultX = optionsX.pointOfHit &&
+            adjust(path, { parallelPaths: optionsX.parallelPaths, pointOfHit: optionsX.pointOfHit, sourceRectangle, targetRectangle });
+        if (resultX) {
+            path = resultX;
+        }
+    }
+    if (yAxis !== undefined) {
+        const optionsY = getAdjustOptions(path, yAxis, false);
+        const resultY = optionsY.pointOfHit &&
+            adjust(path, { parallelPaths: optionsY.parallelPaths, pointOfHit: optionsY.pointOfHit, sourceRectangle, targetRectangle });
+        if (resultY) {
+            path = resultY;
+        }
+    }
+    return path;
+};
+const adjust = (route, options) => {
+    const { parallelPaths, pointOfHit, sourceRectangle, targetRectangle } = options;
+    let result = null;
+    parallelPaths.forEach(parallelPath => {
+        // 构建矩形
+        const tempRect = RectangleClient.toRectangleClient([pointOfHit, parallelPath[0], parallelPath[1]]);
+        if (!RectangleClient.isHit(tempRect, sourceRectangle) && !RectangleClient.isHit(tempRect, targetRectangle)) {
+            const getCornerCount = (path) => {
+                let cornerCount = 0;
+                for (let index = 1; index < path.length - 1; index++) {
+                    const pre = path[index - 1];
+                    const current = path[index];
+                    const next = path[index + 1];
+                    if (pre &&
+                        current &&
+                        next &&
+                        !((Math.floor(current[0]) === Math.floor(pre[0]) && Math.floor(current[0]) === Math.floor(next[0])) ||
+                            (Math.floor(current[1]) === Math.floor(pre[1]) && Math.floor(current[1]) === Math.floor(next[1])))) {
+                        cornerCount++;
+                    }
+                }
+                return cornerCount;
+            };
+            const tempCorners = RectangleClient.getCornerPoints(tempRect);
+            const indexRangeInPath = [];
+            const indexRangeInCorner = [];
+            route.forEach((point, index) => {
+                const cornerResult = tempCorners.findIndex(corner => Math.floor(corner[0]) === Math.floor(point[0]) && Math.floor(corner[1]) === Math.floor(point[1]));
+                if (cornerResult !== -1) {
+                    indexRangeInPath.push(index);
+                    indexRangeInCorner.push(cornerResult);
+                }
+            });
+            const newPath = [...route];
+            const missCorner = tempCorners.find((c, index) => !indexRangeInCorner.includes(index));
+            const removeLength = Math.abs(indexRangeInPath[0] - indexRangeInPath[indexRangeInPath.length - 1]) + 1;
+            newPath.splice(indexRangeInPath[0] + 1, removeLength - 2, missCorner);
+            const cornerCount = getCornerCount([...route]);
+            const newCornerCount = getCornerCount([...newPath]);
+            if (newCornerCount <= cornerCount) {
+                result = newPath;
+            }
+        }
+        return null;
+    });
+    return result;
+};
+const getAdjustOptions = (path, middle, isHorizontal) => {
+    const parallelPaths = [];
+    let start = null;
+    let pointOfHit = null;
+    const axis = isHorizontal ? 0 : 1;
+    for (let index = 0; index < path.length; index++) {
+        const previous = path[index - 1];
+        const current = path[index];
+        if (start === null && previous && previous[axis] === current[axis]) {
+            start = previous;
+        }
+        if (start !== null) {
+            if (previous[axis] !== current[axis]) {
+                parallelPaths.push([start, previous]);
+                start = null;
+            }
+        }
+        if (current[axis] === middle) {
+            pointOfHit = current;
+        }
+    }
+    if (start) {
+        parallelPaths.push([start, path[path.length - 1]]);
+    }
+    return { pointOfHit, parallelPaths };
+};
+const getGraphPoints = (options) => {
+    const { nextSourcePoint, nextTargetPoint, sourceOuterRectangle, targetOuterRectangle } = options;
+    const x = [];
+    const y = [];
+    let result = [];
+    [sourceOuterRectangle, targetOuterRectangle].forEach(rectangle => {
+        x.push(rectangle.x, rectangle.x + rectangle.width / 2, rectangle.x + rectangle.width);
+        y.push(rectangle.y, rectangle.y + rectangle.height / 2, rectangle.y + rectangle.height);
+    });
+    const rectanglesX = [
+        sourceOuterRectangle.x,
+        sourceOuterRectangle.x + sourceOuterRectangle.width,
+        targetOuterRectangle.x,
+        targetOuterRectangle.x + targetOuterRectangle.width
+    ].sort((a, b) => a - b);
+    x.push((rectanglesX[1] + rectanglesX[2]) / 2, nextSourcePoint[0], nextTargetPoint[0]);
+    const rectanglesY = [
+        sourceOuterRectangle.y,
+        sourceOuterRectangle.y + sourceOuterRectangle.height,
+        targetOuterRectangle.y,
+        targetOuterRectangle.y + targetOuterRectangle.height
+    ].sort((a, b) => a - b);
+    y.push((rectanglesY[1] + rectanglesY[2]) / 2, nextSourcePoint[1], nextTargetPoint[1]);
+    for (let i = 0; i < x.length; i++) {
+        for (let j = 0; j < y.length; j++) {
+            const point = [x[i], y[j]];
+            const isInSource = RectangleClient.isPointInRectangle(sourceOuterRectangle, point);
+            const isInTarget = RectangleClient.isPointInRectangle(targetOuterRectangle, point);
+            if (!isInSource && !isInTarget) {
+                result.push(point);
+            }
+        }
+    }
+    result = removeDuplicatePoints(result).filter(point => {
+        const isInSource = RectangleClient.isPointInRectangle(sourceOuterRectangle, point);
+        const isInTarget = RectangleClient.isPointInRectangle(targetOuterRectangle, point);
+        return !isInSource && !isInTarget;
+    });
+    return result;
+};
+const createGraph = (points) => {
+    const graph = new PointGraph();
+    const Xs = [];
+    const Ys = [];
+    points.forEach(p => {
+        const x = p[0], y = p[1];
+        if (Xs.indexOf(x) < 0)
+            Xs.push(x);
+        if (Ys.indexOf(y) < 0)
+            Ys.push(y);
+        graph.add(p);
+    });
+    Xs.sort((a, b) => a - b);
+    Ys.sort((a, b) => a - b);
+    const inHotIndex = (p) => graph.has(p);
+    for (let i = 0; i < Xs.length; i++) {
+        for (let j = 0; j < Ys.length; j++) {
+            const point = [Xs[i], Ys[j]];
+            if (!inHotIndex(point))
+                continue;
+            if (i > 0) {
+                const otherPoint = [Xs[i - 1], Ys[j]];
+                if (inHotIndex(otherPoint)) {
+                    graph.connect(otherPoint, point);
+                    graph.connect(point, otherPoint);
+                }
+            }
+            if (j > 0) {
+                const otherPoint = [Xs[i], Ys[j - 1]];
+                if (inHotIndex(otherPoint)) {
+                    graph.connect(otherPoint, point);
+                    graph.connect(point, otherPoint);
+                }
+            }
+        }
+    }
+    return graph;
+};
+const reduceRouteMargin = (sourceRectangle, targetRectangle) => {
+    const defaultOffset = DEFAULT_ROUTE_MARGIN;
+    let sourceOffset = new Array(4).fill(defaultOffset);
+    let targetOffset = new Array(4).fill(defaultOffset);
+    const sourceOuterRectangle = RectangleClient.inflate(sourceRectangle, defaultOffset * 2);
+    const targetOuterRectangle = RectangleClient.inflate(targetRectangle, defaultOffset * 2);
+    const isHit = RectangleClient.isHit(sourceOuterRectangle, targetOuterRectangle);
+    if (isHit) {
+        const leftToRight = sourceRectangle.x - (targetRectangle.x + targetRectangle.width);
+        const rightToLeft = targetRectangle.x - (sourceRectangle.x + sourceRectangle.width);
+        if (leftToRight > 0 && leftToRight < defaultOffset * 2) {
+            const offset = leftToRight / 2;
+            sourceOffset[3] = offset;
+            targetOffset[1] = offset;
+        }
+        if (rightToLeft > 0 && rightToLeft < defaultOffset * 2) {
+            const offset = rightToLeft / 2;
+            targetOffset[3] = offset;
+            sourceOffset[1] = offset;
+        }
+        const topToBottom = sourceRectangle.y - (targetRectangle.y + targetRectangle.height);
+        const bottomToTop = targetRectangle.y - (sourceRectangle.y + sourceRectangle.height);
+        if (topToBottom > 0 && topToBottom < defaultOffset * 2) {
+            const offset = topToBottom / 2;
+            sourceOffset[0] = offset;
+            targetOffset[2] = offset;
+        }
+        if (bottomToTop > 0 && bottomToTop < defaultOffset * 2) {
+            const offset = bottomToTop / 2;
+            sourceOffset[2] = offset;
+            targetOffset[0] = offset;
+        }
+    }
+    return { sourceOffset, targetOffset };
+};
+const getNextPoint = (point, outerRectangle, direction) => {
+    switch (direction) {
+        case Direction.top: {
+            return [point[0], outerRectangle.y];
+        }
+        case Direction.bottom: {
+            return [point[0], outerRectangle.y + outerRectangle.height];
+        }
+        case Direction.right: {
+            return [outerRectangle.x + outerRectangle.width, point[1]];
+        }
+        default: {
+            return [outerRectangle.x, point[1]];
+        }
+    }
+};
 
 class CommonPluginElement extends PlaitPluginElementComponent {
     constructor() {
@@ -836,5 +1218,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ActiveGenerator, BASE, BoardCreationMode, CommonPluginElement, Generator, IS_RESIZING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ResizeCursorClass, ResizeHandle, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addResizing, buildImage, calculatePolylineLength, getCreationMode, getDirection, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getEdgeCenter, getFactorByPoints, getOppositeDirection, getPointByVector, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleByPoints, getRectangleResizeHandleRefs, getTextEditors, getTextManages, hasAfterDraw, isDelete, isDndMode, isDrawingMode, isEnterHotkey, isExpandHotkey, isPointOnLineSegment, isResizing, isResizingByCondition, isSpaceHotkey, isTabHotkey, isVirtualKey, normalizeShapePoints, removeResizing, rotateVectorAnti90, selectImage, setCreationMode, withResize };
+export { AStar, ActiveGenerator, BASE, BoardCreationMode, CommonPluginElement, DEFAULT_ROUTE_MARGIN, Generator, IS_RESIZING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ResizeCursorClass, ResizeHandle, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, buildImage, calculatePolylineLength, createGraph, generateElbowLineRoute, getCreationMode, getDirection, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getEdgeCenter, getElementOfFocusedImage, getFactorByPoints, getGraphPoints, getNextPoint, getOppositeDirection, getPointByVector, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleByPoints, getRectangleResizeHandleRefs, getTextEditors, getTextManages, hasAfterDraw, isDelete, isDndMode, isDrawingMode, isEnterHotkey, isExpandHotkey, isPointOnLineSegment, isResizing, isResizingByCondition, isSpaceHotkey, isTabHotkey, isVirtualKey, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, rotateVectorAnti90, selectImage, setCreationMode, withResize };
 //# sourceMappingURL=plait-common.mjs.map