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

package/esm2022/utils/arrow-line/arrow-line-basic.mjs

@@ -0,0 +1,257 @@
+import { Point, idCreator, PlaitBoard, createG, RectangleClient, findElements, drawLinearPath, createMask, createRect, distanceBetweenPointAndPoint, catmullRomFitting, setStrokeLinecap } from '@plait/core';
+import { pointsOnBezierCurves } from 'points-on-curve';
+import { getPointOnPolyline, getPointByVectorComponent, removeDuplicatePoints, getExtendPoint } from '@plait/common';
+import { ArrowLineMarkerType, ArrowLineShape, PlaitArrowLine, PlaitDrawElement, StrokeStyle } from '../../interfaces';
+import { getLineDashByElement, getStrokeColorByElement } from '../style/stroke';
+import { getEngine } from '../../engines';
+import { getElementShape } from '../shape';
+import { DefaultLineStyle, LINE_TEXT_SPACE } from '../../constants/line';
+import { ArrowLineShapeGenerator } from '../../generators/arrow-line.generator';
+import { LINE_SNAPPING_CONNECTOR_BUFFER } from '../../constants';
+import { getLineMemorizedLatest } from '../memorize';
+import { alignPoints } from './arrow-line-resize';
+import { getElbowLineRouteOptions, getArrowLineHandleRefPair } from './arrow-line-common';
+import { getElbowPoints, getNextSourceAndTargetPoints, isUseDefaultOrthogonalRoute } from './elbow';
+import { drawArrowLineArrow } from './arrow-line-arrow';
+import { getSnappingRef, getSnappingShape, getStrokeWidthByElement } from '../common';
+export const createArrowLineElement = (shape, points, source, target, texts, options) => {
+    return {
+        id: idCreator(),
+        type: 'arrow-line',
+        shape,
+        source,
+        texts: texts ? texts : [],
+        target,
+        opacity: 1,
+        points,
+        ...options
+    };
+};
+export const getArrowLinePoints = (board, element) => {
+    switch (element.shape) {
+        case ArrowLineShape.elbow: {
+            return getElbowPoints(board, element);
+        }
+        case ArrowLineShape.curve: {
+            return getCurvePoints(board, element);
+        }
+        default: {
+            const points = PlaitArrowLine.getPoints(board, element);
+            const handleRefPair = getArrowLineHandleRefPair(board, element);
+            points[0] = handleRefPair.source.point;
+            points[points.length - 1] = handleRefPair.target.point;
+            return points;
+        }
+    }
+};
+export const getCurvePoints = (board, element) => {
+    if (element.points.length === 2) {
+        const handleRefPair = getArrowLineHandleRefPair(board, element);
+        const { source, target } = handleRefPair;
+        const sourceBoundElement = handleRefPair.source.boundElement;
+        const targetBoundElement = handleRefPair.target.boundElement;
+        let curvePoints = [source.point];
+        const sumDistance = distanceBetweenPointAndPoint(...source.point, ...target.point);
+        const offset = 12 + sumDistance / 3;
+        if (sourceBoundElement) {
+            curvePoints.push(getPointByVectorComponent(source.point, source.vector, offset));
+        }
+        if (targetBoundElement) {
+            curvePoints.push(getPointByVectorComponent(target.point, target.vector, offset));
+        }
+        const isSingleBound = (sourceBoundElement && !targetBoundElement) || (!sourceBoundElement && targetBoundElement);
+        if (isSingleBound) {
+            curvePoints.push(target.point);
+            const points = Q2C(curvePoints);
+            return pointsOnBezierCurves(points);
+        }
+        if (!sourceBoundElement && !targetBoundElement) {
+            curvePoints.push(getPointByVectorComponent(source.point, source.vector, offset));
+            curvePoints.push(getPointByVectorComponent(target.point, target.vector, offset));
+        }
+        curvePoints.push(target.point);
+        return pointsOnBezierCurves(curvePoints);
+    }
+    else {
+        let dataPoints = PlaitArrowLine.getPoints(board, element);
+        dataPoints = removeDuplicatePoints(dataPoints);
+        const points = catmullRomFitting(dataPoints);
+        return pointsOnBezierCurves(points);
+    }
+};
+export function getMiddlePoints(board, element) {
+    const result = [];
+    const shape = element.shape;
+    const hideBuffer = 10;
+    if (shape === ArrowLineShape.straight) {
+        const points = PlaitArrowLine.getPoints(board, element);
+        for (let i = 0; i < points.length - 1; i++) {
+            const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
+            if (distance < hideBuffer)
+                continue;
+            result.push([(points[i][0] + points[i + 1][0]) / 2, (points[i][1] + points[i + 1][1]) / 2]);
+        }
+    }
+    if (shape === ArrowLineShape.curve) {
+        const points = PlaitArrowLine.getPoints(board, element);
+        const pointsOnBezier = getCurvePoints(board, element);
+        if (points.length === 2) {
+            const start = 0;
+            const endIndex = pointsOnBezier.length - 1;
+            const middleIndex = Math.round((start + endIndex) / 2);
+            result.push(pointsOnBezier[middleIndex]);
+        }
+        else {
+            for (let i = 0; i < points.length - 1; i++) {
+                const startIndex = pointsOnBezier.findIndex(point => point[0] === points[i][0] && point[1] === points[i][1]);
+                const endIndex = pointsOnBezier.findIndex(point => point[0] === points[i + 1][0] && point[1] === points[i + 1][1]);
+                const middleIndex = Math.round((startIndex + endIndex) / 2);
+                const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);
+                if (distance < hideBuffer)
+                    continue;
+                result.push(pointsOnBezier[middleIndex]);
+            }
+        }
+    }
+    if (shape === ArrowLineShape.elbow) {
+        const renderPoints = getElbowPoints(board, element);
+        const options = getElbowLineRouteOptions(board, element);
+        if (!isUseDefaultOrthogonalRoute(element, options)) {
+            const [nextSourcePoint, nextTargetPoint] = getNextSourceAndTargetPoints(board, element);
+            for (let i = 0; i < renderPoints.length - 1; i++) {
+                if ((i == 0 && Point.isEquals(renderPoints[i + 1], nextSourcePoint)) ||
+                    (i === renderPoints.length - 2 && Point.isEquals(renderPoints[renderPoints.length - 2], nextTargetPoint))) {
+                    continue;
+                }
+                const [currentX, currentY] = renderPoints[i];
+                const [nextX, nextY] = renderPoints[i + 1];
+                const middlePoint = [(currentX + nextX) / 2, (currentY + nextY) / 2];
+                result.push(middlePoint);
+            }
+        }
+    }
+    return result;
+}
+export const drawArrowLine = (board, element) => {
+    const strokeWidth = getStrokeWidthByElement(element);
+    const strokeColor = getStrokeColorByElement(board, element);
+    const strokeLineDash = getLineDashByElement(element);
+    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };
+    const lineG = createG();
+    let points = getArrowLinePoints(board, element);
+    let line;
+    if (element.shape === ArrowLineShape.curve) {
+        line = PlaitBoard.getRoughSVG(board).curve(points, options);
+    }
+    else {
+        line = drawLinearPath(points, options);
+    }
+    const id = idCreator();
+    line.setAttribute('mask', `url(#${id})`);
+    if (element.strokeStyle === StrokeStyle.dotted) {
+        setStrokeLinecap(line, 'round');
+    }
+    lineG.appendChild(line);
+    const { mask, maskTargetFillRect } = drawArrowLineMask(board, element, id);
+    lineG.appendChild(mask);
+    line.appendChild(maskTargetFillRect);
+    const arrow = drawArrowLineArrow(element, points, { stroke: strokeColor, strokeWidth });
+    arrow && lineG.appendChild(arrow);
+    return lineG;
+};
+export const getHitConnection = (board, point, hitElement) => {
+    let rectangle = RectangleClient.getRectangleByPoints(hitElement.points);
+    const ref = getSnappingRef(board, hitElement, point);
+    const connectionPoint = ref.connectorPoint || ref.edgePoint;
+    return [(connectionPoint[0] - rectangle.x) / rectangle.width, (connectionPoint[1] - rectangle.y) / rectangle.height];
+};
+export const getHitConnectorPoint = (point, hitElement) => {
+    const rectangle = RectangleClient.getRectangleByPoints(hitElement.points);
+    const shape = getElementShape(hitElement);
+    const connectorPoints = getEngine(shape).getConnectorPoints(rectangle);
+    return connectorPoints.find(connectorPoint => {
+        return distanceBetweenPointAndPoint(...connectorPoint, ...point) <= LINE_SNAPPING_CONNECTOR_BUFFER;
+    });
+};
+export const getArrowLineTextRectangle = (board, element, index) => {
+    const text = element.texts[index];
+    const elbowPoints = getArrowLinePoints(board, element);
+    const point = getPointOnPolyline(elbowPoints, text.position);
+    return {
+        x: point[0] - text.width / 2,
+        y: point[1] - text.height / 2,
+        width: text.width,
+        height: text.height
+    };
+};
+export const getArrowLines = (board) => {
+    return findElements(board, {
+        match: (element) => PlaitDrawElement.isArrowLine(element),
+        recursion: (element) => PlaitDrawElement.isDrawElement(element)
+    });
+};
+// quadratic Bezier to cubic Bezier
+export const Q2C = (points) => {
+    const result = [];
+    const numSegments = points.length / 3;
+    for (let i = 0; i < numSegments; i++) {
+        const start = points[i];
+        const qControl = points[i + 1];
+        const end = points[i + 2];
+        const startDistance = distanceBetweenPointAndPoint(...start, ...qControl);
+        const endDistance = distanceBetweenPointAndPoint(...end, ...qControl);
+        const cControl1 = getExtendPoint(start, qControl, (startDistance * 2) / 3);
+        const cControl2 = getExtendPoint(end, qControl, (endDistance * 2) / 3);
+        result.push(start, cControl1, cControl2, end);
+    }
+    return result;
+};
+export const handleArrowLineCreating = (board, lineShape, sourcePoint, movingPoint, sourceElement, lineShapeG) => {
+    const hitElement = getSnappingShape(board, movingPoint);
+    const targetConnection = hitElement ? getHitConnection(board, movingPoint, hitElement) : undefined;
+    const sourceConnection = sourceElement ? getHitConnection(board, sourcePoint, sourceElement) : undefined;
+    const targetBoundId = hitElement ? hitElement.id : undefined;
+    const lineGenerator = new ArrowLineShapeGenerator(board);
+    const memorizedLatest = getLineMemorizedLatest();
+    let sourceMarker, targetMarker;
+    sourceMarker = memorizedLatest.source;
+    targetMarker = memorizedLatest.target;
+    sourceMarker && delete memorizedLatest.source;
+    targetMarker && delete memorizedLatest.target;
+    const temporaryLineElement = createArrowLineElement(lineShape, [sourcePoint, movingPoint], { marker: sourceMarker || ArrowLineMarkerType.none, connection: sourceConnection, boundId: sourceElement?.id }, { marker: targetMarker || ArrowLineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId }, [], {
+        strokeWidth: DefaultLineStyle.strokeWidth,
+        ...memorizedLatest
+    });
+    const linePoints = getArrowLinePoints(board, temporaryLineElement);
+    const otherPoint = linePoints[0];
+    temporaryLineElement.points[1] = alignPoints(otherPoint, movingPoint);
+    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);
+    PlaitBoard.getElementActiveHost(board).append(lineShapeG);
+    return temporaryLineElement;
+};
+function drawArrowLineMask(board, element, id) {
+    const mask = createMask();
+    mask.setAttribute('id', id);
+    const points = getArrowLinePoints(board, element);
+    let rectangle = RectangleClient.getRectangleByPoints(points);
+    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);
+    const maskFillRect = createRect(rectangle, {
+        fill: 'white'
+    });
+    mask.appendChild(maskFillRect);
+    const texts = element.texts;
+    texts.forEach((text, index) => {
+        let textRectangle = getArrowLineTextRectangle(board, element, index);
+        textRectangle = RectangleClient.inflate(textRectangle, LINE_TEXT_SPACE * 2);
+        const rect = createRect(textRectangle, {
+            fill: 'black'
+        });
+        mask.appendChild(rect);
+    });
+    // open line
+    const maskTargetFillRect = createRect(rectangle);
+    maskTargetFillRect.setAttribute('opacity', '0');
+    maskTargetFillRect.setAttribute('fill', 'none');
+    return { mask, maskTargetFillRect };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrow-line-basic.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/arrow-line/arrow-line-basic.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EACL,SAAS,EACT,UAAU,EACV,OAAO,EACP,eAAe,EACf,YAAY,EAEZ,cAAc,EACd,UAAU,EACV,UAAU,EACV,4BAA4B,EAC5B,iBAAiB,EACjB,gBAAgB,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACrH,OAAO,EAEH,mBAAmB,EACnB,cAAc,EAEd,cAAc,EACd,gBAAgB,EAEhB,WAAW,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AACpG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEtF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAClC,KAAqB,EACrB,MAAsB,EACtB,MAAuB,EACvB,MAAuB,EACvB,KAAuB,EACvB,OAA6D,EAC/C,EAAE;IAChB,OAAO;QACH,EAAE,EAAE,SAAS,EAAE;QACf,IAAI,EAAE,YAAY;QAClB,KAAK;QACL,MAAM;QACN,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QACzB,MAAM;QACN,OAAO,EAAE,CAAC;QACV,MAAM;QACN,GAAG,OAAO;KACb,CAAC;AACN,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAiB,EAAE,OAAuB,EAAE,EAAE;IAC7E,QAAQ,OAAO,CAAC,KAAK,EAAE,CAAC;QACpB,KAAK,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;YACxB,OAAO,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC1C,CAAC;QACD,KAAK,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;YACxB,OAAO,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC1C,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACN,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACxD,MAAM,aAAa,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAChE,MAAM,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC;YACvC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC;YACvD,OAAO,MAAM,CAAC;QAClB,CAAC;IACL,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAiB,EAAE,OAAuB,EAAE,EAAE;IACzE,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,aAAa,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAChE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC;QACzC,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAAC,YAAY,CAAC;QAC7D,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAAC,YAAY,CAAC;QAC7D,IAAI,WAAW,GAAY,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,WAAW,GAAG,4BAA4B,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACnF,MAAM,MAAM,GAAG,EAAE,GAAG,WAAW,GAAG,CAAC,CAAC;QACpC,IAAI,kBAAkB,EAAE,CAAC;YACrB,WAAW,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,IAAI,kBAAkB,EAAE,CAAC;YACrB,WAAW,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,MAAM,aAAa,GAAG,CAAC,kBAAkB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,kBAAkB,IAAI,kBAAkB,CAAC,CAAC;QACjH,IAAI,aAAa,EAAE,CAAC;YAChB,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC/B,MAAM,MAAM,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC;YAChC,OAAO,oBAAoB,CAAC,MAAM,CAAY,CAAC;QACnD,CAAC;QACD,IAAI,CAAC,kBAAkB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC7C,WAAW,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;YACjF,WAAW,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,oBAAoB,CAAC,WAAW,CAAY,CAAC;IACxD,CAAC;SAAM,CAAC;QACJ,IAAI,UAAU,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC1D,UAAU,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC7C,OAAO,oBAAoB,CAAC,MAAM,CAAY,CAAC;IACnD,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,UAAU,eAAe,CAAC,KAAiB,EAAE,OAAuB;IACtE,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC5B,MAAM,UAAU,GAAG,EAAE,CAAC;IACtB,IAAI,KAAK,KAAK,cAAc,CAAC,QAAQ,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,4BAA4B,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC9E,IAAI,QAAQ,GAAG,UAAU;gBAAE,SAAS;YACpC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAChG,CAAC;IACL,CAAC;IACD,IAAI,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxD,MAAM,cAAc,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACtD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,KAAK,GAAG,CAAC,CAAC;YAChB,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;YAC3C,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YACvD,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACJ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBACzC,MAAM,UAAU,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7G,MAAM,QAAQ,GAAG,cAAc,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnH,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC5D,MAAM,QAAQ,GAAG,4BAA4B,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC9E,IAAI,QAAQ,GAAG,UAAU;oBAAE,SAAS;gBACpC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC;YAC7C,CAAC;QACL,CAAC;IACL,CAAC;IACD,IAAI,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,YAAY,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,wBAAwB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;YACjD,MAAM,CAAC,eAAe,EAAE,eAAe,CAAC,GAAG,4BAA4B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACxF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/C,IACI,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC;oBAChE,CAAC,CAAC,KAAK,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,EAC3G,CAAC;oBACC,SAAS;gBACb,CAAC;gBACD,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC7C,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC3C,MAAM,WAAW,GAAG,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAU,CAAC;gBAC9E,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC7B,CAAC;QACL,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,OAAuB,EAAE,EAAE;IACxE,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,WAAW,GAAG,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,cAAc,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;IACrE,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;IACxB,IAAI,MAAM,GAAG,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAChD,IAAI,IAAI,CAAC;IACT,IAAI,OAAO,CAAC,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;QACzC,IAAI,GAAG,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;SAAM,CAAC;QACJ,IAAI,GAAG,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IACD,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;IACvB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;IACzC,IAAI,OAAO,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;QAC7C,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAExB,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,GAAG,iBAAiB,CAAC,KAAK,EAAE,OAAyB,EAAE,EAAE,CAAC,CAAC;IAC7F,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,kBAAkB,CAAC,OAAyB,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAAC;IAC1G,KAAK,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,OAAO,KAAK,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAiB,EAAE,KAAY,EAAE,UAA6B,EAAS,EAAE;IACtG,IAAI,SAAS,GAAG,eAAe,CAAC,oBAAoB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACxE,MAAM,GAAG,GAAG,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IACrD,MAAM,eAAe,GAAG,GAAG,CAAC,cAAc,IAAI,GAAG,CAAC,SAAS,CAAC;IAC5D,OAAO,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAY,EAAE,UAA6B,EAAE,EAAE;IAChF,MAAM,SAAS,GAAG,eAAe,CAAC,oBAAoB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1E,MAAM,KAAK,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC;IAC1C,MAAM,eAAe,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvE,OAAO,eAAe,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE;QACzC,OAAO,4BAA4B,CAAC,GAAG,cAAc,EAAE,GAAG,KAAK,CAAC,IAAI,8BAA8B,CAAC;IACvG,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,KAAiB,EAAE,OAAuB,EAAE,KAAa,EAAmB,EAAE;IACpH,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClC,MAAM,WAAW,GAAG,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACvD,MAAM,KAAK,GAAG,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO;QACH,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAM,GAAG,CAAC;QAC7B,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAO,GAAG,CAAC;QAC9B,KAAK,EAAE,IAAI,CAAC,KAAM;QAClB,MAAM,EAAE,IAAI,CAAC,MAAO;KACvB,CAAC;AACN,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,EAAE;IAC/C,OAAO,YAAY,CAAC,KAAK,EAAE;QACvB,KAAK,EAAE,CAAC,OAAqB,EAAE,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC;QACvE,SAAS,EAAE,CAAC,OAAqB,EAAE,EAAE,CAAC,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC;KAChF,CAAqB,CAAC;AAC3B,CAAC,CAAC;AAEF,mCAAmC;AACnC,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAe,EAAE,EAAE;IACnC,MAAM,MAAM,GAAG,EAAE,CAAC;IAClB,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1B,MAAM,aAAa,GAAG,4BAA4B,CAAC,GAAG,KAAK,EAAE,GAAG,QAAQ,CAAC,CAAC;QAC1E,MAAM,WAAW,GAAG,4BAA4B,CAAC,GAAG,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC;QACtE,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3E,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACvE,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACnC,KAAiB,EACjB,SAAyB,EACzB,WAAkB,EAClB,WAAkB,EAClB,aAAuC,EACvC,UAAuB,EACzB,EAAE;IACA,MAAM,UAAU,GAAG,gBAAgB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACxD,MAAM,gBAAgB,GAAG,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnG,MAAM,gBAAgB,GAAG,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACzG,MAAM,aAAa,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7D,MAAM,aAAa,GAAG,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAC;IACzD,MAAM,eAAe,GAAG,sBAAsB,EAAE,CAAC;IACjD,IAAI,YAAY,EAAE,YAAY,CAAC;IAC/B,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC;IACtC,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC;IACtC,YAAY,IAAI,OAAO,eAAe,CAAC,MAAM,CAAC;IAC9C,YAAY,IAAI,OAAO,eAAe,CAAC,MAAM,CAAC;IAC9C,MAAM,oBAAoB,GAAG,sBAAsB,CAC/C,SAAS,EACT,CAAC,WAAW,EAAE,WAAW,CAAC,EAC1B,EAAE,MAAM,EAAE,YAAY,IAAI,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,EAC9G,EAAE,MAAM,EAAE,YAAY,IAAI,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,EAC3G,EAAE,EACF;QACI,WAAW,EAAE,gBAAgB,CAAC,WAAW;QACzC,GAAG,eAAe;KACrB,CACJ,CAAC;IACF,MAAM,UAAU,GAAG,kBAAkB,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAC;IACnE,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IACjC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IACtE,aAAa,CAAC,cAAc,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;IAC/D,UAAU,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC1D,OAAO,oBAAoB,CAAC;AAChC,CAAC,CAAC;AAEF,SAAS,iBAAiB,CAAC,KAAiB,EAAE,OAAuB,EAAE,EAAU;IAC7E,MAAM,IAAI,GAAG,UAAU,EAAE,CAAC;IAC1B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC5B,MAAM,MAAM,GAAG,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAClD,IAAI,SAAS,GAAG,eAAe,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC7D,SAAS,GAAG,eAAe,CAAC,mBAAmB,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;IAChE,MAAM,YAAY,GAAG,UAAU,CAAC,SAAS,EAAE;QACvC,IAAI,EAAE,OAAO;KAChB,CAAC,CAAC;IACH,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;IAE/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC5B,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC1B,IAAI,aAAa,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrE,aAAa,GAAG,eAAe,CAAC,OAAO,CAAC,aAAa,EAAE,eAAe,GAAG,CAAC,CAAC,CAAC;QAC5E,MAAM,IAAI,GAAG,UAAU,CAAC,aAAa,EAAE;YACnC,IAAI,EAAE,OAAO;SAChB,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;IACH,YAAY;IACZ,MAAM,kBAAkB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;IACjD,kBAAkB,CAAC,YAAY,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAChD,kBAAkB,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;AACxC,CAAC","sourcesContent":["import {\n    Point,\n    idCreator,\n    PlaitBoard,\n    createG,\n    RectangleClient,\n    findElements,\n    PlaitElement,\n    drawLinearPath,\n    createMask,\n    createRect,\n    distanceBetweenPointAndPoint,\n    catmullRomFitting,\n    setStrokeLinecap\n} from '@plait/core';\nimport { pointsOnBezierCurves } from 'points-on-curve';\nimport { getPointOnPolyline, getPointByVectorComponent, removeDuplicatePoints, getExtendPoint } from '@plait/common';\nimport {\n    ArrowLineHandle,\n    ArrowLineMarkerType,\n    ArrowLineShape,\n    ArrowLineText,\n    PlaitArrowLine,\n    PlaitDrawElement,\n    PlaitShapeElement,\n    StrokeStyle\n} from '../../interfaces';\nimport { getLineDashByElement, getStrokeColorByElement } from '../style/stroke';\nimport { getEngine } from '../../engines';\nimport { getElementShape } from '../shape';\nimport { DefaultLineStyle, LINE_TEXT_SPACE } from '../../constants/line';\nimport { ArrowLineShapeGenerator } from '../../generators/arrow-line.generator';\nimport { LINE_SNAPPING_CONNECTOR_BUFFER } from '../../constants';\nimport { getLineMemorizedLatest } from '../memorize';\nimport { alignPoints } from './arrow-line-resize';\nimport { getElbowLineRouteOptions, getArrowLineHandleRefPair } from './arrow-line-common';\nimport { getElbowPoints, getNextSourceAndTargetPoints, isUseDefaultOrthogonalRoute } from './elbow';\nimport { drawArrowLineArrow } from './arrow-line-arrow';\nimport { getSnappingRef, getSnappingShape, getStrokeWidthByElement } from '../common';\n\nexport const createArrowLineElement = (\n    shape: ArrowLineShape,\n    points: [Point, Point],\n    source: ArrowLineHandle,\n    target: ArrowLineHandle,\n    texts?: ArrowLineText[],\n    options?: Pick<PlaitArrowLine, 'strokeColor' | 'strokeWidth'>\n): PlaitArrowLine => {\n    return {\n        id: idCreator(),\n        type: 'arrow-line',\n        shape,\n        source,\n        texts: texts ? texts : [],\n        target,\n        opacity: 1,\n        points,\n        ...options\n    };\n};\n\nexport const getArrowLinePoints = (board: PlaitBoard, element: PlaitArrowLine) => {\n    switch (element.shape) {\n        case ArrowLineShape.elbow: {\n            return getElbowPoints(board, element);\n        }\n        case ArrowLineShape.curve: {\n            return getCurvePoints(board, element);\n        }\n        default: {\n            const points = PlaitArrowLine.getPoints(board, element);\n            const handleRefPair = getArrowLineHandleRefPair(board, element);\n            points[0] = handleRefPair.source.point;\n            points[points.length - 1] = handleRefPair.target.point;\n            return points;\n        }\n    }\n};\n\nexport const getCurvePoints = (board: PlaitBoard, element: PlaitArrowLine) => {\n    if (element.points.length === 2) {\n        const handleRefPair = getArrowLineHandleRefPair(board, element);\n        const { source, target } = handleRefPair;\n        const sourceBoundElement = handleRefPair.source.boundElement;\n        const targetBoundElement = handleRefPair.target.boundElement;\n        let curvePoints: Point[] = [source.point];\n        const sumDistance = distanceBetweenPointAndPoint(...source.point, ...target.point);\n        const offset = 12 + sumDistance / 3;\n        if (sourceBoundElement) {\n            curvePoints.push(getPointByVectorComponent(source.point, source.vector, offset));\n        }\n        if (targetBoundElement) {\n            curvePoints.push(getPointByVectorComponent(target.point, target.vector, offset));\n        }\n        const isSingleBound = (sourceBoundElement && !targetBoundElement) || (!sourceBoundElement && targetBoundElement);\n        if (isSingleBound) {\n            curvePoints.push(target.point);\n            const points = Q2C(curvePoints);\n            return pointsOnBezierCurves(points) as Point[];\n        }\n        if (!sourceBoundElement && !targetBoundElement) {\n            curvePoints.push(getPointByVectorComponent(source.point, source.vector, offset));\n            curvePoints.push(getPointByVectorComponent(target.point, target.vector, offset));\n        }\n        curvePoints.push(target.point);\n        return pointsOnBezierCurves(curvePoints) as Point[];\n    } else {\n        let dataPoints = PlaitArrowLine.getPoints(board, element);\n        dataPoints = removeDuplicatePoints(dataPoints);\n        const points = catmullRomFitting(dataPoints);\n        return pointsOnBezierCurves(points) as Point[];\n    }\n};\n\nexport function getMiddlePoints(board: PlaitBoard, element: PlaitArrowLine) {\n    const result: Point[] = [];\n    const shape = element.shape;\n    const hideBuffer = 10;\n    if (shape === ArrowLineShape.straight) {\n        const points = PlaitArrowLine.getPoints(board, element);\n        for (let i = 0; i < points.length - 1; i++) {\n            const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);\n            if (distance < hideBuffer) continue;\n            result.push([(points[i][0] + points[i + 1][0]) / 2, (points[i][1] + points[i + 1][1]) / 2]);\n        }\n    }\n    if (shape === ArrowLineShape.curve) {\n        const points = PlaitArrowLine.getPoints(board, element);\n        const pointsOnBezier = getCurvePoints(board, element);\n        if (points.length === 2) {\n            const start = 0;\n            const endIndex = pointsOnBezier.length - 1;\n            const middleIndex = Math.round((start + endIndex) / 2);\n            result.push(pointsOnBezier[middleIndex]);\n        } else {\n            for (let i = 0; i < points.length - 1; i++) {\n                const startIndex = pointsOnBezier.findIndex(point => point[0] === points[i][0] && point[1] === points[i][1]);\n                const endIndex = pointsOnBezier.findIndex(point => point[0] === points[i + 1][0] && point[1] === points[i + 1][1]);\n                const middleIndex = Math.round((startIndex + endIndex) / 2);\n                const distance = distanceBetweenPointAndPoint(...points[i], ...points[i + 1]);\n                if (distance < hideBuffer) continue;\n                result.push(pointsOnBezier[middleIndex]);\n            }\n        }\n    }\n    if (shape === ArrowLineShape.elbow) {\n        const renderPoints = getElbowPoints(board, element);\n        const options = getElbowLineRouteOptions(board, element);\n        if (!isUseDefaultOrthogonalRoute(element, options)) {\n            const [nextSourcePoint, nextTargetPoint] = getNextSourceAndTargetPoints(board, element);\n            for (let i = 0; i < renderPoints.length - 1; i++) {\n                if (\n                    (i == 0 && Point.isEquals(renderPoints[i + 1], nextSourcePoint)) ||\n                    (i === renderPoints.length - 2 && Point.isEquals(renderPoints[renderPoints.length - 2], nextTargetPoint))\n                ) {\n                    continue;\n                }\n                const [currentX, currentY] = renderPoints[i];\n                const [nextX, nextY] = renderPoints[i + 1];\n                const middlePoint = [(currentX + nextX) / 2, (currentY + nextY) / 2] as Point;\n                result.push(middlePoint);\n            }\n        }\n    }\n    return result;\n}\n\nexport const drawArrowLine = (board: PlaitBoard, element: PlaitArrowLine) => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const strokeColor = getStrokeColorByElement(board, element);\n    const strokeLineDash = getLineDashByElement(element);\n    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };\n    const lineG = createG();\n    let points = getArrowLinePoints(board, element);\n    let line;\n    if (element.shape === ArrowLineShape.curve) {\n        line = PlaitBoard.getRoughSVG(board).curve(points, options);\n    } else {\n        line = drawLinearPath(points, options);\n    }\n    const id = idCreator();\n    line.setAttribute('mask', `url(#${id})`);\n    if (element.strokeStyle === StrokeStyle.dotted) {\n        setStrokeLinecap(line, 'round');\n    }\n    lineG.appendChild(line);\n\n    const { mask, maskTargetFillRect } = drawArrowLineMask(board, element as PlaitArrowLine, id);\n    lineG.appendChild(mask);\n    line.appendChild(maskTargetFillRect);\n    const arrow = drawArrowLineArrow(element as PlaitArrowLine, points, { stroke: strokeColor, strokeWidth });\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nexport const getHitConnection = (board: PlaitBoard, point: Point, hitElement: PlaitShapeElement): Point => {\n    let rectangle = RectangleClient.getRectangleByPoints(hitElement.points);\n    const ref = getSnappingRef(board, hitElement, point);\n    const connectionPoint = ref.connectorPoint || ref.edgePoint;\n    return [(connectionPoint[0] - rectangle.x) / rectangle.width, (connectionPoint[1] - rectangle.y) / rectangle.height];\n};\n\nexport const getHitConnectorPoint = (point: Point, hitElement: PlaitShapeElement) => {\n    const rectangle = RectangleClient.getRectangleByPoints(hitElement.points);\n    const shape = getElementShape(hitElement);\n    const connectorPoints = getEngine(shape).getConnectorPoints(rectangle);\n    return connectorPoints.find(connectorPoint => {\n        return distanceBetweenPointAndPoint(...connectorPoint, ...point) <= LINE_SNAPPING_CONNECTOR_BUFFER;\n    });\n};\n\nexport const getArrowLineTextRectangle = (board: PlaitBoard, element: PlaitArrowLine, index: number): RectangleClient => {\n    const text = element.texts[index];\n    const elbowPoints = getArrowLinePoints(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\nexport const getArrowLines = (board: PlaitBoard) => {\n    return findElements(board, {\n        match: (element: PlaitElement) => PlaitDrawElement.isArrowLine(element),\n        recursion: (element: PlaitElement) => PlaitDrawElement.isDrawElement(element)\n    }) as PlaitArrowLine[];\n};\n\n// quadratic Bezier to cubic Bezier\nexport const Q2C = (points: Point[]) => {\n    const result = [];\n    const numSegments = points.length / 3;\n    for (let i = 0; i < numSegments; i++) {\n        const start = points[i];\n        const qControl = points[i + 1];\n        const end = points[i + 2];\n        const startDistance = distanceBetweenPointAndPoint(...start, ...qControl);\n        const endDistance = distanceBetweenPointAndPoint(...end, ...qControl);\n        const cControl1 = getExtendPoint(start, qControl, (startDistance * 2) / 3);\n        const cControl2 = getExtendPoint(end, qControl, (endDistance * 2) / 3);\n        result.push(start, cControl1, cControl2, end);\n    }\n    return result;\n};\n\nexport const handleArrowLineCreating = (\n    board: PlaitBoard,\n    lineShape: ArrowLineShape,\n    sourcePoint: Point,\n    movingPoint: Point,\n    sourceElement: PlaitShapeElement | null,\n    lineShapeG: SVGGElement\n) => {\n    const hitElement = getSnappingShape(board, movingPoint);\n    const targetConnection = hitElement ? getHitConnection(board, movingPoint, hitElement) : undefined;\n    const sourceConnection = sourceElement ? getHitConnection(board, sourcePoint, sourceElement) : undefined;\n    const targetBoundId = hitElement ? hitElement.id : undefined;\n    const lineGenerator = new ArrowLineShapeGenerator(board);\n    const memorizedLatest = getLineMemorizedLatest();\n    let sourceMarker, targetMarker;\n    sourceMarker = memorizedLatest.source;\n    targetMarker = memorizedLatest.target;\n    sourceMarker && delete memorizedLatest.source;\n    targetMarker && delete memorizedLatest.target;\n    const temporaryLineElement = createArrowLineElement(\n        lineShape,\n        [sourcePoint, movingPoint],\n        { marker: sourceMarker || ArrowLineMarkerType.none, connection: sourceConnection, boundId: sourceElement?.id },\n        { marker: targetMarker || ArrowLineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId },\n        [],\n        {\n            strokeWidth: DefaultLineStyle.strokeWidth,\n            ...memorizedLatest\n        }\n    );\n    const linePoints = getArrowLinePoints(board, temporaryLineElement);\n    const otherPoint = linePoints[0];\n    temporaryLineElement.points[1] = alignPoints(otherPoint, movingPoint);\n    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);\n    PlaitBoard.getElementActiveHost(board).append(lineShapeG);\n    return temporaryLineElement;\n};\n\nfunction drawArrowLineMask(board: PlaitBoard, element: PlaitArrowLine, id: string) {\n    const mask = createMask();\n    mask.setAttribute('id', id);\n    const points = getArrowLinePoints(board, element);\n    let rectangle = RectangleClient.getRectangleByPoints(points);\n    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);\n    const maskFillRect = createRect(rectangle, {\n        fill: 'white'\n    });\n    mask.appendChild(maskFillRect);\n\n    const texts = element.texts;\n    texts.forEach((text, index) => {\n        let textRectangle = getArrowLineTextRectangle(board, element, index);\n        textRectangle = RectangleClient.inflate(textRectangle, LINE_TEXT_SPACE * 2);\n        const rect = createRect(textRectangle, {\n            fill: 'black'\n        });\n        mask.appendChild(rect);\n    });\n    // open line\n    const maskTargetFillRect = createRect(rectangle);\n    maskTargetFillRect.setAttribute('opacity', '0');\n    maskTargetFillRect.setAttribute('fill', 'none');\n    return { mask, maskTargetFillRect };\n}\n"]}

package/esm2022/utils/arrow-line/arrow-line-common.mjs

@@ -0,0 +1,127 @@
+import { getElementById, RectangleClient, Direction, hasValidAngle, rotatePointsByElement } from '@plait/core';
+import { getDirectionFactor, rotateVectorAnti90, getDirectionByVector, getOppositeDirection, getDirectionByPointOfRectangle, getSourceAndTargetOuterRectangle, getNextPoint, rotateVector } from '@plait/common';
+import { BasicShapes, ArrowLineHandleKey, ArrowLineMarkerType, PlaitArrowLine } from '../../interfaces';
+import { getEngine } from '../../engines';
+import { getElementShape } from '../shape';
+import { getSourceAndTargetRectangle } from './elbow';
+import { getStrokeWidthByElement } from '../common';
+export const getArrowLineHandleRefPair = (board, element) => {
+    const strokeWidth = getStrokeWidthByElement(element);
+    const sourceBoundElement = element.source.boundId ? getElementById(board, element.source.boundId) : undefined;
+    const targetBoundElement = element.target.boundId ? getElementById(board, element.target.boundId) : undefined;
+    let sourcePoint = sourceBoundElement ? getConnectionPoint(sourceBoundElement, element.source.connection) : element.points[0];
+    let targetPoint = targetBoundElement
+        ? getConnectionPoint(targetBoundElement, element.target.connection)
+        : element.points[element.points.length - 1];
+    let sourceDirection = getDirectionByVector([targetPoint[0] - sourcePoint[0], targetPoint[1] - sourcePoint[1]]) || Direction.right;
+    let targetDirection = getOppositeDirection(sourceDirection);
+    const sourceFactor = getDirectionFactor(sourceDirection);
+    const targetFactor = getDirectionFactor(targetDirection);
+    const sourceHandleRef = {
+        key: ArrowLineHandleKey.source,
+        point: sourcePoint,
+        direction: sourceDirection,
+        vector: [sourceFactor.x, sourceFactor.y]
+    };
+    const targetHandleRef = {
+        key: ArrowLineHandleKey.target,
+        point: targetPoint,
+        direction: targetDirection,
+        vector: [targetFactor.x, targetFactor.y]
+    };
+    if (sourceBoundElement) {
+        const connectionOffset = PlaitArrowLine.isSourceMarkOrTargetMark(element, ArrowLineMarkerType.none, ArrowLineHandleKey.source)
+            ? 0
+            : strokeWidth;
+        const sourceVector = getVectorByConnection(sourceBoundElement, element.source.connection);
+        sourceHandleRef.vector = sourceVector;
+        sourceHandleRef.boundElement = sourceBoundElement;
+        if (hasValidAngle(sourceBoundElement)) {
+            const direction = getDirectionByVector(rotateVector(sourceVector, sourceBoundElement.angle));
+            sourceDirection = direction ? direction : sourceDirection;
+        }
+        else {
+            const direction = getDirectionByVector(sourceVector);
+            sourceDirection = direction ? direction : sourceDirection;
+        }
+        sourceHandleRef.direction = sourceDirection;
+        sourcePoint = getConnectionPoint(sourceBoundElement, element.source.connection, sourceDirection, connectionOffset);
+        sourceHandleRef.point = rotatePointsByElement(sourcePoint, sourceBoundElement) || sourcePoint;
+    }
+    if (targetBoundElement) {
+        const connectionOffset = PlaitArrowLine.isSourceMarkOrTargetMark(element, ArrowLineMarkerType.none, ArrowLineHandleKey.target)
+            ? 0
+            : strokeWidth;
+        const targetVector = getVectorByConnection(targetBoundElement, element.target.connection);
+        targetHandleRef.vector = targetVector;
+        targetHandleRef.boundElement = targetBoundElement;
+        if (hasValidAngle(targetBoundElement)) {
+            const direction = getDirectionByVector(rotateVector(targetVector, targetBoundElement.angle));
+            targetDirection = direction ? direction : targetDirection;
+        }
+        else {
+            const direction = getDirectionByVector(targetVector);
+            targetDirection = direction ? direction : targetDirection;
+        }
+        targetHandleRef.direction = targetDirection;
+        targetPoint = getConnectionPoint(targetBoundElement, element.target.connection, targetDirection, connectionOffset);
+        targetHandleRef.point = rotatePointsByElement(targetPoint, targetBoundElement) || targetPoint;
+    }
+    return { source: sourceHandleRef, target: targetHandleRef };
+};
+export const getConnectionPoint = (geometry, connection, direction, delta) => {
+    const rectangle = RectangleClient.getRectangleByPoints(geometry.points);
+    if (direction && delta) {
+        const directionFactor = getDirectionFactor(direction);
+        const point = RectangleClient.getConnectionPoint(rectangle, connection);
+        return [point[0] + directionFactor.x * delta, point[1] + directionFactor.y * delta];
+    }
+    else {
+        return RectangleClient.getConnectionPoint(rectangle, connection);
+    }
+};
+export const getVectorByConnection = (boundElement, connection) => {
+    const rectangle = RectangleClient.getRectangleByPoints(boundElement.points);
+    const shape = getElementShape(boundElement);
+    const engine = getEngine(shape);
+    let vector = [0, 0];
+    const direction = getDirectionByPointOfRectangle(connection);
+    if (direction && boundElement.shape !== BasicShapes.ellipse) {
+        const factor = getDirectionFactor(direction);
+        return [factor.x, factor.y];
+    }
+    if (engine.getEdgeByConnectionPoint) {
+        const edge = engine.getEdgeByConnectionPoint(rectangle, connection);
+        if (edge) {
+            const lineVector = [edge[1][0] - edge[0][0], edge[1][1] - edge[0][1]];
+            return rotateVectorAnti90(lineVector);
+        }
+    }
+    if (engine.getTangentVectorByConnectionPoint) {
+        const lineVector = engine.getTangentVectorByConnectionPoint(rectangle, connection);
+        if (lineVector) {
+            return rotateVectorAnti90(lineVector);
+        }
+    }
+    return vector;
+};
+export const getElbowLineRouteOptions = (board, element, handleRefPair) => {
+    handleRefPair = handleRefPair ?? getArrowLineHandleRefPair(board, element);
+    const { sourceRectangle, targetRectangle } = getSourceAndTargetRectangle(board, element, handleRefPair);
+    const { sourceOuterRectangle, targetOuterRectangle } = getSourceAndTargetOuterRectangle(sourceRectangle, targetRectangle);
+    const sourcePoint = handleRefPair.source.point;
+    const targetPoint = handleRefPair.target.point;
+    const nextSourcePoint = getNextPoint(sourcePoint, sourceOuterRectangle, handleRefPair.source.direction);
+    const nextTargetPoint = getNextPoint(targetPoint, targetOuterRectangle, handleRefPair.target.direction);
+    return {
+        sourcePoint,
+        nextSourcePoint,
+        sourceRectangle,
+        sourceOuterRectangle,
+        targetPoint,
+        nextTargetPoint,
+        targetRectangle,
+        targetOuterRectangle
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrow-line-common.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/arrow-line/arrow-line-common.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Point,\n    PlaitBoard,\n    getElementById,\n    RectangleClient,\n    PointOfRectangle,\n    Direction,\n    Vector,\n    hasValidAngle,\n    rotatePointsByElement\n} from '@plait/core';\nimport {\n    getDirectionFactor,\n    rotateVectorAnti90,\n    getDirectionByVector,\n    getOppositeDirection,\n    getDirectionByPointOfRectangle,\n    getSourceAndTargetOuterRectangle,\n    getNextPoint,\n    rotateVector\n} from '@plait/common';\nimport {\n    BasicShapes,\n    ArrowLineHandleKey,\n    ArrowLineHandleRef,\n    ArrowLineHandleRefPair,\n    ArrowLineMarkerType,\n    PlaitArrowLine,\n    PlaitGeometry,\n    PlaitShapeElement\n} from '../../interfaces';\nimport { getEngine } from '../../engines';\nimport { getElementShape } from '../shape';\nimport { getSourceAndTargetRectangle } from './elbow';\nimport { getStrokeWidthByElement } from '../common';\n\nexport const getArrowLineHandleRefPair = (board: PlaitBoard, element: PlaitArrowLine): ArrowLineHandleRefPair => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const sourceBoundElement = element.source.boundId ? getElementById<PlaitShapeElement>(board, element.source.boundId) : undefined;\n    const targetBoundElement = element.target.boundId ? getElementById<PlaitShapeElement>(board, element.target.boundId) : undefined;\n    let sourcePoint = sourceBoundElement ? getConnectionPoint(sourceBoundElement, element.source.connection!) : element.points[0];\n    let targetPoint = targetBoundElement\n        ? getConnectionPoint(targetBoundElement, element.target.connection!)\n        : element.points[element.points.length - 1];\n    let sourceDirection = getDirectionByVector([targetPoint[0] - sourcePoint[0], targetPoint[1] - sourcePoint[1]]) || Direction.right;\n    let targetDirection = getOppositeDirection(sourceDirection);\n    const sourceFactor = getDirectionFactor(sourceDirection);\n    const targetFactor = getDirectionFactor(targetDirection);\n    const sourceHandleRef: ArrowLineHandleRef = {\n        key: ArrowLineHandleKey.source,\n        point: sourcePoint,\n        direction: sourceDirection,\n        vector: [sourceFactor.x, sourceFactor.y]\n    };\n    const targetHandleRef: ArrowLineHandleRef = {\n        key: ArrowLineHandleKey.target,\n        point: targetPoint,\n        direction: targetDirection,\n        vector: [targetFactor.x, targetFactor.y]\n    };\n    if (sourceBoundElement) {\n        const connectionOffset = PlaitArrowLine.isSourceMarkOrTargetMark(\n            element as PlaitArrowLine,\n            ArrowLineMarkerType.none,\n            ArrowLineHandleKey.source\n        )\n            ? 0\n            : strokeWidth;\n        const sourceVector = getVectorByConnection(sourceBoundElement, element.source.connection!);\n        sourceHandleRef.vector = sourceVector;\n        sourceHandleRef.boundElement = sourceBoundElement;\n        if (hasValidAngle(sourceBoundElement)) {\n            const direction = getDirectionByVector(rotateVector(sourceVector, sourceBoundElement.angle!));\n            sourceDirection = direction ? direction : sourceDirection;\n        } else {\n            const direction = getDirectionByVector(sourceVector);\n            sourceDirection = direction ? direction : sourceDirection;\n        }\n        sourceHandleRef.direction = sourceDirection;\n        sourcePoint = getConnectionPoint(sourceBoundElement, element.source.connection!, sourceDirection, connectionOffset);\n        sourceHandleRef.point = rotatePointsByElement(sourcePoint, sourceBoundElement) || sourcePoint;\n    }\n    if (targetBoundElement) {\n        const connectionOffset = PlaitArrowLine.isSourceMarkOrTargetMark(\n            element as PlaitArrowLine,\n            ArrowLineMarkerType.none,\n            ArrowLineHandleKey.target\n        )\n            ? 0\n            : strokeWidth;\n        const targetVector = getVectorByConnection(targetBoundElement, element.target.connection!);\n        targetHandleRef.vector = targetVector;\n        targetHandleRef.boundElement = targetBoundElement;\n        if (hasValidAngle(targetBoundElement)) {\n            const direction = getDirectionByVector(rotateVector(targetVector, targetBoundElement.angle!));\n            targetDirection = direction ? direction : targetDirection;\n        } else {\n            const direction = getDirectionByVector(targetVector);\n            targetDirection = direction ? direction : targetDirection;\n        }\n        targetHandleRef.direction = targetDirection;\n        targetPoint = getConnectionPoint(targetBoundElement, element.target.connection!, targetDirection, connectionOffset);\n        targetHandleRef.point = rotatePointsByElement(targetPoint, targetBoundElement) || targetPoint;\n    }\n    return { source: sourceHandleRef, target: targetHandleRef };\n};\n\nexport const getConnectionPoint = (geometry: PlaitShapeElement, connection: Point, direction?: Direction, delta?: number): Point => {\n    const rectangle = RectangleClient.getRectangleByPoints(geometry.points);\n    if (direction && delta) {\n        const directionFactor = getDirectionFactor(direction);\n        const point = RectangleClient.getConnectionPoint(rectangle, connection);\n        return [point[0] + directionFactor.x * delta, point[1] + directionFactor.y * delta];\n    } else {\n        return RectangleClient.getConnectionPoint(rectangle, connection);\n    }\n};\n\nexport const getVectorByConnection = (boundElement: PlaitShapeElement, connection: PointOfRectangle): Vector => {\n    const rectangle = RectangleClient.getRectangleByPoints(boundElement.points);\n    const shape = getElementShape(boundElement);\n    const engine = getEngine(shape);\n    let vector: Vector = [0, 0];\n    const direction = getDirectionByPointOfRectangle(connection);\n    if (direction && boundElement.shape !== BasicShapes.ellipse) {\n        const factor = getDirectionFactor(direction);\n        return [factor.x, factor.y];\n    }\n    if (engine.getEdgeByConnectionPoint) {\n        const edge = engine.getEdgeByConnectionPoint(rectangle, connection);\n        if (edge) {\n            const lineVector = [edge[1][0] - edge[0][0], edge[1][1] - edge[0][1]] as Vector;\n            return rotateVectorAnti90(lineVector);\n        }\n    }\n    if (engine.getTangentVectorByConnectionPoint) {\n        const lineVector = engine.getTangentVectorByConnectionPoint(rectangle, connection);\n        if (lineVector) {\n            return rotateVectorAnti90(lineVector);\n        }\n    }\n    return vector;\n};\n\nexport const getElbowLineRouteOptions = (board: PlaitBoard, element: PlaitArrowLine, handleRefPair?: ArrowLineHandleRefPair) => {\n    handleRefPair = handleRefPair ?? getArrowLineHandleRefPair(board, element);\n    const { sourceRectangle, targetRectangle } = getSourceAndTargetRectangle(board, element, handleRefPair);\n    const { sourceOuterRectangle, targetOuterRectangle } = getSourceAndTargetOuterRectangle(sourceRectangle, targetRectangle);\n    const sourcePoint = handleRefPair.source.point;\n    const targetPoint = handleRefPair.target.point;\n    const nextSourcePoint = getNextPoint(sourcePoint, sourceOuterRectangle, handleRefPair.source.direction);\n    const nextTargetPoint = getNextPoint(targetPoint, targetOuterRectangle, handleRefPair.target.direction);\n    return {\n        sourcePoint,\n        nextSourcePoint,\n        sourceRectangle,\n        sourceOuterRectangle,\n        targetPoint,\n        nextTargetPoint,\n        targetRectangle,\n        targetOuterRectangle\n    };\n};\n"]}