@plait/draw 0.50.1 → 0.51.0

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

@@ -0,0 +1,123 @@
+import { arrowPoints, createG, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate } from '@plait/core';
+import { LineMarkerType, PlaitLine } from '../../interfaces';
+import { getExtendPoint, getUnitVectorByPointAndPoint } from '@plait/common';
+import { getStrokeWidthByElement } from '../style';
+const ARROW_LENGTH = 20;
+export const drawLineArrow = (element, points, options) => {
+    const arrowG = createG();
+    if (PlaitLine.isSourceMark(element, LineMarkerType.none) && PlaitLine.isTargetMark(element, LineMarkerType.none)) {
+        return null;
+    }
+    const strokeWidth = getStrokeWidthByElement(element);
+    const offset = (strokeWidth * strokeWidth) / 3;
+    if (points.length === 1) {
+        points = [points[0], [points[0][0] + 0.1, points[0][1]]];
+    }
+    if (!PlaitLine.isSourceMark(element, LineMarkerType.none)) {
+        const source = getExtendPoint(points[0], points[1], ARROW_LENGTH + offset);
+        const sourceArrow = getArrow(element, { marker: element.source.marker, source, target: points[0], isSource: true }, options);
+        sourceArrow && arrowG.appendChild(sourceArrow);
+    }
+    if (!PlaitLine.isTargetMark(element, LineMarkerType.none)) {
+        const source = getExtendPoint(points[points.length - 1], points[points.length - 2], ARROW_LENGTH + offset);
+        const arrow = getArrow(element, { marker: element.target.marker, source, target: points[points.length - 1], isSource: false }, options);
+        arrow && arrowG.appendChild(arrow);
+    }
+    return arrowG;
+};
+const getArrow = (element, arrowOptions, options) => {
+    const { marker, target, source, isSource } = arrowOptions;
+    let targetArrow;
+    switch (marker) {
+        case LineMarkerType.openTriangle: {
+            targetArrow = drawOpenTriangle(element, source, target, options);
+            break;
+        }
+        case LineMarkerType.solidTriangle: {
+            targetArrow = drawSolidTriangle(source, target, options);
+            break;
+        }
+        case LineMarkerType.arrow: {
+            targetArrow = drawArrow(element, source, target, options);
+            break;
+        }
+        case LineMarkerType.sharpArrow: {
+            targetArrow = drawSharpArrow(source, target, options);
+            break;
+        }
+        case LineMarkerType.oneSideUp: {
+            targetArrow = drawOneSideArrow(source, target, isSource ? 'down' : 'up', options);
+            break;
+        }
+        case LineMarkerType.oneSideDown: {
+            targetArrow = drawOneSideArrow(source, target, isSource ? 'up' : 'down', options);
+            break;
+        }
+        case LineMarkerType.hollowTriangle: {
+            targetArrow = drawHollowTriangleArrow(source, target, options);
+            break;
+        }
+        case LineMarkerType.singleSlash: {
+            targetArrow = drawSingleSlash(source, target, isSource, options);
+            break;
+        }
+    }
+    return targetArrow;
+};
+const drawSharpArrow = (source, target, options) => {
+    const startPoint = target;
+    const { pointLeft, pointRight } = arrowPoints(source, target, 20);
+    const g = createG();
+    const path = createPath();
+    let polylinePath = `M${pointRight[0]},${pointRight[1]}A25,25,20,0,1,${pointLeft[0]},${pointLeft[1]}L${startPoint[0]},${startPoint[1]}Z`;
+    path.setAttribute('d', polylinePath);
+    path.setAttribute('stroke', `${options?.stroke}`);
+    path.setAttribute('stroke-width', `${options?.strokeWidth}`);
+    path.setAttribute('fill', `${options?.stroke}`);
+    g.appendChild(path);
+    return g;
+};
+const drawArrow = (element, source, target, options) => {
+    const unitVector = getUnitVectorByPointAndPoint(source, target);
+    const strokeWidth = getStrokeWidthByElement(element);
+    const endPoint = [target[0] + (strokeWidth * unitVector[0]) / 2, target[1] + (strokeWidth * unitVector[1]) / 2];
+    const distance = distanceBetweenPointAndPoint(...source, ...endPoint);
+    const middlePoint = [
+        endPoint[0] - (((distance * 3) / 5 + strokeWidth) / 2) * unitVector[0],
+        endPoint[1] - (((distance * 3) / 5 + strokeWidth) / 2) * unitVector[1]
+    ];
+    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 30);
+    const arrowG = drawLinearPath([pointLeft, endPoint, pointRight, middlePoint], { ...options, fill: options.stroke }, true);
+    const path = arrowG.querySelector('path');
+    path.setAttribute('stroke-linejoin', 'round');
+    return arrowG;
+};
+const drawSolidTriangle = (source, target, options) => {
+    const endPoint = target;
+    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 30);
+    return drawLinearPath([pointLeft, endPoint, pointRight], { ...options, fill: options.stroke }, true);
+};
+const drawOpenTriangle = (element, source, target, options) => {
+    const unitVector = getUnitVectorByPointAndPoint(source, target);
+    const strokeWidth = getStrokeWidthByElement(element);
+    const endPoint = [target[0] + (strokeWidth * unitVector[0]) / 2, target[1] + (strokeWidth * unitVector[1]) / 2];
+    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 40);
+    return drawLinearPath([pointLeft, endPoint, pointRight], options);
+};
+const drawOneSideArrow = (source, target, side, options) => {
+    const { pointLeft, pointRight } = arrowPoints(source, target, 40);
+    return drawLinearPath([side === 'up' ? pointRight : pointLeft, target], options);
+};
+const drawSingleSlash = (source, target, isSource, options) => {
+    const length = distanceBetweenPointAndPoint(...source, ...target);
+    const middlePoint = getExtendPoint(target, source, length / 2);
+    const angle = isSource ? 120 : 60;
+    const start = rotate(...source, ...middlePoint, (angle * Math.PI) / 180);
+    const end = rotate(...target, ...middlePoint, (angle * Math.PI) / 180);
+    return drawLinearPath([start, end], options);
+};
+const drawHollowTriangleArrow = (source, target, options) => {
+    const { pointLeft, pointRight } = arrowPoints(source, target, 30);
+    return drawLinearPath([pointLeft, pointRight, target], { ...options, fill: 'white' }, true);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-arrow.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/line/line-arrow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,4BAA4B,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC5H,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EAAE,cAAc,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAQnD,MAAM,YAAY,GAAG,EAAE,CAAC;AAExB,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAkB,EAAE,MAAe,EAAE,OAAgB,EAAE,EAAE;IACnF,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC;IACzB,IAAI,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE;QAC9G,OAAO,IAAI,CAAC;KACf;IACD,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,MAAM,GAAG,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC/C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAC5D;IAED,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE;QACvD,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC,CAAC;QAC3E,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;QAC7H,WAAW,IAAI,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;KAClD;IACD,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE;QACvD,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC,CAAC;QAC3G,MAAM,KAAK,GAAG,QAAQ,CAClB,OAAO,EACP,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAC7F,OAAO,CACV,CAAC;QAEF,KAAK,IAAI,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;KACtC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,QAAQ,GAAG,CAAC,OAAkB,EAAE,YAA0B,EAAE,OAAgB,EAAE,EAAE;IAClF,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,YAAY,CAAC;IAC1D,IAAI,WAAW,CAAC;IAChB,QAAQ,MAAM,EAAE;QACZ,KAAK,cAAc,CAAC,YAAY,CAAC,CAAC;YAC9B,WAAW,GAAG,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YACjE,MAAM;SACT;QACD,KAAK,cAAc,CAAC,aAAa,CAAC,CAAC;YAC/B,WAAW,GAAG,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YACzD,MAAM;SACT;QACD,KAAK,cAAc,CAAC,KAAK,CAAC,CAAC;YACvB,WAAW,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAC1D,MAAM;SACT;QACD,KAAK,cAAc,CAAC,UAAU,CAAC,CAAC;YAC5B,WAAW,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YACtD,MAAM;SACT;QACD,KAAK,cAAc,CAAC,SAAS,CAAC,CAAC;YAC3B,WAAW,GAAG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YAClF,MAAM;SACT;QACD,KAAK,cAAc,CAAC,WAAW,CAAC,CAAC;YAC7B,WAAW,GAAG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAClF,MAAM;SACT;QACD,KAAK,cAAc,CAAC,cAAc,CAAC,CAAC;YAChC,WAAW,GAAG,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAC/D,MAAM;SACT;QACD,KAAK,cAAc,CAAC,WAAW,CAAC,CAAC;YAC7B,WAAW,GAAG,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;YACjE,MAAM;SACT;KACJ;IACD,OAAO,WAAW,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,MAAa,EAAE,MAAa,EAAE,OAAgB,EAAE,EAAE;IACtE,MAAM,UAAU,GAAU,MAAM,CAAC;IACjC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;IAClE,MAAM,CAAC,GAAG,OAAO,EAAE,CAAC;IACpB,MAAM,IAAI,GAAG,UAAU,EAAE,CAAC;IAC1B,IAAI,YAAY,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,iBAAiB,SAAS,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;IACxI,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IACrC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAClD,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;IAC7D,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAChD,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACpB,OAAO,CAAC,CAAC;AACb,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,CAAC,OAAkB,EAAE,MAAa,EAAE,MAAa,EAAE,OAAgB,EAAE,EAAE;IACrF,MAAM,UAAU,GAAG,4BAA4B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChE,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,QAAQ,GAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvH,MAAM,QAAQ,GAAG,4BAA4B,CAAC,GAAG,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC;IACtE,MAAM,WAAW,GAAU;QACvB,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QACtE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;KACzE,CAAC;IACF,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IACpE,MAAM,MAAM,GAAG,cAAc,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAC;IAC1H,MAAM,IAAI,GAAG,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAK,CAAC,YAAY,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,MAAa,EAAE,MAAa,EAAE,OAAgB,EAAE,EAAE;IACzE,MAAM,QAAQ,GAAU,MAAM,CAAC;IAC/B,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IACpE,OAAO,cAAc,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAC;AACzG,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,OAAkB,EAAE,MAAa,EAAE,MAAa,EAAE,OAAgB,EAAE,EAAE;IAC5F,MAAM,UAAU,GAAG,4BAA4B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChE,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,QAAQ,GAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvH,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IACpE,OAAO,cAAc,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;AACtE,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,MAAa,EAAE,MAAa,EAAE,IAAY,EAAE,OAAgB,EAAE,EAAE;IACtF,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;IAClE,OAAO,cAAc,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;AACrF,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,MAAa,EAAE,MAAa,EAAE,QAAiB,EAAE,OAAgB,EAAE,EAAE;IAC1F,MAAM,MAAM,GAAG,4BAA4B,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC;IAClE,MAAM,WAAW,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/D,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAClC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,WAAW,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAU,CAAC;IAClF,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,WAAW,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAU,CAAC;IAChF,OAAO,cAAc,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,CAAC,MAAa,EAAE,MAAa,EAAE,OAAgB,EAAE,EAAE;IAC/E,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;IAClE,OAAO,cAAc,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;AAChG,CAAC,CAAC","sourcesContent":["import { Point, arrowPoints, createG, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate } from '@plait/core';\nimport { LineMarkerType, PlaitLine } from '../../interfaces';\nimport { Options } from 'roughjs/bin/core';\nimport { getExtendPoint, getUnitVectorByPointAndPoint } from '@plait/common';\nimport { getStrokeWidthByElement } from '../style';\n\ninterface ArrowOptions {\n    marker: LineMarkerType;\n    source: Point;\n    target: Point;\n    isSource: boolean;\n}\nconst ARROW_LENGTH = 20;\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    const strokeWidth = getStrokeWidthByElement(element);\n    const offset = (strokeWidth * strokeWidth) / 3;\n    if (points.length === 1) {\n        points = [points[0], [points[0][0] + 0.1, points[0][1]]];\n    }\n\n    if (!PlaitLine.isSourceMark(element, LineMarkerType.none)) {\n        const source = getExtendPoint(points[0], points[1], ARROW_LENGTH + offset);\n        const sourceArrow = getArrow(element, { marker: element.source.marker, source, target: points[0], isSource: true }, options);\n        sourceArrow && arrowG.appendChild(sourceArrow);\n    }\n    if (!PlaitLine.isTargetMark(element, LineMarkerType.none)) {\n        const source = getExtendPoint(points[points.length - 1], points[points.length - 2], ARROW_LENGTH + offset);\n        const arrow = getArrow(\n            element,\n            { marker: element.target.marker, source, target: points[points.length - 1], isSource: false },\n            options\n        );\n\n        arrow && arrowG.appendChild(arrow);\n    }\n    return arrowG;\n};\n\nconst getArrow = (element: PlaitLine, arrowOptions: ArrowOptions, options: Options) => {\n    const { marker, target, source, isSource } = arrowOptions;\n    let targetArrow;\n    switch (marker) {\n        case LineMarkerType.openTriangle: {\n            targetArrow = drawOpenTriangle(element, source, target, options);\n            break;\n        }\n        case LineMarkerType.solidTriangle: {\n            targetArrow = drawSolidTriangle(source, target, options);\n            break;\n        }\n        case LineMarkerType.arrow: {\n            targetArrow = drawArrow(element, source, target, options);\n            break;\n        }\n        case LineMarkerType.sharpArrow: {\n            targetArrow = drawSharpArrow(source, target, options);\n            break;\n        }\n        case LineMarkerType.oneSideUp: {\n            targetArrow = drawOneSideArrow(source, target, isSource ? 'down' : 'up', options);\n            break;\n        }\n        case LineMarkerType.oneSideDown: {\n            targetArrow = drawOneSideArrow(source, target, isSource ? 'up' : 'down', options);\n            break;\n        }\n        case LineMarkerType.hollowTriangle: {\n            targetArrow = drawHollowTriangleArrow(source, target, options);\n            break;\n        }\n        case LineMarkerType.singleSlash: {\n            targetArrow = drawSingleSlash(source, target, isSource, options);\n            break;\n        }\n    }\n    return targetArrow;\n};\n\nconst drawSharpArrow = (source: Point, target: Point, options: Options) => {\n    const startPoint: Point = target;\n    const { pointLeft, pointRight } = arrowPoints(source, target, 20);\n    const g = createG();\n    const path = createPath();\n    let polylinePath = `M${pointRight[0]},${pointRight[1]}A25,25,20,0,1,${pointLeft[0]},${pointLeft[1]}L${startPoint[0]},${startPoint[1]}Z`;\n    path.setAttribute('d', polylinePath);\n    path.setAttribute('stroke', `${options?.stroke}`);\n    path.setAttribute('stroke-width', `${options?.strokeWidth}`);\n    path.setAttribute('fill', `${options?.stroke}`);\n    g.appendChild(path);\n    return g;\n};\n\nconst drawArrow = (element: PlaitLine, source: Point, target: Point, options: Options) => {\n    const unitVector = getUnitVectorByPointAndPoint(source, target);\n    const strokeWidth = getStrokeWidthByElement(element);\n    const endPoint: Point = [target[0] + (strokeWidth * unitVector[0]) / 2, target[1] + (strokeWidth * unitVector[1]) / 2];\n    const distance = distanceBetweenPointAndPoint(...source, ...endPoint);\n    const middlePoint: Point = [\n        endPoint[0] - (((distance * 3) / 5 + strokeWidth) / 2) * unitVector[0],\n        endPoint[1] - (((distance * 3) / 5 + strokeWidth) / 2) * unitVector[1]\n    ];\n    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 30);\n    const arrowG = drawLinearPath([pointLeft, endPoint, pointRight, middlePoint], { ...options, fill: options.stroke }, true);\n    const path = arrowG.querySelector('path');\n    path!.setAttribute('stroke-linejoin', 'round');\n    return arrowG;\n};\n\nconst drawSolidTriangle = (source: Point, target: Point, options: Options) => {\n    const endPoint: Point = target;\n    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 30);\n    return drawLinearPath([pointLeft, endPoint, pointRight], { ...options, fill: options.stroke }, true);\n};\n\nconst drawOpenTriangle = (element: PlaitLine, source: Point, target: Point, options: Options) => {\n    const unitVector = getUnitVectorByPointAndPoint(source, target);\n    const strokeWidth = getStrokeWidthByElement(element);\n    const endPoint: Point = [target[0] + (strokeWidth * unitVector[0]) / 2, target[1] + (strokeWidth * unitVector[1]) / 2];\n    const { pointLeft, pointRight } = arrowPoints(source, endPoint, 40);\n    return drawLinearPath([pointLeft, endPoint, pointRight], options);\n};\n\nconst drawOneSideArrow = (source: Point, target: Point, side: string, options: Options) => {\n    const { pointLeft, pointRight } = arrowPoints(source, target, 40);\n    return drawLinearPath([side === 'up' ? pointRight : pointLeft, target], options);\n};\n\nconst drawSingleSlash = (source: Point, target: Point, isSource: boolean, options: Options) => {\n    const length = distanceBetweenPointAndPoint(...source, ...target);\n    const middlePoint = getExtendPoint(target, source, length / 2);\n    const angle = isSource ? 120 : 60;\n    const start = rotate(...source, ...middlePoint, (angle * Math.PI) / 180) as Point;\n    const end = rotate(...target, ...middlePoint, (angle * Math.PI) / 180) as Point;\n    return drawLinearPath([start, end], options);\n};\n\nconst drawHollowTriangleArrow = (source: Point, target: Point, options: Options) => {\n    const { pointLeft, pointRight } = arrowPoints(source, target, 30);\n    return drawLinearPath([pointLeft, pointRight, target], { ...options, fill: 'white' }, true);\n};\n"]}

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

