@plait/draw 0.1.0-next.3 → 0.1.0-next.4

package/esm2022/utils/line.mjs

@@ -1,9 +1,10 @@
-import { idCreator, distanceBetweenPointAndSegments, PlaitBoard, createG, arrowPoints, drawLinearPath, getElementById, RectangleClient } from '@plait/core';
-import { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline } from '@plait/common';
-import { LineMarkerType } from '../interfaces';
+import { idCreator, distanceBetweenPointAndSegments, PlaitBoard, createG, arrowPoints, drawLinearPath, getElementById, RectangleClient, setPathStrokeLinecap } from '@plait/core';
+import { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline, getDirectionFactor, getDirectionBetweenPointAndPoint } from '@plait/common';
+import { LineMarkerType, PlaitLine } from '../interfaces';
 import { getPointsByCenterPoint, getNearestPoint } from './geometry';
 import { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './geometry-style/stroke';
 import { getEngine } from './engine';
+const BOUNDED_HANDLE_OFFSET = 0.5;
 export const createLineElement = (shape, points, source, target, options) => {
     return {
         id: idCreator(),
@@ -67,26 +68,32 @@ export const drawElbowLine = (board, element) => {
     const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);
     const path = elbowLine.querySelector('path');
     path?.setAttribute('mask', `url(#${element.id})`);
+    setPathStrokeLinecap(elbowLine, 'square');
     lineG.appendChild(elbowLine);
     const arrow = drawLineArrow(element, points, options);
     arrow && lineG.appendChild(arrow);
     return lineG;
 };
 export const drawLineArrow = (element, points, options) => {
-    const sourceMarker = element.source.marker;
-    const targetMarker = element.target.marker;
     const arrowG = createG();
-    if (sourceMarker === LineMarkerType.none && targetMarker === LineMarkerType.none)
+    if (PlaitLine.isSourceMark(element, LineMarkerType.none) && PlaitLine.isTargetMark(element, LineMarkerType.none)) {
         return null;
-    if (sourceMarker === LineMarkerType.arrow) {
+    }
+    if (PlaitLine.isSourceMark(element, LineMarkerType.arrow)) {
         const sourcePoint = points[0];
-        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 10, 20);
+        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 12, 40);
         const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);
         arrowG.appendChild(sourceArrow);
     }
-    if (targetMarker === LineMarkerType.arrow) {
-        const endPoint = points[points.length - 1];
-        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 10, 20);
+    if (PlaitLine.isTargetMark(element, LineMarkerType.arrow)) {
+        const _endPoint = points[points.length - 1];
+        const arrowDirection = getDirectionBetweenPointAndPoint(points[points.length - 2], _endPoint);
+        const directionFactor = getDirectionFactor(arrowDirection);
+        const endPoint = [
+            _endPoint[0] + BOUNDED_HANDLE_OFFSET * directionFactor.x,
+            _endPoint[1] + BOUNDED_HANDLE_OFFSET * directionFactor.y
+        ];
+        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 12, 40);
         const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);
         arrowG.appendChild(targetArrow);
     }
@@ -94,24 +101,29 @@ export const drawLineArrow = (element, points, options) => {
 };
 export const getSourcePoint = (board, element) => {
     if (element.source.boundId) {
+        const connectionOffset = PlaitLine.isSourceMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;
         const boundElement = getElementById(board, element.source.boundId);
-        return boundElement ? normalizeConnection(boundElement, element.source.connection) : element.points[0];
+        return boundElement ? getConnectionPoint(boundElement, element.source.connection, connectionOffset) : element.points[0];
     }
     return element.points[0];
 };
 export const getTargetPoint = (board, element) => {
     if (element.target.boundId) {
+        const connectionOffset = PlaitLine.isTargetMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;
         const boundElement = getElementById(board, element.target.boundId);
-        return boundElement ? normalizeConnection(boundElement, element.target.connection) : element.points[element.points.length - 1];
+        return boundElement
+            ? getConnectionPoint(boundElement, element.target.connection, connectionOffset)
+            : element.points[element.points.length - 1];
     }
     return element.points[element.points.length - 1];
 };
