@plait/draw 0.62.0-next.6 → 0.62.0-next.7

package/esm2022/plugins/with-arrow-line-auto-complete-reaction.mjs

@@ -0,0 +1,41 @@
+import { CursorClass, PlaitBoard, PlaitElement, RectangleClient, RgbaToHEX, drawCircle, hasValidAngle, isSelectionMoving, rotateAntiPointsByElement, setAngleForG, toHostPoint, toViewBoxPoint } from '@plait/core';
+import { PlaitDrawElement } from '../interfaces';
+import { getAutoCompletePoints, getHitIndexOfAutoCompletePoint, getSelectedDrawElements } from '../utils';
+import { PRIMARY_COLOR } from '@plait/common';
+import { LINE_AUTO_COMPLETE_HOVERED_DIAMETER, LINE_AUTO_COMPLETE_HOVERED_OPACITY } from '../constants/line';
+import { ArrowLineAutoCompleteGenerator } from '../generators/arrow-line-auto-complete.generator';
+export const withArrowLineAutoCompleteReaction = (board) => {
+    const { pointerMove } = board;
+    let reactionG = null;
+    board.pointerMove = (event) => {
+        reactionG?.remove();
+        PlaitBoard.getBoardContainer(board).classList.remove(CursorClass.crosshair);
+        const selectedElements = getSelectedDrawElements(board);
+        const targetElement = selectedElements.length === 1 && selectedElements[0];
+        const movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        if (!PlaitBoard.isReadonly(board) && !isSelectionMoving(board) && targetElement && PlaitDrawElement.isShapeElement(targetElement)) {
+            const points = getAutoCompletePoints(targetElement);
+            const hitIndex = getHitIndexOfAutoCompletePoint(rotateAntiPointsByElement(movingPoint, targetElement) || movingPoint, points);
+            const hitPoint = points[hitIndex];
+            const ref = PlaitElement.getElementRef(targetElement);
+            const lineAutoCompleteGenerator = ref.getGenerator(ArrowLineAutoCompleteGenerator.key);
+            lineAutoCompleteGenerator.recoverAutoCompleteG();
+            if (hitPoint) {
+                lineAutoCompleteGenerator?.removeAutoCompleteG(hitIndex);
+                reactionG = drawCircle(PlaitBoard.getRoughSVG(board), hitPoint, LINE_AUTO_COMPLETE_HOVERED_DIAMETER, {
+                    stroke: 'none',
+                    fill: RgbaToHEX(PRIMARY_COLOR, LINE_AUTO_COMPLETE_HOVERED_OPACITY),
+                    fillStyle: 'solid'
+                });
+                PlaitBoard.getElementActiveHost(board).append(reactionG);
+                PlaitBoard.getBoardContainer(board).classList.add(CursorClass.crosshair);
+                if (hasValidAngle(targetElement)) {
+                    setAngleForG(reactionG, RectangleClient.getCenterPoint(board.getRectangle(targetElement)), targetElement.angle);
+                }
+            }
+        }
+        pointerMove(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/with-arrow-line-auto-complete.mjs

@@ -0,0 +1,74 @@
+import { BoardTransforms, PRESS_AND_MOVE_BUFFER, PlaitBoard, PlaitPointerType, RectangleClient, Transforms, addSelectedElement, clearSelectedElement, createG, distanceBetweenPointAndPoint, rotateAntiPointsByElement, rotatePointsByElement, temporaryDisableSelection, toHostPoint, toViewBoxPoint } from '@plait/core';
+import { ArrowLineShape, PlaitDrawElement } from '../interfaces';
+import { getElementShape } from '../utils/shape';
+import { getEngine } from '../engines';
+import { handleArrowLineCreating } from '../utils/arrow-line/arrow-line-basic';
+import { getSelectedDrawElements } from '../utils/selected';
+import { getAutoCompletePoints, getHitIndexOfAutoCompletePoint } from '../utils/geometry';
+export const WithArrowLineAutoCompletePluginKey = 'plait-arrow-line-auto-complete-plugin-key';
+export const withArrowLineAutoComplete = (board) => {
+    const { pointerDown, pointerMove, globalPointerUp } = board;
+    let autoCompletePoint = null;
+    let lineShapeG = null;
+    let sourceElement;
+    let temporaryElement;
+    board.pointerDown = (event) => {
+        const selectedElements = getSelectedDrawElements(board);
+        const targetElement = selectedElements.length === 1 && selectedElements[0];
+        const clickPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        if (!PlaitBoard.isReadonly(board) && targetElement && PlaitDrawElement.isShapeElement(targetElement)) {
+            const points = getAutoCompletePoints(targetElement);
+            const index = getHitIndexOfAutoCompletePoint(rotateAntiPointsByElement(clickPoint, targetElement) || clickPoint, points);
+            const hitPoint = points[index];
+            if (hitPoint) {
+                temporaryDisableSelection(board);
+                autoCompletePoint = hitPoint;
+                sourceElement = targetElement;
+                BoardTransforms.updatePointerType(board, ArrowLineShape.elbow);
+            }
+        }
+        pointerDown(event);
+    };
+    board.pointerMove = (event) => {
+        lineShapeG?.remove();
+        lineShapeG = createG();
+        let movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        if (autoCompletePoint && sourceElement) {
+            const distance = distanceBetweenPointAndPoint(...(rotateAntiPointsByElement(movingPoint, sourceElement) || movingPoint), ...autoCompletePoint);
+            if (distance > PRESS_AND_MOVE_BUFFER) {
+                const rectangle = RectangleClient.getRectangleByPoints(sourceElement.points);
+                const shape = getElementShape(sourceElement);
+                const engine = getEngine(shape);
+                let sourcePoint = autoCompletePoint;
+                if (engine.getNearestCrossingPoint) {
+                    const crossingPoint = engine.getNearestCrossingPoint(rectangle, autoCompletePoint);
+                    sourcePoint = crossingPoint;
+                }
+                // source point must be click point
+                const rotatedSourcePoint = rotatePointsByElement(sourcePoint, sourceElement) || sourcePoint;
+                temporaryElement = handleArrowLineCreating(board, ArrowLineShape.elbow, rotatedSourcePoint, movingPoint, sourceElement, lineShapeG);
+            }
+        }
+        pointerMove(event);
+    };
+    board.globalPointerUp = event => {
+        if (temporaryElement) {
+            Transforms.insertNode(board, temporaryElement, [board.children.length]);
+            clearSelectedElement(board);
+            addSelectedElement(board, temporaryElement);
+            const afterComplete = board.getPluginOptions(WithArrowLineAutoCompletePluginKey)?.afterComplete;
+            afterComplete && afterComplete(temporaryElement);
+        }
+        if (autoCompletePoint) {
+            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+            autoCompletePoint = null;
+        }
+        lineShapeG?.remove();
+        lineShapeG = null;
+        sourceElement = null;
+        temporaryElement = null;
+        globalPointerUp(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-arrow-line-auto-complete.js","sourceRoot":"","sources":["../../../../packages/draw/src/plugins/with-arrow-line-auto-complete.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    BoardTransforms,\n    PRESS_AND_MOVE_BUFFER,\n    PlaitBoard,\n    PlaitOptionsBoard,\n    PlaitPointerType,\n    Point,\n    RectangleClient,\n    Transforms,\n    addSelectedElement,\n    clearSelectedElement,\n    createG,\n    distanceBetweenPointAndPoint,\n    rotateAntiPointsByElement,\n    rotatePointsByElement,\n    temporaryDisableSelection,\n    toHostPoint,\n    toViewBoxPoint\n} from '@plait/core';\nimport { ArrowLineShape, PlaitArrowLine, PlaitDrawElement, PlaitShapeElement } from '../interfaces';\nimport { getElementShape } from '../utils/shape';\nimport { getEngine } from '../engines';\nimport { handleArrowLineCreating } from '../utils/arrow-line/arrow-line-basic';\nimport { getSelectedDrawElements } from '../utils/selected';\nimport { getAutoCompletePoints, getHitIndexOfAutoCompletePoint } from '../utils/geometry';\n\nexport const WithArrowLineAutoCompletePluginKey = 'plait-arrow-line-auto-complete-plugin-key';\n\nexport interface ArrowLineAutoCompleteOptions {\n    afterComplete: (element: PlaitArrowLine) => {};\n}\n\nexport const withArrowLineAutoComplete = (board: PlaitBoard) => {\n    const { pointerDown, pointerMove, globalPointerUp } = board;\n\n    let autoCompletePoint: Point | null = null;\n    let lineShapeG: SVGGElement | null = null;\n    let sourceElement: PlaitShapeElement | null;\n    let temporaryElement: PlaitArrowLine | null;\n\n    board.pointerDown = (event: PointerEvent) => {\n        const selectedElements = getSelectedDrawElements(board);\n        const targetElement = selectedElements.length === 1 && selectedElements[0];\n        const clickPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));\n        if (!PlaitBoard.isReadonly(board) && targetElement && PlaitDrawElement.isShapeElement(targetElement)) {\n            const points = getAutoCompletePoints(targetElement);\n            const index = getHitIndexOfAutoCompletePoint(rotateAntiPointsByElement(clickPoint, targetElement) || clickPoint, points);\n            const hitPoint = points[index];\n            if (hitPoint) {\n                temporaryDisableSelection(board as PlaitOptionsBoard);\n                autoCompletePoint = hitPoint;\n                sourceElement = targetElement;\n                BoardTransforms.updatePointerType(board, ArrowLineShape.elbow);\n            }\n        }\n        pointerDown(event);\n    };\n\n    board.pointerMove = (event: PointerEvent) => {\n        lineShapeG?.remove();\n        lineShapeG = createG();\n        let movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));\n        if (autoCompletePoint && sourceElement) {\n            const distance = distanceBetweenPointAndPoint(\n                ...(rotateAntiPointsByElement(movingPoint, sourceElement) || movingPoint),\n                ...autoCompletePoint\n            );\n            if (distance > PRESS_AND_MOVE_BUFFER) {\n                const rectangle = RectangleClient.getRectangleByPoints(sourceElement.points);\n                const shape = getElementShape(sourceElement);\n                const engine = getEngine(shape);\n                let sourcePoint = autoCompletePoint;\n                if (engine.getNearestCrossingPoint) {\n                    const crossingPoint = engine.getNearestCrossingPoint(rectangle, autoCompletePoint);\n                    sourcePoint = crossingPoint;\n                }\n                // source point must be click point\n                const rotatedSourcePoint = rotatePointsByElement(sourcePoint, sourceElement) || sourcePoint;\n                temporaryElement = handleArrowLineCreating(\n                    board,\n                    ArrowLineShape.elbow,\n                    rotatedSourcePoint,\n                    movingPoint,\n                    sourceElement,\n                    lineShapeG\n                );\n            }\n        }\n        pointerMove(event);\n    };\n\n    board.globalPointerUp = event => {\n        if (temporaryElement) {\n            Transforms.insertNode(board, temporaryElement, [board.children.length]);\n            clearSelectedElement(board);\n            addSelectedElement(board, temporaryElement);\n            const afterComplete = (board as PlaitOptionsBoard).getPluginOptions<ArrowLineAutoCompleteOptions>(\n                WithArrowLineAutoCompletePluginKey\n            )?.afterComplete;\n            afterComplete && afterComplete(temporaryElement);\n        }\n        if (autoCompletePoint) {\n            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);\n            autoCompletePoint = null;\n        }\n        lineShapeG?.remove();\n        lineShapeG = null;\n        sourceElement = null;\n        temporaryElement = null;\n        globalPointerUp(event);\n    };\n\n    return board;\n};\n"]}

package/esm2022/plugins/with-arrow-line-bound-reaction.mjs

@@ -0,0 +1,53 @@
+import { SNAPPING_STROKE_WIDTH, PlaitBoard, RectangleClient, SELECTION_BORDER_COLOR, drawCircle, hasValidAngle, setAngleForG, toHostPoint, toViewBoxPoint } from '@plait/core';
+import { ArrowLineShape, PlaitDrawElement } from '../interfaces';
+import { isResizingByCondition } from '@plait/common';
+import { ArrowLineResizeHandle } from '../utils/position/arrow-line';
+import { drawBoundReaction, getHitShape, getSnappingRef } from '../utils';
+export const withArrowLineBoundReaction = (board) => {
+    const { pointerMove, pointerUp } = board;
+    let boundShapeG = null;
+    board.pointerMove = (event) => {
+        boundShapeG?.remove();
+        if (PlaitBoard.isReadonly(board)) {
+            pointerMove(event);
+            return;
+        }
+        const linePointers = Object.keys(ArrowLineShape);
+        const isLinePointer = PlaitBoard.isInPointer(board, linePointers);
+        const movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        const isLineResizing = isResizingByCondition(board, resizeRef => {
+            const { element, handle } = resizeRef;
+            const isSourceOrTarget = handle === ArrowLineResizeHandle.target || handle === ArrowLineResizeHandle.source;
+            return PlaitDrawElement.isArrowLine(element) && isSourceOrTarget;
+        });
+        if (isLinePointer || isLineResizing) {
+            const hitElement = getHitShape(board, movingPoint);
+            if (hitElement) {
+                const ref = getSnappingRef(board, hitElement, movingPoint);
+                const isSnapping = ref.isHitEdge || ref.isHitConnector;
+                boundShapeG = drawBoundReaction(board, hitElement, { hasMask: isSnapping, hasConnector: true });
+                if (isSnapping) {
+                    const circleG = drawCircle(PlaitBoard.getRoughSVG(board), ref.connectorPoint || ref.edgePoint, 6, {
+                        stroke: SELECTION_BORDER_COLOR,
+                        strokeWidth: SNAPPING_STROKE_WIDTH,
+                        fill: SELECTION_BORDER_COLOR,
+                        fillStyle: 'solid'
+                    });
+                    boundShapeG.appendChild(circleG);
+                }
+                if (hasValidAngle(hitElement)) {
+                    setAngleForG(boundShapeG, RectangleClient.getCenterPointByPoints(hitElement.points), hitElement.angle);
+                }
+                PlaitBoard.getElementActiveHost(board).append(boundShapeG);
+            }
+        }
+        pointerMove(event);
+    };
+    board.pointerUp = event => {
+        boundShapeG?.remove();
+        boundShapeG = null;
+        pointerUp(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/with-arrow-line-create.mjs

@@ -0,0 +1,53 @@
+import { BoardTransforms, PlaitBoard, PlaitPointerType, Transforms, addSelectedElement, clearSelectedElement, createG, preventTouchMove, toHostPoint, toViewBoxPoint } from '@plait/core';
+import { getArrowLinePointers } from '../constants';
+import { isDrawingMode } from '@plait/common';
+import { handleArrowLineCreating } from '../utils/arrow-line/arrow-line-basic';
+import { getSnappingShape } from '../utils';
+export const withArrowLineCreateByDraw = (board) => {
+    const { pointerDown, pointerMove, globalPointerUp } = board;
+    let start = null;
+    let sourceElement;
+    let lineShapeG = null;
+    let temporaryElement = null;
+    board.pointerDown = (event) => {
+        const linePointers = getArrowLinePointers();
+        const isLinePointer = PlaitBoard.isInPointer(board, linePointers);
+        if (!PlaitBoard.isReadonly(board) && isLinePointer && isDrawingMode(board)) {
+            const point = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+            start = point;
+            const hitElement = getSnappingShape(board, point);
+            if (hitElement) {
+                sourceElement = hitElement;
+            }
+            preventTouchMove(board, event, true);
+        }
+        pointerDown(event);
+    };
+    board.pointerMove = (event) => {
+        lineShapeG?.remove();
+        lineShapeG = createG();
+        let movingPoint = toViewBoxPoint(board, toHostPoint(board, event.x, event.y));
+        if (start) {
+            const lineShape = PlaitBoard.getPointer(board);
+            temporaryElement = handleArrowLineCreating(board, lineShape, start, movingPoint, sourceElement, lineShapeG);
+        }
+        pointerMove(event);
+    };
+    board.globalPointerUp = (event) => {
+        if (temporaryElement) {
+            Transforms.insertNode(board, temporaryElement, [board.children.length]);
+            clearSelectedElement(board);
+            addSelectedElement(board, temporaryElement);
+            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+        }
+        lineShapeG?.remove();
+        lineShapeG = null;
+        sourceElement = null;
+        start = null;
+        temporaryElement = null;
+        preventTouchMove(board, event, false);
+        globalPointerUp(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/plugins/with-arrow-line-resize.mjs

@@ -0,0 +1,158 @@
+import { PlaitNode, Point } from '@plait/core';
+import { simplifyOrthogonalPoints, withResize } from '@plait/common';
+import { getSelectedArrowLineElements } from '../utils/selected';
+import { getHitArrowLineResizeHandleRef, ArrowLineResizeHandle } from '../utils/position/arrow-line';
+import { ArrowLineShape } from '../interfaces';
+import { DrawTransforms } from '../transforms';
+import { getElbowPoints, getNextRenderPoints, isUseDefaultOrthogonalRoute } from '../utils/arrow-line/elbow';
+import { alignElbowSegment, alignPoints, getIndexAndDeleteCountByKeyPoint, getResizedPreviousAndNextPoint, hasIllegalElbowPoint } from '../utils/arrow-line/arrow-line-resize';
+import { getHitConnection, getArrowLinePoints } from '../utils/arrow-line/arrow-line-basic';
+import { getElbowLineRouteOptions } from '../utils/arrow-line';
+import { getSnappingShape } from '../utils';
+export const withArrowLineResize = (board) => {
+    let elbowLineIndex;
+    let elbowLineDeleteCount;
+    let elbowSourcePoint;
+    let elbowTargetPoint;
+    let elbowNextRenderPoints;
+    const options = {
+        key: 'draw-line',
+        canResize: () => {
+            return true;
+        },
+        hitTest: (point) => {
+            const selectedLineElements = getSelectedArrowLineElements(board);
+            if (selectedLineElements.length > 0) {
+                let result = null;
+                selectedLineElements.forEach(value => {
+                    const handleRef = getHitArrowLineResizeHandleRef(board, value, point);
+                    if (handleRef) {
+                        result = {
+                            element: value,
+                            handle: handleRef.handle,
+                            handleIndex: handleRef.handleIndex
+                        };
+                    }
+                });
+                return result;
+            }
+            return null;
+        },
+        beforeResize: (resizeRef) => {
+            if (resizeRef.element.shape === ArrowLineShape.elbow &&
+                resizeRef.handle !== ArrowLineResizeHandle.source &&
+                resizeRef.handle !== ArrowLineResizeHandle.target) {
+                const params = getElbowLineRouteOptions(board, resizeRef.element);
+                if (isUseDefaultOrthogonalRoute(resizeRef.element, params)) {
+                    return;
+                }
+                const points = [...resizeRef.element.points];
+                const handleIndex = resizeRef.handleIndex;
+                const pointsOnElbow = getElbowPoints(board, resizeRef.element);
+                elbowSourcePoint = pointsOnElbow[0];
+                elbowTargetPoint = pointsOnElbow[pointsOnElbow.length - 1];
+                elbowNextRenderPoints = getNextRenderPoints(board, resizeRef.element, pointsOnElbow);
+                const value = getIndexAndDeleteCountByKeyPoint(board, resizeRef.element, [...points], elbowNextRenderPoints, handleIndex);
+                elbowLineIndex = value.index;
+                elbowLineDeleteCount = value.deleteCount;
+            }
+        },
+        onResize: (resizeRef, resizeState) => {
+            let points = [...resizeRef.element.points];
+            let source = { ...resizeRef.element.source };
+            let target = { ...resizeRef.element.target };
+            let handleIndex = resizeRef.handleIndex;
+            const hitElement = getSnappingShape(board, resizeState.endPoint);
+            if (resizeRef.handle === ArrowLineResizeHandle.source || resizeRef.handle === ArrowLineResizeHandle.target) {
+                const object = resizeRef.handle === ArrowLineResizeHandle.source ? source : target;
+                points[handleIndex] = resizeState.endPoint;
+                if (hitElement) {
+                    object.connection = getHitConnection(board, resizeState.endPoint, hitElement);
+                    object.boundId = hitElement.id;
+                }
+                else {
+                    object.connection = undefined;
+                    object.boundId = undefined;
+                }
+            }
+            else {
+                if (resizeRef.element.shape === ArrowLineShape.elbow) {
+                    if (elbowNextRenderPoints && elbowSourcePoint && elbowTargetPoint) {
+                        const resizedPreviousAndNextPoint = getResizedPreviousAndNextPoint(elbowNextRenderPoints, elbowSourcePoint, elbowTargetPoint, handleIndex);
+                        const startKeyPoint = elbowNextRenderPoints[handleIndex];
+                        const endKeyPoint = elbowNextRenderPoints[handleIndex + 1];
+                        const [newStartPoint, newEndPoint] = alignElbowSegment(startKeyPoint, endKeyPoint, resizeState, resizedPreviousAndNextPoint);
+                        let midDataPoints = [...points].slice(1, points.length - 1);
+                        if (elbowLineIndex !== null && elbowLineDeleteCount !== null) {
+                            if (hasIllegalElbowPoint(midDataPoints)) {
+                                midDataPoints = [newStartPoint, newEndPoint];
+                            }
+                            else {
+                                midDataPoints.splice(elbowLineIndex, elbowLineDeleteCount, newStartPoint, newEndPoint);
+                            }
+                            points = [elbowSourcePoint, ...midDataPoints, elbowTargetPoint];
+                        }
+                    }
+                }
+                else {
+                    if (resizeRef.handle === ArrowLineResizeHandle.addHandle) {
+                        points.splice(handleIndex + 1, 0, resizeState.endPoint);
+                    }
+                    else {
+                        points[handleIndex] = resizeState.endPoint;
+                    }
+                }
+            }
+            if (!hitElement) {
+                handleIndex = resizeRef.handle === ArrowLineResizeHandle.addHandle ? handleIndex + 1 : handleIndex;
+                const drawPoints = getArrowLinePoints(board, resizeRef.element);
+                const newPoints = [...points];
+                newPoints[0] = drawPoints[0];
+                newPoints[newPoints.length - 1] = drawPoints[drawPoints.length - 1];
+                if (resizeRef.element.shape !== ArrowLineShape.elbow ||
+                    (resizeRef.element.shape === ArrowLineShape.elbow && newPoints.length === 2)) {
+                    newPoints.forEach((point, index) => {
+                        if (index === handleIndex)
+                            return;
+                        if (points[handleIndex]) {
+                            points[handleIndex] = alignPoints(point, points[handleIndex]);
+                        }
+                    });
+                }
+            }
+            DrawTransforms.resizeArrowLine(board, { points, source, target }, resizeRef.path);
+        },
+        afterResize: (resizeRef) => {
+            if (resizeRef.element.shape === ArrowLineShape.elbow) {
+                const element = PlaitNode.get(board, resizeRef.path);
+                let points = element && [...element.points];
+                if (points.length > 2 && elbowNextRenderPoints && elbowSourcePoint && elbowTargetPoint) {
+                    const nextSourcePoint = elbowNextRenderPoints[0];
+                    const nextTargetPoint = elbowNextRenderPoints[elbowNextRenderPoints.length - 1];
+                    points.splice(0, 1, nextSourcePoint);
+                    points.splice(-1, 1, nextTargetPoint);
+                    points = simplifyOrthogonalPoints(points);
+                    if (Point.isEquals(points[0], nextSourcePoint)) {
+                        points.splice(0, 1);
+                    }
+                    if (Point.isEquals(points[points.length - 1], nextTargetPoint)) {
+                        points.pop();
+                    }
+                    if (points.length === 1) {
+                        points = [];
+                    }
+                    points = [elbowSourcePoint, ...points, elbowTargetPoint];
+                    DrawTransforms.resizeArrowLine(board, { points }, resizeRef.path);
+                }
+            }
+            elbowLineIndex = null;
+            elbowLineDeleteCount = null;
+            elbowSourcePoint = null;
+            elbowTargetPoint = null;
+            elbowNextRenderPoints = null;
+        }
+    };
+    withResize(board, options);
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-arrow-line-resize.js","sourceRoot":"","sources":["../../../../packages/draw/src/plugins/with-arrow-line-resize.ts"],"names":[],"mappings":"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","sourcesContent":["import { Path, PlaitBoard, PlaitNode, Point } from '@plait/core';\nimport { ResizeRef, ResizeState, WithResizeOptions, simplifyOrthogonalPoints, withResize } from '@plait/common';\nimport { getSelectedArrowLineElements } from '../utils/selected';\nimport { getHitArrowLineResizeHandleRef, ArrowLineResizeHandle } from '../utils/position/arrow-line';\nimport { ArrowLineHandle, ArrowLineShape, PlaitArrowLine } from '../interfaces';\nimport { DrawTransforms } from '../transforms';\nimport { getElbowPoints, getNextRenderPoints, isUseDefaultOrthogonalRoute } from '../utils/arrow-line/elbow';\nimport {\n    alignElbowSegment,\n    alignPoints,\n    getIndexAndDeleteCountByKeyPoint,\n    getResizedPreviousAndNextPoint,\n    hasIllegalElbowPoint\n} from '../utils/arrow-line/arrow-line-resize';\nimport { getHitConnection, getArrowLinePoints } from '../utils/arrow-line/arrow-line-basic';\nimport { getElbowLineRouteOptions } from '../utils/arrow-line';\nimport { getSnappingShape } from '../utils';\n\nexport const withArrowLineResize = (board: PlaitBoard) => {\n    let elbowLineIndex: number | null;\n    let elbowLineDeleteCount: number | null;\n    let elbowSourcePoint: Point | null;\n    let elbowTargetPoint: Point | null;\n    let elbowNextRenderPoints: Point[] | null;\n\n    const options: WithResizeOptions<PlaitArrowLine, ArrowLineResizeHandle> = {\n        key: 'draw-line',\n        canResize: () => {\n            return true;\n        },\n        hitTest: (point: Point) => {\n            const selectedLineElements = getSelectedArrowLineElements(board);\n            if (selectedLineElements.length > 0) {\n                let result = null;\n                selectedLineElements.forEach(value => {\n                    const handleRef = getHitArrowLineResizeHandleRef(board, value, point);\n                    if (handleRef) {\n                        result = {\n                            element: value,\n                            handle: handleRef.handle,\n                            handleIndex: handleRef.handleIndex\n                        };\n                    }\n                });\n                return result;\n            }\n            return null;\n        },\n        beforeResize: (resizeRef: ResizeRef<PlaitArrowLine, ArrowLineResizeHandle>) => {\n            if (\n                resizeRef.element.shape === ArrowLineShape.elbow &&\n                resizeRef.handle !== ArrowLineResizeHandle.source &&\n                resizeRef.handle !== ArrowLineResizeHandle.target\n            ) {\n                const params = getElbowLineRouteOptions(board, resizeRef.element);\n                if (isUseDefaultOrthogonalRoute(resizeRef.element, params)) {\n                    return;\n                }\n                const points: Point[] = [...resizeRef.element.points];\n                const handleIndex = resizeRef.handleIndex!;\n                const pointsOnElbow = getElbowPoints(board, resizeRef.element);\n                elbowSourcePoint = pointsOnElbow[0];\n                elbowTargetPoint = pointsOnElbow[pointsOnElbow.length - 1];\n                elbowNextRenderPoints = getNextRenderPoints(board, resizeRef.element, pointsOnElbow);\n\n                const value = getIndexAndDeleteCountByKeyPoint(board, resizeRef.element, [...points], elbowNextRenderPoints, handleIndex);\n                elbowLineIndex = value.index;\n                elbowLineDeleteCount = value.deleteCount;\n            }\n        },\n        onResize: (resizeRef: ResizeRef<PlaitArrowLine, ArrowLineResizeHandle>, resizeState: ResizeState) => {\n            let points: Point[] = [...resizeRef.element.points];\n            let source: ArrowLineHandle = { ...resizeRef.element.source };\n            let target: ArrowLineHandle = { ...resizeRef.element.target };\n            let handleIndex = resizeRef.handleIndex!;\n            const hitElement = getSnappingShape(board, resizeState.endPoint);\n            if (resizeRef.handle === ArrowLineResizeHandle.source || resizeRef.handle === ArrowLineResizeHandle.target) {\n                const object = resizeRef.handle === ArrowLineResizeHandle.source ? source : target;\n                points[handleIndex] = resizeState.endPoint;\n                if (hitElement) {\n                    object.connection = getHitConnection(board, resizeState.endPoint, hitElement);\n                    object.boundId = hitElement.id;\n                } else {\n                    object.connection = undefined;\n                    object.boundId = undefined;\n                }\n            } else {\n                if (resizeRef.element.shape === ArrowLineShape.elbow) {\n                    if (elbowNextRenderPoints && elbowSourcePoint && elbowTargetPoint) {\n                        const resizedPreviousAndNextPoint = getResizedPreviousAndNextPoint(\n                            elbowNextRenderPoints,\n                            elbowSourcePoint,\n                            elbowTargetPoint,\n                            handleIndex\n                        );\n                        const startKeyPoint = elbowNextRenderPoints[handleIndex];\n                        const endKeyPoint = elbowNextRenderPoints[handleIndex + 1];\n                        const [newStartPoint, newEndPoint] = alignElbowSegment(\n                            startKeyPoint,\n                            endKeyPoint,\n                            resizeState,\n                            resizedPreviousAndNextPoint\n                        );\n                        let midDataPoints: Point[] = [...points].slice(1, points.length - 1);\n                        if (elbowLineIndex !== null && elbowLineDeleteCount !== null) {\n                            if (hasIllegalElbowPoint(midDataPoints)) {\n                                midDataPoints = [newStartPoint, newEndPoint];\n                            } else {\n                                midDataPoints.splice(elbowLineIndex, elbowLineDeleteCount, newStartPoint, newEndPoint);\n                            }\n                            points = [elbowSourcePoint, ...midDataPoints, elbowTargetPoint];\n                        }\n                    }\n                } else {\n                    if (resizeRef.handle === ArrowLineResizeHandle.addHandle) {\n                        points.splice(handleIndex + 1, 0, resizeState.endPoint);\n                    } else {\n                        points[handleIndex] = resizeState.endPoint;\n                    }\n                }\n            }\n\n            if (!hitElement) {\n                handleIndex = resizeRef.handle === ArrowLineResizeHandle.addHandle ? handleIndex + 1 : handleIndex;\n                const drawPoints = getArrowLinePoints(board, resizeRef.element);\n                const newPoints = [...points];\n                newPoints[0] = drawPoints[0];\n                newPoints[newPoints.length - 1] = drawPoints[drawPoints.length - 1];\n                if (\n                    resizeRef.element.shape !== ArrowLineShape.elbow ||\n                    (resizeRef.element.shape === ArrowLineShape.elbow && newPoints.length === 2)\n                ) {\n                    newPoints.forEach((point, index) => {\n                        if (index === handleIndex) return;\n                        if (points[handleIndex]) {\n                            points[handleIndex] = alignPoints(point, points[handleIndex]);\n                        }\n                    });\n                }\n            }\n            DrawTransforms.resizeArrowLine(board, { points, source, target }, resizeRef.path as Path);\n        },\n        afterResize: (resizeRef: ResizeRef<PlaitArrowLine, ArrowLineResizeHandle>) => {\n            if (resizeRef.element.shape === ArrowLineShape.elbow) {\n                const element = PlaitNode.get(board, resizeRef.path as Path);\n                let points = element && [...element.points!];\n                if (points.length > 2 && elbowNextRenderPoints && elbowSourcePoint && elbowTargetPoint) {\n                    const nextSourcePoint = elbowNextRenderPoints[0];\n                    const nextTargetPoint = elbowNextRenderPoints[elbowNextRenderPoints.length - 1];\n                    points.splice(0, 1, nextSourcePoint);\n                    points.splice(-1, 1, nextTargetPoint);\n                    points = simplifyOrthogonalPoints(points!);\n                    if (Point.isEquals(points[0], nextSourcePoint)) {\n                        points.splice(0, 1);\n                    }\n                    if (Point.isEquals(points[points.length - 1], nextTargetPoint)) {\n                        points.pop();\n                    }\n                    if (points.length === 1) {\n                        points = [];\n                    }\n                    points = [elbowSourcePoint, ...points, elbowTargetPoint];\n                    DrawTransforms.resizeArrowLine(board, { points }, resizeRef.path as Path);\n                }\n            }\n            elbowLineIndex = null;\n            elbowLineDeleteCount = null;\n            elbowSourcePoint = null;\n            elbowTargetPoint = null;\n            elbowNextRenderPoints = null;\n        }\n    };\n\n    withResize<PlaitArrowLine, ArrowLineResizeHandle>(board, options);\n\n    return board;\n};\n"]}

package/esm2022/plugins/with-arrow-line-text-move.mjs

@@ -0,0 +1,53 @@
+import { distanceBetweenPointAndSegments, getHitElementByPoint, getNearestPointBetweenPointAndSegments } from '@plait/core';
+import { PlaitDrawElement } from '../interfaces';
+import { ResizeHandle, getRatioByPoint, getTextManages, withResize } from '@plait/common';
+import { DrawTransforms } from '../transforms';
+import { getArrowLinePoints } from '../utils/arrow-line/arrow-line-basic';
+import { getHitArrowLineTextIndex } from '../utils/position/arrow-line';
+export const withArrowLineTextMove = (board) => {
+    let textIndex = 0;
+    const movableBuffer = 100;
+    const options = {
+        key: 'line-text',
+        canResize: () => {
+            return true;
+        },
+        hitTest: (point) => {
+            let result = null;
+            const line = getHitElementByPoint(board, point, (element) => {
+                return PlaitDrawElement.isArrowLine(element);
+            });
+            if (line) {
+                const index = getHitArrowLineTextIndex(board, line, point);
+                const textManages = getTextManages(line);
+                const textManage = textManages[index];
+                if (index !== -1 && !textManage.isEditing) {
+                    textIndex = index;
+                    return { element: line, handle: ResizeHandle.e };
+                }
+            }
+            return result;
+        },
+        onResize: (resizeRef, resizeState) => {
+            const element = resizeRef.element;
+            if (element) {
+                const movingPoint = resizeState.endPoint;
+                const points = getArrowLinePoints(board, element);
+                const distance = distanceBetweenPointAndSegments(points, movingPoint);
+                if (distance <= movableBuffer) {
+                    const point = getNearestPointBetweenPointAndSegments(movingPoint, points, false);
+                    const position = getRatioByPoint(points, point);
+                    const texts = [...element.texts];
+                    texts[textIndex] = {
+                        ...texts[textIndex],
+                        position
+                    };
+                    DrawTransforms.setArrowLineTexts(board, element, texts);
+                }
+            }
+        }
+    };
+    withResize(board, options);
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,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