@plait/draw 0.50.1 → 0.51.1

package/esm2022/utils/line/line-resize.mjs

@@ -0,0 +1,313 @@
+import { generateElbowLineRoute, removeDuplicatePoints, simplifyOrthogonalPoints } from '@plait/common';
+import { Point, RectangleClient } from '@plait/core';
+import { LINE_ALIGN_TOLERANCE } from '../../constants/line';
+import { getElbowLineRouteOptions, getLineHandleRefPair } from './line-common';
+export const alignPoints = (basePoint, movingPoint) => {
+    const newPoint = [...movingPoint];
+    if (Point.isVertical(newPoint, basePoint, LINE_ALIGN_TOLERANCE)) {
+        newPoint[0] = basePoint[0];
+    }
+    if (Point.isHorizontal(newPoint, basePoint, LINE_ALIGN_TOLERANCE)) {
+        newPoint[1] = basePoint[1];
+    }
+    return newPoint;
+};
+export function getResizedPreviousAndNextPoint(nextRenderPoints, sourcePoint, targetPoint, handleIndex) {
+    const referencePoint = {
+        previous: null,
+        next: null
+    };
+    const startPoint = nextRenderPoints[handleIndex];
+    const endPoint = nextRenderPoints[handleIndex + 1];
+    const isHorizontal = Point.isHorizontal(startPoint, endPoint);
+    const isVertical = Point.isVertical(startPoint, endPoint);
+    const previousPoint = nextRenderPoints[handleIndex - 1] ?? nextRenderPoints[0];
+    const beforePreviousPoint = nextRenderPoints[handleIndex - 2] ?? sourcePoint;
+    if ((isHorizontal && Point.isHorizontal(beforePreviousPoint, previousPoint)) ||
+        (isVertical && Point.isVertical(beforePreviousPoint, previousPoint))) {
+        referencePoint.previous = previousPoint;
+    }
+    const nextPoint = nextRenderPoints[handleIndex + 2] ?? nextRenderPoints[nextRenderPoints.length - 1];
+    const afterNextPoint = nextRenderPoints[handleIndex + 3] ?? targetPoint;
+    if ((isHorizontal && Point.isHorizontal(nextPoint, afterNextPoint)) || (isVertical && Point.isVertical(nextPoint, afterNextPoint))) {
+        referencePoint.next = nextPoint;
+    }
+    return referencePoint;
+}
+export function alignElbowSegment(startKeyPoint, endKeyPoint, resizeState, resizedPreviousAndNextPoint) {
+    let newStartPoint = startKeyPoint;
+    let newEndPoint = endKeyPoint;
+    if (Point.isHorizontal(startKeyPoint, endKeyPoint)) {
+        const offsetY = Point.getOffsetY(resizeState.startPoint, resizeState.endPoint);
+        let pointY = startKeyPoint[1] + offsetY;
+        if (resizedPreviousAndNextPoint.previous && Math.abs(resizedPreviousAndNextPoint.previous[1] - pointY) < LINE_ALIGN_TOLERANCE) {
+            pointY = resizedPreviousAndNextPoint.previous[1];
+        }
+        else if (resizedPreviousAndNextPoint.next && Math.abs(resizedPreviousAndNextPoint.next[1] - pointY) < LINE_ALIGN_TOLERANCE) {
+            pointY = resizedPreviousAndNextPoint.next[1];
+        }
+        newStartPoint = [startKeyPoint[0], pointY];
+        newEndPoint = [endKeyPoint[0], pointY];
+    }
+    if (Point.isVertical(startKeyPoint, endKeyPoint)) {
+        const offsetX = Point.getOffsetX(resizeState.startPoint, resizeState.endPoint);
+        let pointX = startKeyPoint[0] + offsetX;
+        if (resizedPreviousAndNextPoint.previous && Math.abs(resizedPreviousAndNextPoint.previous[0] - pointX) < LINE_ALIGN_TOLERANCE) {
+            pointX = resizedPreviousAndNextPoint.previous[0];
+        }
+        else if (resizedPreviousAndNextPoint.next && Math.abs(resizedPreviousAndNextPoint.next[0] - pointX) < LINE_ALIGN_TOLERANCE) {
+            pointX = resizedPreviousAndNextPoint.next[0];
+        }
+        newStartPoint = [pointX, startKeyPoint[1]];
+        newEndPoint = [pointX, endKeyPoint[1]];
+    }
+    return [newStartPoint, newEndPoint];
+}
+export function getIndexAndDeleteCountByKeyPoint(board, element, dataPoints, nextRenderPoints, handleIndex) {
+    let index = null;
+    let deleteCount = null;
+    const startKeyPoint = nextRenderPoints[handleIndex];
+    const endKeyPoint = nextRenderPoints[handleIndex + 1];
+    if (!startKeyPoint || !endKeyPoint) {
+        return {
+            index,
+            deleteCount
+        };
+    }
+    const midDataPoints = dataPoints.slice(1, -1);
+    const startIndex = midDataPoints.findIndex(item => Point.isEquals(item, startKeyPoint));
+    const endIndex = midDataPoints.findIndex(item => Point.isEquals(item, endKeyPoint));
+    if (Math.max(startIndex, endIndex) > -1) {
+        if (startIndex > -1 && endIndex > -1) {
+            return {
+                index: startIndex,
+                deleteCount: 2
+            };
+        }
+        if (startIndex > -1 && endIndex === -1) {
+            const isReplace = startIndex < midDataPoints.length - 1 &&
+                Point.isAlign([midDataPoints[startIndex], midDataPoints[startIndex + 1], startKeyPoint, endKeyPoint]);
+            if (isReplace) {
+                return {
+                    index: startIndex,
+                    deleteCount: 2
+                };
+            }
+            return {
+                index: startIndex,
+                deleteCount: 1
+            };
+        }
+        if (startIndex === -1 && endIndex > -1) {
+            const isReplace = endIndex > 0 && Point.isAlign([midDataPoints[endIndex], midDataPoints[endIndex - 1], startKeyPoint, endKeyPoint]);
+            if (isReplace) {
+                return {
+                    index: endIndex - 1,
+                    deleteCount: 2
+                };
+            }
+            return {
+                index: endIndex,
+                deleteCount: 1
+            };
+        }
+    }
+    else {
+        for (let i = 0; i < midDataPoints.length - 1; i++) {
+            const currentPoint = midDataPoints[i];
+            const nextPoint = midDataPoints[i + 1];
+            if (Point.isAlign([currentPoint, nextPoint, startKeyPoint, endKeyPoint])) {
+                index = i;
+                deleteCount = 2;
+                break;
+            }
+            if (Point.isAlign([currentPoint, nextPoint, startKeyPoint])) {
+                index = Math.min(i + 1, midDataPoints.length - 1);
+                deleteCount = 1;
+                break;
+            }
+            if (Point.isAlign([currentPoint, nextPoint, endKeyPoint])) {
+                index = Math.max(i - 1, 0);
+                deleteCount = 1;
+                break;
+            }
+        }
+    }
+    if (index === null) {
+        deleteCount = 0;
+        if (midDataPoints.length > 0) {
+            const handleRefPair = getLineHandleRefPair(board, element);
+            const params = getElbowLineRouteOptions(board, element, handleRefPair);
+            const keyPoints = removeDuplicatePoints(generateElbowLineRoute(params));
+            const nextKeyPoints = simplifyOrthogonalPoints(keyPoints.slice(1, keyPoints.length - 1));
+            const nextDataPoints = [nextRenderPoints[0], ...midDataPoints, nextRenderPoints[nextRenderPoints.length - 1]];
+            const mirrorDataPoints = getMirrorDataPoints(board, nextDataPoints, nextKeyPoints, params);
+            for (let i = handleIndex - 1; i >= 0; i--) {
+                const previousIndex = mirrorDataPoints.slice(1, -1).findIndex(item => Point.isEquals(item, nextRenderPoints[i]));
+                if (previousIndex > -1) {
+                    index = previousIndex + 1;
+                    break;
+                }
+            }
+            if (index === null) {
+                index = 0;
+                // When renderPoints is a straight line and dataPoints are not on the line,
+                // the default 'deleteCount' is set to midDataPoints.length.
+                if (Point.isAlign(nextRenderPoints)) {
+                    deleteCount = midDataPoints.length;
+                }
+            }
+        }
+        else {
+            index = 0;
+        }
+    }
+    return {
+        index,
+        deleteCount
+    };
+}
+export function getMirrorDataPoints(board, nextDataPoints, nextKeyPoints, params) {
+    for (let index = 1; index < nextDataPoints.length - 2; index++) {
+        adjustByCustomPointStartIndex(board, index, nextDataPoints, nextKeyPoints, params);
+    }
+    return nextDataPoints;
+}
+/**
+ * adjust based parallel segment
+ */
+const adjustByCustomPointStartIndex = (board, customPointStartIndex, nextDataPoints, nextKeyPoints, params) => {
+    const beforePoint = nextDataPoints[customPointStartIndex - 1];
+    const startPoint = nextDataPoints[customPointStartIndex];
+    const endPoint = nextDataPoints[customPointStartIndex + 1];
+    const afterPoint = nextDataPoints[customPointStartIndex + 2];
+    const beforeSegment = [beforePoint, startPoint];
+    const afterSegment = [endPoint, afterPoint];
+    const isStraightWithBefore = Point.isAlign(beforeSegment);
+    const isStraightWithAfter = Point.isAlign(afterSegment);
+    let isAdjustStart = false;
+    let isAdjustEnd = false;
+    if (!isStraightWithBefore || !isStraightWithAfter) {
+        const midKeyPointsWithBefore = getMidKeyPoints(nextKeyPoints, beforeSegment[0], beforeSegment[1]);
+        const midKeyPointsWithAfter = getMidKeyPoints(nextKeyPoints, afterSegment[0], afterSegment[1]);
+        const hasMidKeyPoints = midKeyPointsWithBefore.length > 0 && midKeyPointsWithAfter.length > 0;
+        isAdjustStart = !isStraightWithBefore && !hasMidKeyPoints;
+        isAdjustEnd = !isStraightWithAfter && !hasMidKeyPoints;
+    }
+    if (isAdjustStart || isAdjustEnd) {
+        const parallelSegment = [startPoint, endPoint];
+        const parallelSegments = findOrthogonalParallelSegments(parallelSegment, nextKeyPoints);
+        const mirrorSegments = findMirrorSegments(board, parallelSegment, parallelSegments, params.sourceRectangle, params.targetRectangle);
+        if (mirrorSegments.length === 1) {
+            const mirrorSegment = mirrorSegments[0];
+            if (isAdjustStart) {
+                nextDataPoints.splice(customPointStartIndex, 1, mirrorSegment[0]);
+            }
+            if (isAdjustEnd) {
+                nextDataPoints.splice(customPointStartIndex + 1, 1, mirrorSegment[1]);
+            }
+        }
+        else {
+            const isHorizontal = Point.isHorizontal(startPoint, endPoint);
+            const adjustIndex = isHorizontal ? 0 : 1;
+            if (isAdjustStart) {
+                const newStartPoint = [startPoint[0], startPoint[1]];
+                newStartPoint[adjustIndex] = beforePoint[adjustIndex];
+                nextDataPoints.splice(customPointStartIndex, 1, newStartPoint);
+            }
+            if (isAdjustEnd) {
+                const newEndPoint = [endPoint[0], endPoint[1]];
+                newEndPoint[adjustIndex] = afterPoint[adjustIndex];
+                nextDataPoints.splice(customPointStartIndex + 1, 1, newEndPoint);
+            }
+        }
+    }
+};
+export function isUpdatedHandleIndex(board, element, dataPoints, nextRenderPoints, handleIndex) {
+    const { deleteCount } = getIndexAndDeleteCountByKeyPoint(board, element, dataPoints, nextRenderPoints, handleIndex);
+    if (deleteCount !== null && deleteCount > 1) {
+        return true;
+    }
+    return false;
+}
+export function getMidKeyPoints(simplifiedNextKeyPoints, startPoint, endPoint) {
+    let midElbowPoints = [];
+    let startPointIndex = -1;
+    let endPointIndex = -1;
+    for (let i = 0; i < simplifiedNextKeyPoints.length; i++) {
+        if (Point.isAlign([simplifiedNextKeyPoints[i], startPoint])) {
+            startPointIndex = i;
+        }
+        if (startPointIndex > -1 && Point.isAlign([simplifiedNextKeyPoints[i], endPoint])) {
+            endPointIndex = i;
+            break;
+        }
+    }
+    if (startPointIndex > -1 && endPointIndex > -1) {
+        midElbowPoints = simplifiedNextKeyPoints.slice(startPointIndex, endPointIndex + 1);
+    }
+    return midElbowPoints;
+}
+function findOrthogonalParallelSegments(segment, keyPoints) {
+    const isHorizontalSegment = Point.isHorizontal(segment[0], segment[1]);
+    const parallelSegments = [];
+    for (let i = 0; i < keyPoints.length - 1; i++) {
+        const current = keyPoints[i];
+        const next = keyPoints[i + 1];
+        const isHorizontal = Point.isHorizontal(current, next, 0.1);
+        if (isHorizontalSegment && isHorizontal) {
+            parallelSegments.push([current, next]);
+        }
+        if (!isHorizontalSegment && !isHorizontal) {
+            parallelSegments.push([current, next]);
+        }
+    }
+    return parallelSegments;
+}
+function findMirrorSegments(board, segment, parallelSegments, sourceRectangle, targetRectangle) {
+    const mirrorSegments = [];
+    for (let index = 0; index < parallelSegments.length; index++) {
+        const parallelPath = parallelSegments[index];
+        const startPoint = [segment[0][0], segment[0][1]];
+        const endPoint = [segment[1][0], segment[1][1]];
+        const isHorizontal = Point.isHorizontal(startPoint, endPoint);
+        const adjustDataIndex = isHorizontal ? 0 : 1;
+        startPoint[adjustDataIndex] = parallelPath[0][adjustDataIndex];
+        endPoint[adjustDataIndex] = parallelPath[1][adjustDataIndex];
+        const fakeRectangle = RectangleClient.getRectangleByPoints([startPoint, endPoint, ...parallelPath]);
+        const isValid = !RectangleClient.isHit(fakeRectangle, sourceRectangle) && !RectangleClient.isHit(fakeRectangle, targetRectangle);
+        if (isValid) {
+            mirrorSegments.push([startPoint, endPoint]);
+            // const fakeRectangleG = PlaitBoard.getRoughSVG(board).rectangle(
+            //     fakeRectangle.x,
+            //     fakeRectangle.y,
+            //     fakeRectangle.width,
+            //     fakeRectangle.height,
+            //     { stroke: 'blue' }
+            // );
+            // PlaitBoard.getElementActiveHost(board).append(fakeRectangleG);
+        }
+    }
+    return mirrorSegments;
+}
+export const hasIllegalElbowPoint = (midDataPoints) => {
+    if (midDataPoints.length === 1) {
+        return true;
+    }
+    return midDataPoints.some((item, index) => {
+        const beforePoint = midDataPoints[index - 1];
+        const afterPoint = midDataPoints[index + 1];
+        const beforeSegment = beforePoint && [beforePoint, item];
+        const afterSegment = afterPoint && [item, afterPoint];
+        const isStraightWithBefore = beforeSegment && Point.isAlign(beforeSegment);
+        const isStraightWithAfter = afterSegment && Point.isAlign(afterSegment);
+        if (index === 0) {
+            return !isStraightWithAfter;
+        }
+        if (index === midDataPoints.length - 1) {
+            return !isStraightWithBefore;
+        }
+        return !isStraightWithBefore && !isStraightWithAfter;
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-resize.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/line/line-resize.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElbowLineRouteOptions, ResizeState, generateElbowLineRoute, removeDuplicatePoints, simplifyOrthogonalPoints } from '@plait/common';\nimport { PlaitBoard, Point, RectangleClient, drawCircle } from '@plait/core';\nimport { LINE_ALIGN_TOLERANCE } from '../../constants/line';\nimport { getElbowLineRouteOptions, getLineHandleRefPair } from './line-common';\nimport { PlaitLine } from '../../interfaces';\n\nexport const alignPoints = (basePoint: Point, movingPoint: Point) => {\n    const newPoint: Point = [...movingPoint];\n    if (Point.isVertical(newPoint, basePoint, LINE_ALIGN_TOLERANCE)) {\n        newPoint[0] = basePoint[0];\n    }\n    if (Point.isHorizontal(newPoint, basePoint, LINE_ALIGN_TOLERANCE)) {\n        newPoint[1] = basePoint[1];\n    }\n    return newPoint;\n};\n\nexport function getResizedPreviousAndNextPoint(nextRenderPoints: Point[], sourcePoint: Point, targetPoint: Point, handleIndex: number) {\n    const referencePoint: { previous: Point | null; next: Point | null } = {\n        previous: null,\n        next: null\n    };\n\n    const startPoint = nextRenderPoints[handleIndex];\n    const endPoint = nextRenderPoints[handleIndex + 1];\n    const isHorizontal = Point.isHorizontal(startPoint, endPoint);\n    const isVertical = Point.isVertical(startPoint, endPoint);\n    const previousPoint = nextRenderPoints[handleIndex - 1] ?? nextRenderPoints[0];\n    const beforePreviousPoint = nextRenderPoints[handleIndex - 2] ?? sourcePoint;\n    if (\n        (isHorizontal && Point.isHorizontal(beforePreviousPoint, previousPoint)) ||\n        (isVertical && Point.isVertical(beforePreviousPoint, previousPoint))\n    ) {\n        referencePoint.previous = previousPoint;\n    }\n\n    const nextPoint = nextRenderPoints[handleIndex + 2] ?? nextRenderPoints[nextRenderPoints.length - 1];\n    const afterNextPoint = nextRenderPoints[handleIndex + 3] ?? targetPoint;\n    if ((isHorizontal && Point.isHorizontal(nextPoint, afterNextPoint)) || (isVertical && Point.isVertical(nextPoint, afterNextPoint))) {\n        referencePoint.next = nextPoint;\n    }\n    return referencePoint;\n}\n\nexport function alignElbowSegment(\n    startKeyPoint: Point,\n    endKeyPoint: Point,\n    resizeState: ResizeState,\n    resizedPreviousAndNextPoint: { previous: Point | null; next: Point | null }\n) {\n    let newStartPoint = startKeyPoint;\n    let newEndPoint = endKeyPoint;\n    if (Point.isHorizontal(startKeyPoint, endKeyPoint)) {\n        const offsetY = Point.getOffsetY(resizeState.startPoint, resizeState.endPoint);\n        let pointY = startKeyPoint[1] + offsetY;\n        if (resizedPreviousAndNextPoint.previous && Math.abs(resizedPreviousAndNextPoint.previous[1] - pointY) < LINE_ALIGN_TOLERANCE) {\n            pointY = resizedPreviousAndNextPoint.previous[1];\n        } else if (resizedPreviousAndNextPoint.next && Math.abs(resizedPreviousAndNextPoint.next[1] - pointY) < LINE_ALIGN_TOLERANCE) {\n            pointY = resizedPreviousAndNextPoint.next[1];\n        }\n        newStartPoint = [startKeyPoint[0], pointY];\n        newEndPoint = [endKeyPoint[0], pointY];\n    }\n    if (Point.isVertical(startKeyPoint, endKeyPoint)) {\n        const offsetX = Point.getOffsetX(resizeState.startPoint, resizeState.endPoint);\n        let pointX = startKeyPoint[0] + offsetX;\n        if (resizedPreviousAndNextPoint.previous && Math.abs(resizedPreviousAndNextPoint.previous[0] - pointX) < LINE_ALIGN_TOLERANCE) {\n            pointX = resizedPreviousAndNextPoint.previous[0];\n        } else if (resizedPreviousAndNextPoint.next && Math.abs(resizedPreviousAndNextPoint.next[0] - pointX) < LINE_ALIGN_TOLERANCE) {\n            pointX = resizedPreviousAndNextPoint.next[0];\n        }\n        newStartPoint = [pointX, startKeyPoint[1]];\n        newEndPoint = [pointX, endKeyPoint[1]];\n    }\n    return [newStartPoint, newEndPoint];\n}\n\nexport function getIndexAndDeleteCountByKeyPoint(\n    board: PlaitBoard,\n    element: PlaitLine,\n    dataPoints: Point[],\n    nextRenderPoints: Point[],\n    handleIndex: number\n) {\n    let index: number | null = null;\n    let deleteCount: number | null = null;\n\n    const startKeyPoint = nextRenderPoints[handleIndex];\n    const endKeyPoint = nextRenderPoints[handleIndex + 1];\n    if (!startKeyPoint || !endKeyPoint) {\n        return {\n            index,\n            deleteCount\n        };\n    }\n    const midDataPoints = dataPoints.slice(1, -1);\n    const startIndex = midDataPoints.findIndex(item => Point.isEquals(item, startKeyPoint));\n    const endIndex = midDataPoints.findIndex(item => Point.isEquals(item, endKeyPoint));\n\n    if (Math.max(startIndex, endIndex) > -1) {\n        if (startIndex > -1 && endIndex > -1) {\n            return {\n                index: startIndex,\n                deleteCount: 2\n            };\n        }\n        if (startIndex > -1 && endIndex === -1) {\n            const isReplace =\n                startIndex < midDataPoints.length - 1 &&\n                Point.isAlign([midDataPoints[startIndex], midDataPoints[startIndex + 1], startKeyPoint, endKeyPoint]);\n            if (isReplace) {\n                return {\n                    index: startIndex,\n                    deleteCount: 2\n                };\n            }\n            return {\n                index: startIndex,\n                deleteCount: 1\n            };\n        }\n        if (startIndex === -1 && endIndex > -1) {\n            const isReplace =\n                endIndex > 0 && Point.isAlign([midDataPoints[endIndex], midDataPoints[endIndex - 1], startKeyPoint, endKeyPoint]);\n            if (isReplace) {\n                return {\n                    index: endIndex - 1,\n                    deleteCount: 2\n                };\n            }\n            return {\n                index: endIndex,\n                deleteCount: 1\n            };\n        }\n    } else {\n        for (let i = 0; i < midDataPoints.length - 1; i++) {\n            const currentPoint = midDataPoints[i];\n            const nextPoint = midDataPoints[i + 1];\n            if (Point.isAlign([currentPoint, nextPoint, startKeyPoint, endKeyPoint])) {\n                index = i;\n                deleteCount = 2;\n                break;\n            }\n            if (Point.isAlign([currentPoint, nextPoint, startKeyPoint])) {\n                index = Math.min(i + 1, midDataPoints.length - 1);\n                deleteCount = 1;\n                break;\n            }\n            if (Point.isAlign([currentPoint, nextPoint, endKeyPoint])) {\n                index = Math.max(i - 1, 0);\n                deleteCount = 1;\n                break;\n            }\n        }\n    }\n    if (index === null) {\n        deleteCount = 0;\n        if (midDataPoints.length > 0) {\n            const handleRefPair = getLineHandleRefPair(board, element);\n            const params = getElbowLineRouteOptions(board, element, handleRefPair);\n            const keyPoints = removeDuplicatePoints(generateElbowLineRoute(params));\n            const nextKeyPoints = simplifyOrthogonalPoints(keyPoints.slice(1, keyPoints.length - 1));\n            const nextDataPoints = [nextRenderPoints[0], ...midDataPoints, nextRenderPoints[nextRenderPoints.length - 1]];\n            const mirrorDataPoints = getMirrorDataPoints(board, nextDataPoints, nextKeyPoints, params);\n            for (let i = handleIndex - 1; i >= 0; i--) {\n                const previousIndex = mirrorDataPoints.slice(1, -1).findIndex(item => Point.isEquals(item, nextRenderPoints[i]));\n                if (previousIndex > -1) {\n                    index = previousIndex + 1;\n                    break;\n                }\n            }\n            if (index === null) {\n                index = 0;\n                // When renderPoints is a straight line and dataPoints are not on the line,\n                // the default 'deleteCount' is set to midDataPoints.length.\n                if (Point.isAlign(nextRenderPoints)) {\n                    deleteCount = midDataPoints.length;\n                }\n            }\n        } else {\n            index = 0;\n        }\n    }\n\n    return {\n        index,\n        deleteCount\n    };\n}\n\nexport function getMirrorDataPoints(board: PlaitBoard, nextDataPoints: Point[], nextKeyPoints: Point[], params: ElbowLineRouteOptions) {\n    for (let index = 1; index < nextDataPoints.length - 2; index++) {\n        adjustByCustomPointStartIndex(board, index, nextDataPoints, nextKeyPoints, params);\n    }\n    return nextDataPoints;\n}\n\n/**\n * adjust based parallel segment\n */\nconst adjustByCustomPointStartIndex = (\n    board: PlaitBoard,\n    customPointStartIndex: number,\n    nextDataPoints: Point[],\n    nextKeyPoints: Point[],\n    params: ElbowLineRouteOptions\n) => {\n    const beforePoint = nextDataPoints[customPointStartIndex - 1];\n    const startPoint = nextDataPoints[customPointStartIndex];\n    const endPoint = nextDataPoints[customPointStartIndex + 1];\n    const afterPoint = nextDataPoints[customPointStartIndex + 2];\n    const beforeSegment = [beforePoint, startPoint];\n    const afterSegment = [endPoint, afterPoint];\n    const isStraightWithBefore = Point.isAlign(beforeSegment);\n    const isStraightWithAfter = Point.isAlign(afterSegment);\n    let isAdjustStart = false;\n    let isAdjustEnd = false;\n    if (!isStraightWithBefore || !isStraightWithAfter) {\n        const midKeyPointsWithBefore = getMidKeyPoints(nextKeyPoints, beforeSegment[0], beforeSegment[1]);\n        const midKeyPointsWithAfter = getMidKeyPoints(nextKeyPoints, afterSegment[0], afterSegment[1]);\n        const hasMidKeyPoints = midKeyPointsWithBefore.length > 0 && midKeyPointsWithAfter.length > 0;\n        isAdjustStart = !isStraightWithBefore && !hasMidKeyPoints;\n        isAdjustEnd = !isStraightWithAfter && !hasMidKeyPoints;\n    }\n    if (isAdjustStart || isAdjustEnd) {\n        const parallelSegment = [startPoint, endPoint] as [Point, Point];\n        const parallelSegments = findOrthogonalParallelSegments(parallelSegment, nextKeyPoints);\n        const mirrorSegments = findMirrorSegments(board, parallelSegment, parallelSegments, params.sourceRectangle, params.targetRectangle);\n        if (mirrorSegments.length === 1) {\n            const mirrorSegment = mirrorSegments[0];\n            if (isAdjustStart) {\n                nextDataPoints.splice(customPointStartIndex, 1, mirrorSegment[0]);\n            }\n            if (isAdjustEnd) {\n                nextDataPoints.splice(customPointStartIndex + 1, 1, mirrorSegment[1]);\n            }\n        } else {\n            const isHorizontal = Point.isHorizontal(startPoint, endPoint);\n            const adjustIndex = isHorizontal ? 0 : 1;\n            if (isAdjustStart) {\n                const newStartPoint = [startPoint[0], startPoint[1]] as Point;\n                newStartPoint[adjustIndex] = beforePoint[adjustIndex];\n                nextDataPoints.splice(customPointStartIndex, 1, newStartPoint);\n            }\n            if (isAdjustEnd) {\n                const newEndPoint = [endPoint[0], endPoint[1]] as Point;\n                newEndPoint[adjustIndex] = afterPoint[adjustIndex];\n                nextDataPoints.splice(customPointStartIndex + 1, 1, newEndPoint);\n            }\n        }\n    }\n};\n\nexport function isUpdatedHandleIndex(\n    board: PlaitBoard,\n    element: PlaitLine,\n    dataPoints: Point[],\n    nextRenderPoints: Point[],\n    handleIndex: number\n) {\n    const { deleteCount } = getIndexAndDeleteCountByKeyPoint(board, element, dataPoints, nextRenderPoints, handleIndex);\n    if (deleteCount !== null && deleteCount > 1) {\n        return true;\n    }\n    return false;\n}\n\nexport function getMidKeyPoints(simplifiedNextKeyPoints: Point[], startPoint: Point, endPoint: Point) {\n    let midElbowPoints: Point[] = [];\n    let startPointIndex = -1;\n    let endPointIndex = -1;\n    for (let i = 0; i < simplifiedNextKeyPoints.length; i++) {\n        if (Point.isAlign([simplifiedNextKeyPoints[i], startPoint])) {\n            startPointIndex = i;\n        }\n        if (startPointIndex > -1 && Point.isAlign([simplifiedNextKeyPoints[i], endPoint])) {\n            endPointIndex = i;\n            break;\n        }\n    }\n    if (startPointIndex > -1 && endPointIndex > -1) {\n        midElbowPoints = simplifiedNextKeyPoints.slice(startPointIndex, endPointIndex + 1);\n    }\n    return midElbowPoints;\n}\n\nfunction findOrthogonalParallelSegments(segment: [Point, Point], keyPoints: Point[]): [Point, Point][] {\n    const isHorizontalSegment = Point.isHorizontal(segment[0], segment[1]);\n    const parallelSegments: [Point, Point][] = [];\n\n    for (let i = 0; i < keyPoints.length - 1; i++) {\n        const current = keyPoints[i];\n        const next = keyPoints[i + 1];\n        const isHorizontal = Point.isHorizontal(current, next, 0.1);\n        if (isHorizontalSegment && isHorizontal) {\n            parallelSegments.push([current, next]);\n        }\n        if (!isHorizontalSegment && !isHorizontal) {\n            parallelSegments.push([current, next]);\n        }\n    }\n\n    return parallelSegments;\n}\n\nfunction findMirrorSegments(\n    board: PlaitBoard,\n    segment: [Point, Point],\n    parallelSegments: [Point, Point][],\n    sourceRectangle: RectangleClient,\n    targetRectangle: RectangleClient\n) {\n    const mirrorSegments: [Point, Point][] = [];\n    for (let index = 0; index < parallelSegments.length; index++) {\n        const parallelPath = parallelSegments[index];\n        const startPoint = [segment[0][0], segment[0][1]] as Point;\n        const endPoint = [segment[1][0], segment[1][1]] as Point;\n        const isHorizontal = Point.isHorizontal(startPoint, endPoint);\n        const adjustDataIndex = isHorizontal ? 0 : 1;\n        startPoint[adjustDataIndex] = parallelPath[0][adjustDataIndex];\n        endPoint[adjustDataIndex] = parallelPath[1][adjustDataIndex];\n        const fakeRectangle = RectangleClient.getRectangleByPoints([startPoint, endPoint, ...parallelPath]);\n        const isValid = !RectangleClient.isHit(fakeRectangle, sourceRectangle) && !RectangleClient.isHit(fakeRectangle, targetRectangle);\n        if (isValid) {\n            mirrorSegments.push([startPoint, endPoint]);\n            // const fakeRectangleG = PlaitBoard.getRoughSVG(board).rectangle(\n            //     fakeRectangle.x,\n            //     fakeRectangle.y,\n            //     fakeRectangle.width,\n            //     fakeRectangle.height,\n            //     { stroke: 'blue' }\n            // );\n            // PlaitBoard.getElementActiveHost(board).append(fakeRectangleG);\n        }\n    }\n    return mirrorSegments;\n}\n\nexport const hasIllegalElbowPoint = (midDataPoints: Point[]): boolean => {\n    if (midDataPoints.length === 1) {\n        return true;\n    }\n    return midDataPoints.some((item, index) => {\n        const beforePoint = midDataPoints[index - 1];\n        const afterPoint = midDataPoints[index + 1];\n        const beforeSegment = beforePoint && [beforePoint, item];\n        const afterSegment = afterPoint && [item, afterPoint];\n        const isStraightWithBefore = beforeSegment && Point.isAlign(beforeSegment);\n        const isStraightWithAfter = afterSegment && Point.isAlign(afterSegment);\n        if (index === 0) {\n            return !isStraightWithAfter;\n        }\n        if (index === midDataPoints.length - 1) {\n            return !isStraightWithBefore;\n        }\n        return !isStraightWithBefore && !isStraightWithAfter;\n    });\n};\n"]}

package/esm2022/utils/polygon.mjs

@@ -0,0 +1,30 @@
+import { getCrossingPointsBetweenPointAndSegment, isPointOnSegment } from '@plait/common';
+export const getCenterPointsOnPolygon = (points) => {
+    const centerPoints = [];
+    for (let i = 0; i < points.length; i++) {
+        let j = i == points.length - 1 ? 0 : i + 1;
+        centerPoints.push([(points[i][0] + points[j][0]) / 2, (points[i][1] + points[j][1]) / 2]);
+    }
+    return centerPoints;
+};
+export const getCrossingPointBetweenPointAndPolygon = (corners, point) => {
+    const result = [];
+    for (let index = 1; index <= corners.length; index++) {
+        let start = corners[index - 1];
+        let end = index === corners.length ? corners[0] : corners[index];
+        const crossingPoint = getCrossingPointsBetweenPointAndSegment(point, start, end);
+        result.push(...crossingPoint);
+    }
+    return result;
+};
+export const getPolygonEdgeByConnectionPoint = (corners, point) => {
+    for (let index = 1; index <= corners.length; index++) {
+        let start = corners[index - 1];
+        let end = index === corners.length ? corners[0] : corners[index];
+        if (isPointOnSegment(point, start, end)) {
+            return [start, end];
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/position/geometry.mjs

@@ -1,13 +1,12 @@
 import { RectangleClient, depthFirstRecursion, getIsRecursionFunc } from '@plait/core';
 import { PlaitDrawElement } from '../../interfaces';
-import { RESIZE_HANDLE_DIAMETER, getRectangleByPoints, getRectangleResizeHandleRefs } from '@plait/common';
+import { RESIZE_HANDLE_DIAMETER, getRectangleResizeHandleRefs } from '@plait/common';
 import { getEngine } from '../../engines';
 import { getShape } from '../shape';
-export const getHitGeometryResizeHandleRef = (board, element, point) => {
-    const rectangle = getRectangleByPoints(element.points);
+export const getHitRectangleResizeHandleRef = (board, rectangle, point) => {
     const resizeHandleRefs = getRectangleResizeHandleRefs(rectangle, RESIZE_HANDLE_DIAMETER);
     const result = resizeHandleRefs.find(resizeHandleRef => {
-        return RectangleClient.isHit(RectangleClient.toRectangleClient([point, point]), resizeHandleRef.rectangle);
+        return RectangleClient.isHit(RectangleClient.getRectangleByPoints([point, point]), resizeHandleRef.rectangle);
     });
     return result;
 };
@@ -15,7 +14,7 @@ export const getHitOutlineGeometry = (board, point, offset = 0) => {
     let geometry = null;
     depthFirstRecursion(board, node => {
         if (PlaitDrawElement.isGeometry(node) || PlaitDrawElement.isImage(node)) {
-            let client = getRectangleByPoints(node.points);
+            let client = RectangleClient.getRectangleByPoints(node.points);
             client = RectangleClient.getOutlineRectangle(client, offset);
             const shape = getShape(node);
             const isHit = getEngine(shape).isHit(client, point);
@@ -26,4 +25,4 @@ export const getHitOutlineGeometry = (board, point, offset = 0) => {
     }, getIsRecursionFunc(board), true);
     return geometry;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/position/line.mjs

@@ -1,7 +1,7 @@
 import { RectangleClient } from '@plait/core';
-import { PlaitLine } from '../../interfaces';
-import { RESIZE_HANDLE_DIAMETER } from '@plait/common';
-import { getMiddlePoints } from '../../generators/line-active.generator';
+import { LineShape, PlaitLine } from '../../interfaces';
+import { RESIZE_HANDLE_DIAMETER, getPointOnPolyline } from '@plait/common';
+import { getLinePoints, getMiddlePoints } from '../line/line-basic';
 export var LineResizeHandle;
 (function (LineResizeHandle) {
     LineResizeHandle["source"] = "source";
@@ -9,25 +9,32 @@ export var LineResizeHandle;
     LineResizeHandle["addHandle"] = "addHandle";
 })(LineResizeHandle || (LineResizeHandle = {}));
 export const getHitLineResizeHandleRef = (board, element, point) => {
-    const points = PlaitLine.getPoints(board, element);
-    const index = getHitPointIndex(points, point);
+    let dataPoints = PlaitLine.getPoints(board, element);
+    const index = getHitPointIndex(dataPoints, point);
     if (index !== -1) {
+        const handleIndex = index;
         if (index === 0) {
-            return { handle: LineResizeHandle.source, index };
+            return { handle: LineResizeHandle.source, handleIndex };
         }
-        if (index === points.length - 1) {
-            return { handle: LineResizeHandle.target, index };
+        if (index === dataPoints.length - 1) {
+            return { handle: LineResizeHandle.target, handleIndex };
+        }
+        // elbow line, data points only verify source connection point and target connection point
+        if (element.shape !== LineShape.elbow) {
+            return { handleIndex };
         }
-        return { index };
     }
     const middlePoints = getMiddlePoints(board, element);
-    const middleIndex = getHitPointIndex(middlePoints, point);
-    if (middleIndex !== -1) {
-        return { handle: LineResizeHandle.addHandle, index: middleIndex };
+    const indexOfMiddlePoints = getHitPointIndex(middlePoints, point);
+    if (indexOfMiddlePoints !== -1) {
+        return {
+            handle: LineResizeHandle.addHandle,
+            handleIndex: indexOfMiddlePoints
+        };
     }
     return undefined;
 };
-function getHitPointIndex(points, movingPoint) {
+export function getHitPointIndex(points, movingPoint) {
     const rectangles = points.map(point => {
         return {
             x: point[0] - RESIZE_HANDLE_DIAMETER / 2,
@@ -37,8 +44,24 @@ function getHitPointIndex(points, movingPoint) {
         };
     });
     const rectangle = rectangles.find(rectangle => {
-        return RectangleClient.isHit(RectangleClient.toRectangleClient([movingPoint, movingPoint]), rectangle);
+        return RectangleClient.isHit(RectangleClient.getRectangleByPoints([movingPoint, movingPoint]), rectangle);
     });
     return rectangle ? rectangles.indexOf(rectangle) : -1;
 }
-//# sourceMappingURL=data:application/json;base64,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
+export const getHitLineTextIndex = (board, element, point) => {
+    const texts = element.texts;
+    if (!texts.length)
+        return -1;
+    const points = getLinePoints(board, element);
+    return texts.findIndex(text => {
+        const center = getPointOnPolyline(points, text.position);
+        const rectangle = {
+            x: center[0] - text.width / 2,
+            y: center[1] - text.height / 2,
+            width: text.width,
+            height: text.height
+        };
+        return RectangleClient.isHit(rectangle, RectangleClient.getRectangleByPoints([point, point]));
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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