-export const normalizeConnection = (geometry, connection) => {
+export const getConnectionPoint = (geometry, connection, offset) => {
     const rectangle = getRectangleByPoints(geometry.points);
     const strokeWidth = getStrokeWidthByElement(geometry);
+    const directionFactor = getDirectionFactor(getDirectionByPoint(connection, Direction.bottom));
     return [
-        rectangle.x - strokeWidth / 2 + (rectangle.width + strokeWidth) * connection[0],
-        rectangle.y - strokeWidth / 2 + (rectangle.height + strokeWidth) * connection[1]
+        rectangle.x + rectangle.width * connection[0] + strokeWidth * directionFactor.x + offset * directionFactor.x,
+        rectangle.y + rectangle.height * connection[1] + strokeWidth * directionFactor.y + offset * directionFactor.y
     ];
 };
 export const transformPointToConnection = (board, point, hitElement) => {
@@ -142,4 +154,4 @@ export const getLineTextRectangle = (board, element, index) => {
         height: text.height
     };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/line.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Point,\n    idCreator,\n    distanceBetweenPointAndSegments,\n    PlaitBoard,\n    createG,\n    arrowPoints,\n    drawLinearPath,\n    getElementById,\n    RectangleClient\n} from '@plait/core';\nimport { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline } from '@plait/common';\nimport { LineHandle, LineMarkerType, LineShape, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { Options } from 'roughjs/bin/core';\nimport { getPointsByCenterPoint, getNearestPoint } from './geometry';\nimport { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './geometry-style/stroke';\nimport { getEngine } from './engine';\n\nexport const createLineElement = (\n    shape: LineShape,\n    points: [Point, Point],\n    source: LineHandle,\n    target: LineHandle,\n    options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>\n): PlaitLine => {\n    return {\n        id: idCreator(),\n        type: 'line',\n        shape,\n        source,\n        texts: [],\n        target,\n        opacity: 1,\n        points,\n        ...options\n    };\n};\n\nexport const getElbowPoints = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.points.length === 2) {\n        const source = getSourcePoint(board, element);\n        const target = getTargetPoint(board, element);\n        let sourceDirection = source[0] < target[0] ? Direction.right : Direction.left;\n        let targetDirection = source[0] < target[0] ? Direction.left : Direction.right;\n        if (element.source.connection) {\n            sourceDirection = getDirectionByPoint(element.source.connection, sourceDirection);\n        }\n        if (element.target.connection) {\n            targetDirection = getDirectionByPoint(element.target.connection, targetDirection);\n        }\n        const points: Point[] = getPoints(source, sourceDirection, target, targetDirection, 30);\n        return points;\n    }\n    return element.points;\n};\n\nexport const isHitPolyLine = (pathPoints: Point[], point: Point, strokeWidth: number, expand: number = 0) => {\n    const distance = distanceBetweenPointAndSegments(pathPoints, point);\n    return distance <= strokeWidth + expand;\n};\n\nexport const getHitLineTextIndex = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    const texts = element.texts;\n    if (!texts.length) return -1;\n\n    const points = getElbowPoints(board, element);\n    return texts.findIndex(text => {\n        const center = getPointOnPolyline(points, text.position);\n        const rectangle = {\n            x: center[0] - text.width! / 2,\n            y: center[1] - text.height! / 2,\n            width: text.width!,\n            height: text.height!\n        };\n        return RectangleClient.isHit(rectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const isHitLineText = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    return getHitLineTextIndex(board, element, point) !== -1;\n};\n\nexport const drawElbowLine = (board: PlaitBoard, element: PlaitLine) => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const strokeColor = getStrokeColorByElement(element);\n    const strokeLineDash = getLineDashByElement(element);\n    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };\n    const lineG = createG();\n    const points = getElbowPoints(board, element);\n    const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);\n    const path = elbowLine.querySelector('path');\n    path?.setAttribute('mask', `url(#${element.id})`);\n    lineG.appendChild(elbowLine);\n    const arrow = drawLineArrow(element, points, options);\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nexport const drawLineArrow = (element: PlaitLine, points: Point[], options: Options) => {\n    const sourceMarker = element.source.marker;\n    const targetMarker = element.target.marker;\n    const arrowG = createG();\n    if (sourceMarker === LineMarkerType.none && targetMarker === LineMarkerType.none) return null;\n    if (sourceMarker === LineMarkerType.arrow) {\n        const sourcePoint = points[0];\n        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 10, 20);\n        const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);\n        arrowG.appendChild(sourceArrow);\n    }\n    if (targetMarker === LineMarkerType.arrow) {\n        const endPoint = points[points.length - 1];\n        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 10, 20);\n        const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);\n        arrowG.appendChild(targetArrow);\n    }\n    return arrowG;\n};\n\nexport const getSourcePoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.source.boundId) {\n        const boundElement = getElementById<PlaitGeometry>(board, element.source.boundId);\n        return boundElement ? normalizeConnection(boundElement, element.source.connection!) : element.points[0];\n    }\n    return element.points[0];\n};\n\nexport const getTargetPoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.target.boundId) {\n        const boundElement = getElementById<PlaitGeometry>(board, element.target.boundId);\n        return boundElement ? normalizeConnection(boundElement, element.target.connection!) : element.points[element.points.length - 1];\n    }\n    return element.points[element.points.length - 1];\n};\n\nexport const normalizeConnection = (geometry: PlaitGeometry, connection: Point): Point => {\n    const rectangle = getRectangleByPoints(geometry.points);\n    const strokeWidth = getStrokeWidthByElement(geometry);\n    return [\n        rectangle.x - strokeWidth / 2 + (rectangle.width + strokeWidth) * connection[0],\n        rectangle.y - strokeWidth / 2 + (rectangle.height + strokeWidth) * connection[1]\n    ];\n};\n\nexport const transformPointToConnection = (board: PlaitBoard, point: Point, hitElement: PlaitGeometry): Point => {\n    const offset = (getStrokeWidthByElement(hitElement) + 1) / 2;\n    let rectangle = getRectangleByPoints(hitElement.points);\n    rectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);\n    let nearestPoint = getNearestPoint(hitElement, point, offset);\n    const hitConnector = getHitConnectorPoint(nearestPoint, hitElement, rectangle);\n    nearestPoint = hitConnector ? hitConnector : nearestPoint;\n    return [(nearestPoint[0] - rectangle.x) / rectangle.width, (nearestPoint[1] - rectangle.y) / rectangle.height];\n};\n\nexport const getHitConnectorPoint = (movingPoint: Point, hitElement: PlaitGeometry, rectangle: RectangleClient) => {\n    const connector = getEngine(hitElement.shape).getConnectorPoints(rectangle);\n    const points = getPointsByCenterPoint(movingPoint, 5, 5);\n    const pointRectangle = getRectangleByPoints(points);\n    return connector.find(point => {\n        return RectangleClient.isHit(pointRectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const getLineTextRectangle = (board: PlaitBoard, element: PlaitLine, index: number): RectangleClient => {\n    const text = element.texts[index];\n    const elbowPoints = getElbowPoints(board, element);\n    const point = getPointOnPolyline(elbowPoints, text.position);\n    return {\n        x: point[0] - text.width! / 2,\n        y: point[1] - text.height! / 2,\n        width: text.width!,\n        height: text.height!\n    };\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/line.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Point,\n    idCreator,\n    distanceBetweenPointAndSegments,\n    PlaitBoard,\n    createG,\n    arrowPoints,\n    drawLinearPath,\n    getElementById,\n    RectangleClient,\n    setPathStrokeLinecap\n} from '@plait/core';\nimport {\n    getPoints,\n    Direction,\n    getRectangleByPoints,\n    getDirectionByPoint,\n    getPointOnPolyline,\n    getDirectionFactor,\n    getDirectionBetweenPointAndPoint\n} from '@plait/common';\nimport { LineHandle, LineMarkerType, LineShape, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { Options } from 'roughjs/bin/core';\nimport { getPointsByCenterPoint, getNearestPoint } from './geometry';\nimport { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './geometry-style/stroke';\nimport { getEngine } from './engine';\n\nconst BOUNDED_HANDLE_OFFSET = 0.5;\n\nexport const createLineElement = (\n    shape: LineShape,\n    points: [Point, Point],\n    source: LineHandle,\n    target: LineHandle,\n    options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>\n): PlaitLine => {\n    return {\n        id: idCreator(),\n        type: 'line',\n        shape,\n        source,\n        texts: [],\n        target,\n        opacity: 1,\n        points,\n        ...options\n    };\n};\n\nexport const getElbowPoints = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.points.length === 2) {\n        const source = getSourcePoint(board, element);\n        const target = getTargetPoint(board, element);\n        let sourceDirection = source[0] < target[0] ? Direction.right : Direction.left;\n        let targetDirection = source[0] < target[0] ? Direction.left : Direction.right;\n        if (element.source.connection) {\n            sourceDirection = getDirectionByPoint(element.source.connection, sourceDirection);\n        }\n        if (element.target.connection) {\n            targetDirection = getDirectionByPoint(element.target.connection, targetDirection);\n        }\n        const points: Point[] = getPoints(source, sourceDirection, target, targetDirection, 30);\n        return points;\n    }\n    return element.points;\n};\n\nexport const isHitPolyLine = (pathPoints: Point[], point: Point, strokeWidth: number, expand: number = 0) => {\n    const distance = distanceBetweenPointAndSegments(pathPoints, point);\n    return distance <= strokeWidth + expand;\n};\n\nexport const getHitLineTextIndex = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    const texts = element.texts;\n    if (!texts.length) return -1;\n\n    const points = getElbowPoints(board, element);\n    return texts.findIndex(text => {\n        const center = getPointOnPolyline(points, text.position);\n        const rectangle = {\n            x: center[0] - text.width! / 2,\n            y: center[1] - text.height! / 2,\n            width: text.width!,\n            height: text.height!\n        };\n        return RectangleClient.isHit(rectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const isHitLineText = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    return getHitLineTextIndex(board, element, point) !== -1;\n};\n\nexport const drawElbowLine = (board: PlaitBoard, element: PlaitLine) => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const strokeColor = getStrokeColorByElement(element);\n    const strokeLineDash = getLineDashByElement(element);\n    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };\n    const lineG = createG();\n    const points = getElbowPoints(board, element);\n    const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);\n    const path = elbowLine.querySelector('path');\n    path?.setAttribute('mask', `url(#${element.id})`);\n    setPathStrokeLinecap(elbowLine, 'square');\n    lineG.appendChild(elbowLine);\n    const arrow = drawLineArrow(element, points, options);\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nexport const drawLineArrow = (element: PlaitLine, points: Point[], options: Options) => {\n    const arrowG = createG();\n    if (PlaitLine.isSourceMark(element, LineMarkerType.none) && PlaitLine.isTargetMark(element, LineMarkerType.none)) {\n        return null;\n    }\n    if (PlaitLine.isSourceMark(element, LineMarkerType.arrow)) {\n        const sourcePoint = points[0];\n        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 12, 40);\n        const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);\n        arrowG.appendChild(sourceArrow);\n    }\n    if (PlaitLine.isTargetMark(element, LineMarkerType.arrow)) {\n        const _endPoint = points[points.length - 1];\n        const arrowDirection = getDirectionBetweenPointAndPoint(points[points.length - 2], _endPoint);\n        const directionFactor = getDirectionFactor(arrowDirection);\n        const endPoint: Point = [\n            _endPoint[0] + BOUNDED_HANDLE_OFFSET * directionFactor.x,\n            _endPoint[1] + BOUNDED_HANDLE_OFFSET * directionFactor.y\n        ];\n        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 12, 40);\n        const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);\n        arrowG.appendChild(targetArrow);\n    }\n    return arrowG;\n};\n\nexport const getSourcePoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.source.boundId) {\n        const connectionOffset = PlaitLine.isSourceMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;\n        const boundElement = getElementById<PlaitGeometry>(board, element.source.boundId);\n        return boundElement ? getConnectionPoint(boundElement, element.source.connection!, connectionOffset) : element.points[0];\n    }\n    return element.points[0];\n};\n\nexport const getTargetPoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.target.boundId) {\n        const connectionOffset = PlaitLine.isTargetMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;\n        const boundElement = getElementById<PlaitGeometry>(board, element.target.boundId);\n        return boundElement\n            ? getConnectionPoint(boundElement, element.target.connection!, connectionOffset)\n            : element.points[element.points.length - 1];\n    }\n    return element.points[element.points.length - 1];\n};\n\nexport const getConnectionPoint = (geometry: PlaitGeometry, connection: Point, offset: number): Point => {\n    const rectangle = getRectangleByPoints(geometry.points);\n    const strokeWidth = getStrokeWidthByElement(geometry);\n    const directionFactor = getDirectionFactor(getDirectionByPoint(connection, Direction.bottom));\n    return [\n        rectangle.x + rectangle.width * connection[0] + strokeWidth * directionFactor.x + offset * directionFactor.x,\n        rectangle.y + rectangle.height * connection[1] + strokeWidth * directionFactor.y + offset * directionFactor.y\n    ];\n};\n\nexport const transformPointToConnection = (board: PlaitBoard, point: Point, hitElement: PlaitGeometry): Point => {\n    const offset = (getStrokeWidthByElement(hitElement) + 1) / 2;\n    let rectangle = getRectangleByPoints(hitElement.points);\n    rectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);\n    let nearestPoint = getNearestPoint(hitElement, point, offset);\n    const hitConnector = getHitConnectorPoint(nearestPoint, hitElement, rectangle);\n    nearestPoint = hitConnector ? hitConnector : nearestPoint;\n    return [(nearestPoint[0] - rectangle.x) / rectangle.width, (nearestPoint[1] - rectangle.y) / rectangle.height];\n};\n\nexport const getHitConnectorPoint = (movingPoint: Point, hitElement: PlaitGeometry, rectangle: RectangleClient) => {\n    const connector = getEngine(hitElement.shape).getConnectorPoints(rectangle);\n    const points = getPointsByCenterPoint(movingPoint, 5, 5);\n    const pointRectangle = getRectangleByPoints(points);\n    return connector.find(point => {\n        return RectangleClient.isHit(pointRectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const getLineTextRectangle = (board: PlaitBoard, element: PlaitLine, index: number): RectangleClient => {\n    const text = element.texts[index];\n    const elbowPoints = getElbowPoints(board, element);\n    const point = getPointOnPolyline(elbowPoints, text.position);\n    return {\n        x: point[0] - text.width! / 2,\n        y: point[1] - text.height! / 2,\n        width: text.width!,\n        height: text.height!\n    };\n};\n"]}

package/fesm2022/plait-draw.mjs

@@ -1,8 +1,8 @@
-import { PlaitElement, RectangleClient, PlaitBoard, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, idCreator, createG, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, distanceBetweenPointAndSegments, arrowPoints, drawLinearPath, getElementById, getSelectedElements, Transforms, clearSelectedElement, addSelectedElement, PlaitNode, Point, PlaitPluginElementComponent, isSelectionMoving, createMask, createRect, transformPoint, toPoint, BoardTransforms, PlaitPointerType, preventTouchMove, createForeignObject, setClipboardData, getDataFromClipboard, depthFirstRecursion, getIsRecursionFunc, getHitElements, isPolylineHitRectangle } from '@plait/core';
+import { PlaitElement, RectangleClient, PlaitBoard, setStrokeLinecap, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, idCreator, createG, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, distanceBetweenPointAndSegments, setPathStrokeLinecap, arrowPoints, drawLinearPath, getElementById, getSelectedElements, Transforms, clearSelectedElement, addSelectedElement, PlaitNode, Point, PlaitPluginElementComponent, isSelectionMoving, createMask, createRect, transformPoint, toPoint, BoardTransforms, PlaitPointerType, preventTouchMove, createForeignObject, setClipboardData, getDataFromClipboard, depthFirstRecursion, getIsRecursionFunc, getHitElements, isPolylineHitRectangle } from '@plait/core';
 import * as i0 from '@angular/core';
 import { Component, ChangeDetectionStrategy } from '@angular/core';
 import { Subject } from 'rxjs';
-import { getRectangleByPoints, Direction, getDirectionByPoint, getPoints, getPointOnPolyline, Generator, normalizeShapePoints, ActiveGenerator, RESIZE_HANDLE_DIAMETER, isVirtualKey, isSpaceHotkey, CommonTransforms, getRectangleResizeHandleRefs, ResizeHandle, withResize, isResizingByCondition, getRatioByPoint } from '@plait/common';
+import { getRectangleByPoints, Direction, getDirectionByPoint, getPoints, getPointOnPolyline, getDirectionBetweenPointAndPoint, getDirectionFactor, Generator, normalizeShapePoints, ActiveGenerator, RESIZE_HANDLE_DIAMETER, isVirtualKey, isSpaceHotkey, isDndMode, isDrawingMode, CommonTransforms, getRectangleResizeHandleRefs, ResizeHandle, withResize, isResizingByCondition, getRatioByPoint } from '@plait/common';
 import { Alignment, buildText, AlignEditor, TextManage, DEFAULT_FONT_SIZE, getTextFromClipboard, getTextSize } from '@plait/text';
 import { isKeyHotkey } from 'is-hotkey';
 import { Node } from 'slate';
@@ -37,6 +37,27 @@ var LineShape;
     LineShape["curve"] = "curve";
     LineShape["elbow"] = "elbow";
 })(LineShape || (LineShape = {}));
+const PlaitLine = {
+    getTextEditors(element) {
+        const component = PlaitElement.getComponent(element);
+        if (component) {
+            const manage = component.textManages.find(manage => manage.isEditing);
+            if (manage) {
+                return [manage.componentRef.instance.editor];
+            }
+            else {
+                return component.textManages.map(manage => manage.componentRef.instance.editor);
+            }
+        }
+        throw new Error('can not get correctly component in get text editor');
+    },
+    isSourceMark(line, markType) {
+        return line.source.marker === markType;
+    },
+    isTargetMark(line, markType) {
+        return line.target.marker === markType;
+    }
+};
 
 const PlaitDrawElement = {
     isGeometry: (value) => {
@@ -125,7 +146,9 @@ const DiamondEngine = {
     draw(board, rectangle, options) {
         const points = RectangleClient.getEdgeCenterPoints(rectangle);
         const rs = PlaitBoard.getRoughSVG(board);
-        return rs.polygon(points, { ...options, fillStyle: 'solid' });
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
     },
     isHit(rectangle, point) {
         const controlPoints = RectangleClient.getEdgeCenterPoints(rectangle);
@@ -198,7 +221,9 @@ const ParallelogramEngine = {
     draw(board, rectangle, options) {
         const points = getParallelogramPoints(rectangle);
         const rs = PlaitBoard.getRoughSVG(board);
-        return rs.polygon(points, { ...options, fillStyle: 'solid' });
+        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
+        setStrokeLinecap(polygon, 'round');
+        return polygon;
     },
     isHit(rectangle, point) {
         const parallelogramPoints = getParallelogramPoints(rectangle);
@@ -375,6 +400,7 @@ const getCenterPointsOnPolygon = (points) => {
     return centerPoint;
 };
 
+const BOUNDED_HANDLE_OFFSET = 0.5;
 const createLineElement = (shape, points, source, target, options) => {
     return {
         id: idCreator(),
@@ -438,26 +464,32 @@ const drawElbowLine = (board, element) => {
     const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);
     const path = elbowLine.querySelector('path');
     path?.setAttribute('mask', `url(#${element.id})`);
+    setPathStrokeLinecap(elbowLine, 'square');
     lineG.appendChild(elbowLine);
     const arrow = drawLineArrow(element, points, options);
     arrow && lineG.appendChild(arrow);
     return lineG;
 };
 const drawLineArrow = (element, points, options) => {
-    const sourceMarker = element.source.marker;
-    const targetMarker = element.target.marker;
     const arrowG = createG();
-    if (sourceMarker === LineMarkerType.none && targetMarker === LineMarkerType.none)
+    if (PlaitLine.isSourceMark(element, LineMarkerType.none) && PlaitLine.isTargetMark(element, LineMarkerType.none)) {
         return null;
-    if (sourceMarker === LineMarkerType.arrow) {
+    }
+    if (PlaitLine.isSourceMark(element, LineMarkerType.arrow)) {
         const sourcePoint = points[0];
-        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 10, 20);
+        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 12, 40);
         const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);
         arrowG.appendChild(sourceArrow);
     }
-    if (targetMarker === LineMarkerType.arrow) {
-        const endPoint = points[points.length - 1];
-        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 10, 20);
+    if (PlaitLine.isTargetMark(element, LineMarkerType.arrow)) {
+        const _endPoint = points[points.length - 1];
+        const arrowDirection = getDirectionBetweenPointAndPoint(points[points.length - 2], _endPoint);
+        const directionFactor = getDirectionFactor(arrowDirection);
+        const endPoint = [
+            _endPoint[0] + BOUNDED_HANDLE_OFFSET * directionFactor.x,
+            _endPoint[1] + BOUNDED_HANDLE_OFFSET * directionFactor.y
+        ];
+        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 12, 40);
         const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);
         arrowG.appendChild(targetArrow);
     }
@@ -465,24 +497,29 @@ const drawLineArrow = (element, points, options) => {
 };
 const getSourcePoint = (board, element) => {
     if (element.source.boundId) {
+        const connectionOffset = PlaitLine.isSourceMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;
         const boundElement = getElementById(board, element.source.boundId);
-        return boundElement ? normalizeConnection(boundElement, element.source.connection) : element.points[0];
+        return boundElement ? getConnectionPoint(boundElement, element.source.connection, connectionOffset) : element.points[0];
     }
     return element.points[0];
 };
 const getTargetPoint = (board, element) => {
     if (element.target.boundId) {
+        const connectionOffset = PlaitLine.isTargetMark(element, LineMarkerType.arrow) ? BOUNDED_HANDLE_OFFSET : 0;
         const boundElement = getElementById(board, element.target.boundId);
-        return boundElement ? normalizeConnection(boundElement, element.target.connection) : element.points[element.points.length - 1];
+        return boundElement
+            ? getConnectionPoint(boundElement, element.target.connection, connectionOffset)
+            : element.points[element.points.length - 1];
     }
     return element.points[element.points.length - 1];
 };
-const normalizeConnection = (geometry, connection) => {
+const getConnectionPoint = (geometry, connection, offset) => {
     const rectangle = getRectangleByPoints(geometry.points);
     const strokeWidth = getStrokeWidthByElement(geometry);
+    const directionFactor = getDirectionFactor(getDirectionByPoint(connection, Direction.bottom));
     return [
-        rectangle.x - strokeWidth / 2 + (rectangle.width + strokeWidth) * connection[0],
-        rectangle.y - strokeWidth / 2 + (rectangle.height + strokeWidth) * connection[1]
+        rectangle.x + rectangle.width * connection[0] + strokeWidth * directionFactor.x + offset * directionFactor.x,
+        rectangle.y + rectangle.height * connection[1] + strokeWidth * directionFactor.y + offset * directionFactor.y
     ];
 };
 const transformPointToConnection = (board, point, hitElement) => {
@@ -514,19 +551,6 @@ const getLineTextRectangle = (board, element, index) => {
     };
 };
 
-var DrawCreateMode;
-(function (DrawCreateMode) {
-    DrawCreateMode["drag"] = "drag";
-    DrawCreateMode["draw"] = "draw";
-})(DrawCreateMode || (DrawCreateMode = {}));
-const BOARD_TO_CREATE_MODE = new WeakMap();
-const getCreateMode = (board) => {
-    return BOARD_TO_CREATE_MODE.get(board);
-};
-const setCreateMode = (board, mode) => {
-    BOARD_TO_CREATE_MODE.set(board, mode);
-};
-
 const getSelectedDrawElements = (board) => {
     const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isDrawElement(value));
     return selectedElements;
@@ -686,7 +710,7 @@ class GeometryComponent extends PlaitPluginElementComponent {
             },
             hasResizeHandle: () => {
                 const selectedElements = getSelectedElements(this.board);
-                if (PlaitBoard.hasBeenTextEditing(this.board)) {
+                if (PlaitBoard.hasBeenTextEditing(this.board) && PlaitDrawElement.isText(this.element)) {
                     return false;
                 }
                 return selectedElements.length === 1 && !isSelectionMoving(this.board);
@@ -982,7 +1006,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImpor
         }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; } });
 
 const withDrawHotkey = (board) => {
-    const { keydown } = board;
+    const { keydown, dblclick } = board;
     board.keydown = (event) => {
         const selectedElements = getSelectedElements(board);
         const isSingleSelection = selectedElements.length === 1;
@@ -994,20 +1018,27 @@ const withDrawHotkey = (board) => {
         }
         keydown(event);
     };
+    board.dblclick = (event) => {
+        event.preventDefault();
+        const geometries = getSelectedGeometryElements(board);
+        if (geometries.length === 1) {
+            const component = PlaitElement.getComponent(geometries[0]);
+            component.editText();
+        }
+        dblclick(event);
+    };
     return board;
 };
 
 const withGeometryCreateByDrag = (board) => {
     const { pointerMove, pointerUp } = board;
-    let createMode = undefined;
     let geometryShapeG = null;
     board.pointerMove = (event) => {
         geometryShapeG?.remove();
         geometryShapeG = createG();
-        createMode = getCreateMode(board);
         const geometryGenerator = new GeometryShapeGenerator(board);
         const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
-        const dragMode = isGeometryPointer && createMode === DrawCreateMode.drag;
+        const dragMode = isGeometryPointer && isDndMode(board);
         const movingPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
         const pointer = PlaitBoard.getPointer(board);
         if (dragMode) {
@@ -1031,7 +1062,7 @@ const withGeometryCreateByDrag = (board) => {
     board.pointerUp = (event) => {
         const pointer = PlaitBoard.getPointer(board);
         const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
-        const dragMode = isGeometryPointer && createMode === DrawCreateMode.drag;
+        const dragMode = isGeometryPointer && isDndMode(board);
         if (dragMode) {
             const targetPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
             const points = getDefaultGeometryPoints(pointer, targetPoint);
@@ -1065,9 +1096,8 @@ const withGeometryCreateByDraw = (board) => {
         keyup(event);
     };
     board.pointerDown = (event) => {
-        const createMode = getCreateMode(board);
         const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
-        if (isGeometryPointer && createMode === DrawCreateMode.draw) {
+        if (isGeometryPointer && isDrawingMode(board)) {
             const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
             start = point;
             preventTouchMove(board, true);
@@ -1254,9 +1284,8 @@ const withLineCreateByDraw = (board) => {
     let lineShapeG = null;
     let temporaryElement = null;
     board.pointerDown = (event) => {
-        const createMode = getCreateMode(board);
         const isLinePointer = PlaitBoard.isPointer(board, DrawPointerType.line);
-        if (isLinePointer && createMode === DrawCreateMode.draw) {
+        if (isLinePointer && isDrawingMode(board)) {
             const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
             start = point;
             const hitElement = getHitOutlineGeometry(board, point, -4);
@@ -1583,14 +1612,6 @@ const withDraw = (board) => {
         }
         return isMovable(element);
     };
-    board.dblclick = (event) => {
-        const element = getSelectedElements(board)[0];
-        if (element && PlaitDrawElement.isGeometry(element)) {
-            const component = PlaitElement.getComponent(element);
-            component.editText();
-        }
-        dblclick(event);
-    };
     return withLineText(withLineBoundReaction(withLineResize(withGeometryResize(withLineCreateByDraw(withGeometryCreateByDrag(withGeometryCreateByDraw(withDrawFragment(withDrawHotkey(board)))))))));
 };
 
@@ -1598,5 +1619,5 @@ const withDraw = (board) => {
  * Generated bundle index. Do not edit.
  */
 
-export { DefaultGeometryActiveStyle, DefaultGeometryProperty, DefaultGeometryStyle, DefaultTextProperty, DrawCreateMode, DrawPointerType, GeometryPointer, GeometryShape, GeometryThreshold, LineMarkerType, LineShape, PlaitDrawElement, PlaitGeometry, ShapeDefaultSpace, createGeometryElement, createLineElement, drawBoundMask, drawElbowLine, drawGeometry, drawLineArrow, getCenterPointsOnPolygon, getCreateMode, getElbowPoints, getHitConnectorPoint, getHitLineTextIndex, getLineTextRectangle, getNearestPoint, getPointsByCenterPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedLineElements, getSourcePoint, getTargetPoint, getTextRectangle, isHitLineText, isHitPolyLine, normalizeConnection, setCreateMode, transformPointToConnection, withDraw };
+export { DefaultGeometryActiveStyle, DefaultGeometryProperty, DefaultGeometryStyle, DefaultTextProperty, DrawPointerType, GeometryComponent, GeometryPointer, GeometryShape, GeometryThreshold, LineComponent, LineMarkerType, LineShape, PlaitDrawElement, PlaitGeometry, PlaitLine, ShapeDefaultSpace, createGeometryElement, createLineElement, drawBoundMask, drawElbowLine, drawGeometry, drawLineArrow, getCenterPointsOnPolygon, getConnectionPoint, getElbowPoints, getHitConnectorPoint, getHitLineTextIndex, getLineTextRectangle, getNearestPoint, getPointsByCenterPoint, getSelectedDrawElements, getSelectedGeometryElements, getSelectedLineElements, getSourcePoint, getTargetPoint, getTextRectangle, isHitLineText, isHitPolyLine, transformPointToConnection, withDraw };
 //# sourceMappingURL=plait-draw.mjs.map