@@ -0,0 +1,258 @@
+import { Point, idCreator, PlaitBoard, createG, RectangleClient, findElements, drawLinearPath, createMask, createRect, distanceBetweenPointAndPoint, catmullRomFitting } from '@plait/core';
+import { pointsOnBezierCurves } from 'points-on-curve';
+import { getPointOnPolyline, getPointByVector, removeDuplicatePoints, getExtendPoint, isSourceAndTargetIntersect } from '@plait/common';
+import { LineMarkerType, LineShape, PlaitDrawElement, PlaitLine } from '../../interfaces';
+import { getNearestPoint } from '../geometry';
+import { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from '../style/stroke';
+import { getEngine } from '../../engines';
+import { getShape } from '../shape';
+import { DefaultLineStyle, LINE_TEXT_SPACE } from '../../constants/line';
+import { LineShapeGenerator } from '../../generators/line.generator';
+import { REACTION_MARGIN } from '../../constants';
+import { getHitOutlineGeometry } from '../position/geometry';
+import { getLineMemorizedLatest } from '../memorize';
+import { alignPoints } from './line-resize';
+import { getElbowLineRouteOptions, getLineHandleRefPair } from './line-common';
+import { getElbowPoints, getNextSourceAndTargetPoints } from './elbow';
+import { drawLineArrow } from './line-arrow';
+export const createLineElement = (shape, points, source, target, texts, options) => {
+    return {
+        id: idCreator(),
+        type: 'line',
+        shape,
+        source,
+        texts: texts ? texts : [],
+        target,
+        opacity: 1,
+        points,
+        ...options
+    };
+};
+export const getLinePoints = (board, element) => {
+    switch (element.shape) {
+        case LineShape.elbow: {
+            return getElbowPoints(board, element);
+        }
+        case LineShape.curve: {
+            return getCurvePoints(board, element);
+        }
+        default: {
+            const points = PlaitLine.getPoints(board, element);
+            const handleRefPair = getLineHandleRefPair(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 = getLineHandleRefPair(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(getPointByVector(source.point, source.vector, offset));
+        }
+        if (targetBoundElement) {
+            curvePoints.push(getPointByVector(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(getPointByVector(source.point, source.vector, offset));
+            curvePoints.push(getPointByVector(target.point, target.vector, offset));
+        }
+        curvePoints.push(target.point);
+        return pointsOnBezierCurves(curvePoints);
+    }
+    else {
+        let dataPoints = PlaitLine.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 === LineShape.straight) {
+        const points = PlaitLine.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 === LineShape.curve) {
+        const points = PlaitLine.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 === LineShape.elbow) {
+        const renderPoints = getElbowPoints(board, element);
+        const options = getElbowLineRouteOptions(board, element);
+        const isIntersect = isSourceAndTargetIntersect(options);
+        if (!isIntersect) {
+            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 drawLine = (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 = getLinePoints(board, element);
+    let line;
+    if (element.shape === LineShape.curve) {
+        line = PlaitBoard.getRoughSVG(board).curve(points, options);
+    }
+    else {
+        line = drawLinearPath(points, options);
+    }
+    const id = idCreator();
+    line.setAttribute('mask', `url(#${id})`);
+    lineG.appendChild(line);
+    const { mask, maskTargetFillRect } = drawMask(board, element, id);
+    lineG.appendChild(mask);
+    line.appendChild(maskTargetFillRect);
+    const arrow = drawLineArrow(element, points, { stroke: strokeColor, strokeWidth });
+    arrow && lineG.appendChild(arrow);
+    return lineG;
+};
+export const getConnectionByNearestPoint = (board, point, hitElement) => {
+    let rectangle = RectangleClient.getRectangleByPoints(hitElement.points);
+    let nearestPoint = getNearestPoint(hitElement, point);
+    const hitConnector = getHitConnectorPoint(nearestPoint, hitElement, rectangle);
+    nearestPoint = hitConnector ? hitConnector : nearestPoint;
+    return [(nearestPoint[0] - rectangle.x) / rectangle.width, (nearestPoint[1] - rectangle.y) / rectangle.height];
+};
+export const getHitConnectorPoint = (point, hitElement, rectangle) => {
+    const shape = getShape(hitElement);
+    const connector = getEngine(shape).getConnectorPoints(rectangle);
+    const points = RectangleClient.getPoints(RectangleClient.getRectangleByCenterPoint(point, 10, 10));
+    const pointRectangle = RectangleClient.getRectangleByPoints(points);
+    return connector.find(point => {
+        return RectangleClient.isHit(pointRectangle, RectangleClient.getRectangleByPoints([point, point]));
+    });
+};
+export const getLineTextRectangle = (board, element, index) => {
+    const text = element.texts[index];
+    const elbowPoints = getLinePoints(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 getLines = (board) => {
+    return findElements(board, {
+        match: (element) => PlaitDrawElement.isLine(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 handleLineCreating = (board, lineShape, sourcePoint, movingPoint, sourceElement, lineShapeG) => {
+    const hitElement = getHitOutlineGeometry(board, movingPoint, REACTION_MARGIN);
+    const targetConnection = hitElement ? getConnectionByNearestPoint(board, movingPoint, hitElement) : undefined;
+    const connection = sourceElement ? getConnectionByNearestPoint(board, sourcePoint, sourceElement) : undefined;
+    const targetBoundId = hitElement ? hitElement.id : undefined;
+    const lineGenerator = new LineShapeGenerator(board);
+    const memorizedLatest = getLineMemorizedLatest();
+    let sourceMarker, targetMarker;
+    sourceMarker = memorizedLatest.source;
+    targetMarker = memorizedLatest.target;
+    sourceMarker && delete memorizedLatest.source;
+    targetMarker && delete memorizedLatest.target;
+    const temporaryLineElement = createLineElement(lineShape, [sourcePoint, movingPoint], { marker: sourceMarker || LineMarkerType.none, connection: connection, boundId: sourceElement?.id }, { marker: targetMarker || LineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId }, [], {
+        strokeWidth: DefaultLineStyle.strokeWidth,
+        ...memorizedLatest
+    });
+    const linePoints = getLinePoints(board, temporaryLineElement);
+    const otherPoint = linePoints[0];
+    temporaryLineElement.points[1] = alignPoints(otherPoint, movingPoint);
+    lineGenerator.processDrawing(temporaryLineElement, lineShapeG);
+    PlaitBoard.getElementActiveHost(board).append(lineShapeG);
+    return temporaryLineElement;
+};
+function drawMask(board, element, id) {
+    const mask = createMask();
+    mask.setAttribute('id', id);
+    const points = getLinePoints(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 = getLineTextRectangle(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":"line-basic.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/line/line-basic.ts"],"names":[],"mappings":"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","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} from '@plait/core';\nimport { pointsOnBezierCurves } from 'points-on-curve';\nimport { getPointOnPolyline, getPointByVector, removeDuplicatePoints, getExtendPoint, isSourceAndTargetIntersect } from '@plait/common';\nimport { LineHandle, LineMarkerType, LineShape, LineText, PlaitDrawElement, PlaitLine, PlaitShape } from '../../interfaces';\nimport { getNearestPoint } from '../geometry';\nimport { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from '../style/stroke';\nimport { getEngine } from '../../engines';\nimport { getShape } from '../shape';\nimport { DefaultLineStyle, LINE_TEXT_SPACE } from '../../constants/line';\nimport { LineShapeGenerator } from '../../generators/line.generator';\nimport { REACTION_MARGIN } from '../../constants';\nimport { getHitOutlineGeometry } from '../position/geometry';\nimport { getLineMemorizedLatest } from '../memorize';\nimport { alignPoints } from './line-resize';\nimport { getElbowLineRouteOptions, getLineHandleRefPair } from './line-common';\nimport { getElbowPoints, getNextSourceAndTargetPoints } from './elbow';\nimport { drawLineArrow } from './line-arrow';\n\nexport const createLineElement = (\n    shape: LineShape,\n    points: [Point, Point],\n    source: LineHandle,\n    target: LineHandle,\n    texts?: LineText[],\n    options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>\n): PlaitLine => {\n    return {\n        id: idCreator(),\n        type: 'line',\n        shape,\n        source,\n        texts: texts ? texts : [],\n        target,\n        opacity: 1,\n        points,\n        ...options\n    };\n};\n\nexport const getLinePoints = (board: PlaitBoard, element: PlaitLine) => {\n    switch (element.shape) {\n        case LineShape.elbow: {\n            return getElbowPoints(board, element);\n        }\n        case LineShape.curve: {\n            return getCurvePoints(board, element);\n        }\n        default: {\n            const points = PlaitLine.getPoints(board, element);\n            const handleRefPair = getLineHandleRefPair(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: PlaitLine) => {\n    if (element.points.length === 2) {\n        const handleRefPair = getLineHandleRefPair(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(getPointByVector(source.point, source.vector, offset));\n        }\n        if (targetBoundElement) {\n            curvePoints.push(getPointByVector(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(getPointByVector(source.point, source.vector, offset));\n            curvePoints.push(getPointByVector(target.point, target.vector, offset));\n        }\n        curvePoints.push(target.point);\n        return pointsOnBezierCurves(curvePoints) as Point[];\n    } else {\n        let dataPoints = PlaitLine.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: PlaitLine) {\n    const result: Point[] = [];\n    const shape = element.shape;\n    const hideBuffer = 10;\n    if (shape === LineShape.straight) {\n        const points = PlaitLine.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 === LineShape.curve) {\n        const points = PlaitLine.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 === LineShape.elbow) {\n        const renderPoints = getElbowPoints(board, element);\n        const options = getElbowLineRouteOptions(board, element);\n        const isIntersect = isSourceAndTargetIntersect(options);\n        if (!isIntersect) {\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 drawLine = (board: PlaitBoard, element: PlaitLine) => {\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 = getLinePoints(board, element);\n    let line;\n    if (element.shape === LineShape.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    lineG.appendChild(line);\n    const { mask, maskTargetFillRect } = drawMask(board, element, id);\n    lineG.appendChild(mask);\n    line.appendChild(maskTargetFillRect);\n    const arrow = drawLineArrow(element, points, { stroke: strokeColor, strokeWidth });\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nexport const getConnectionByNearestPoint = (board: PlaitBoard, point: Point, hitElement: PlaitShape): Point => {\n    let rectangle = RectangleClient.getRectangleByPoints(hitElement.points);\n    let nearestPoint = getNearestPoint(hitElement, point);\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 = (point: Point, hitElement: PlaitShape, rectangle: RectangleClient) => {\n    const shape = getShape(hitElement);\n    const connector = getEngine(shape).getConnectorPoints(rectangle);\n    const points = RectangleClient.getPoints(RectangleClient.getRectangleByCenterPoint(point, 10, 10));\n    const pointRectangle = RectangleClient.getRectangleByPoints(points);\n    return connector.find(point => {\n        return RectangleClient.isHit(pointRectangle, RectangleClient.getRectangleByPoints([point, point]));\n    });\n};\n\nexport const getLineTextRectangle = (board: PlaitBoard, element: PlaitLine, index: number): RectangleClient => {\n    const text = element.texts[index];\n    const elbowPoints = getLinePoints(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 getLines = (board: PlaitBoard) => {\n    return findElements(board, {\n        match: (element: PlaitElement) => PlaitDrawElement.isLine(element),\n        recursion: (element: PlaitElement) => PlaitDrawElement.isDrawElement(element)\n    }) as PlaitLine[];\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 handleLineCreating = (\n    board: PlaitBoard,\n    lineShape: LineShape,\n    sourcePoint: Point,\n    movingPoint: Point,\n    sourceElement: PlaitShape | null,\n    lineShapeG: SVGGElement\n) => {\n    const hitElement = getHitOutlineGeometry(board, movingPoint, REACTION_MARGIN);\n    const targetConnection = hitElement ? getConnectionByNearestPoint(board, movingPoint, hitElement) : undefined;\n    const connection = sourceElement ? getConnectionByNearestPoint(board, sourcePoint, sourceElement) : undefined;\n    const targetBoundId = hitElement ? hitElement.id : undefined;\n    const lineGenerator = new LineShapeGenerator(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 = createLineElement(\n        lineShape,\n        [sourcePoint, movingPoint],\n        { marker: sourceMarker || LineMarkerType.none, connection: connection, boundId: sourceElement?.id },\n        { marker: targetMarker || LineMarkerType.arrow, connection: targetConnection, boundId: targetBoundId },\n        [],\n        {\n            strokeWidth: DefaultLineStyle.strokeWidth,\n            ...memorizedLatest\n        }\n    );\n    const linePoints = getLinePoints(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 drawMask(board: PlaitBoard, element: PlaitLine, id: string) {\n    const mask = createMask();\n    mask.setAttribute('id', id);\n    const points = getLinePoints(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 = getLineTextRectangle(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/line/line-common.mjs

@@ -0,0 +1,111 @@
+import { getElementById, RectangleClient, Direction } from '@plait/core';
+import { getDirectionFactor, rotateVectorAnti90, getDirectionByVector, getOppositeDirection, getDirectionByPointOfRectangle, getSourceAndTargetOuterRectangle, getNextPoint } from '@plait/common';
+import { BasicShapes, LineHandleKey, LineMarkerType, PlaitLine } from '../../interfaces';
+import { getStrokeWidthByElement } from '../style/stroke';
+import { getEngine } from '../../engines';
+import { getShape } from '../shape';
+import { getSourceAndTargetRectangle } from './elbow';
+export const getLineHandleRefPair = (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: LineHandleKey.source,
+        point: sourcePoint,
+        direction: sourceDirection,
+        vector: [sourceFactor.x, sourceFactor.y]
+    };
+    const targetHandleRef = {
+        key: LineHandleKey.target,
+        point: targetPoint,
+        direction: targetDirection,
+        vector: [targetFactor.x, targetFactor.y]
+    };
+    if (sourceBoundElement) {
+        const connectionOffset = PlaitLine.isSourceMarkOrTargetMark(element, LineMarkerType.none, LineHandleKey.source) ? 0 : strokeWidth;
+        const sourceVector = getVectorByConnection(sourceBoundElement, element.source.connection);
+        const direction = getDirectionByVector(sourceVector);
+        sourceDirection = direction ? direction : sourceDirection;
+        sourcePoint = getConnectionPoint(sourceBoundElement, element.source.connection, sourceDirection, connectionOffset);
+        sourceHandleRef.boundElement = sourceBoundElement;
+        sourceHandleRef.direction = sourceDirection;
+        sourceHandleRef.point = sourcePoint;
+        sourceHandleRef.vector = sourceVector;
+    }
+    if (targetBoundElement) {
+        const connectionOffset = PlaitLine.isSourceMarkOrTargetMark(element, LineMarkerType.none, LineHandleKey.target) ? 0 : strokeWidth;
+        const targetVector = getVectorByConnection(targetBoundElement, element.target.connection);
+        const direction = getDirectionByVector(targetVector);
+        targetDirection = direction ? direction : targetDirection;
+        targetPoint = getConnectionPoint(targetBoundElement, element.target.connection, targetDirection, connectionOffset);
+        targetHandleRef.boundElement = targetBoundElement;
+        targetHandleRef.direction = targetDirection;
+        targetHandleRef.point = targetPoint;
+        targetHandleRef.vector = targetVector;
+    }
+    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 = getShape(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 ?? getLineHandleRefPair(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":"line-common.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/line/line-common.ts"],"names":[],"mappings":"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","sourcesContent":["import { Point, PlaitBoard, getElementById, RectangleClient, PointOfRectangle, Direction, Vector } from '@plait/core';\nimport {\n    getDirectionFactor,\n    rotateVectorAnti90,\n    getDirectionByVector,\n    getOppositeDirection,\n    getDirectionByPointOfRectangle,\n    getSourceAndTargetOuterRectangle,\n    getNextPoint\n} from '@plait/common';\nimport { BasicShapes, LineHandleKey, LineHandleRef, LineHandleRefPair, LineMarkerType, PlaitGeometry, PlaitLine } from '../../interfaces';\nimport { getStrokeWidthByElement } from '../style/stroke';\nimport { getEngine } from '../../engines';\nimport { getShape } from '../shape';\nimport { getSourceAndTargetRectangle } from './elbow';\n\nexport const getLineHandleRefPair = (board: PlaitBoard, element: PlaitLine): LineHandleRefPair => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const sourceBoundElement = element.source.boundId ? getElementById<PlaitGeometry>(board, element.source.boundId) : undefined;\n    const targetBoundElement = element.target.boundId ? getElementById<PlaitGeometry>(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: LineHandleRef = {\n        key: LineHandleKey.source,\n        point: sourcePoint,\n        direction: sourceDirection,\n        vector: [sourceFactor.x, sourceFactor.y]\n    };\n    const targetHandleRef: LineHandleRef = {\n        key: LineHandleKey.target,\n        point: targetPoint,\n        direction: targetDirection,\n        vector: [targetFactor.x, targetFactor.y]\n    };\n    if (sourceBoundElement) {\n        const connectionOffset = PlaitLine.isSourceMarkOrTargetMark(element, LineMarkerType.none, LineHandleKey.source) ? 0 : strokeWidth;\n        const sourceVector = getVectorByConnection(sourceBoundElement, element.source.connection!);\n        const direction = getDirectionByVector(sourceVector);\n        sourceDirection = direction ? direction : sourceDirection;\n        sourcePoint = getConnectionPoint(sourceBoundElement, element.source.connection!, sourceDirection, connectionOffset);\n        sourceHandleRef.boundElement = sourceBoundElement;\n        sourceHandleRef.direction = sourceDirection;\n        sourceHandleRef.point = sourcePoint;\n        sourceHandleRef.vector = sourceVector;\n    }\n    if (targetBoundElement) {\n        const connectionOffset = PlaitLine.isSourceMarkOrTargetMark(element, LineMarkerType.none, LineHandleKey.target) ? 0 : strokeWidth;\n        const targetVector = getVectorByConnection(targetBoundElement, element.target.connection!);\n        const direction = getDirectionByVector(targetVector);\n        targetDirection = direction ? direction : targetDirection;\n        targetPoint = getConnectionPoint(targetBoundElement, element.target.connection!, targetDirection, connectionOffset);\n        targetHandleRef.boundElement = targetBoundElement;\n        targetHandleRef.direction = targetDirection;\n        targetHandleRef.point = targetPoint;\n        targetHandleRef.vector = targetVector;\n    }\n    return { source: sourceHandleRef, target: targetHandleRef };\n};\n\nexport const getConnectionPoint = (geometry: PlaitGeometry, 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: PlaitGeometry, connection: PointOfRectangle): Vector => {\n    const rectangle = RectangleClient.getRectangleByPoints(boundElement.points);\n    const shape = getShape(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: PlaitLine, handleRefPair?: LineHandleRefPair) => {\n    handleRefPair = handleRefPair ?? getLineHandleRefPair(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"]}