@plait/draw 0.50.1 → 0.51.1

package/generators/line-active.generator.d.ts

@@ -1,11 +1,13 @@
-import { PlaitBoard, Point } from '@plait/core';
+import { Point } from '@plait/core';
 import { PlaitLine } from '../interfaces';
 import { Generator } from '@plait/common';
 export interface ActiveData {
     selected: boolean;
+    linePoints: Point[];
 }
 export declare class LineActiveGenerator extends Generator<PlaitLine, ActiveData> {
+    onlySelectedCurrentLine: boolean;
     canDraw(element: PlaitLine, data: ActiveData): boolean;
     draw(element: PlaitLine, data: ActiveData): SVGGElement;
+    needUpdate(): boolean;
 }
-export declare function getMiddlePoints(board: PlaitBoard, element: PlaitLine): Point[];

package/interfaces/geometry.d.ts

@@ -64,6 +64,7 @@ export declare const PlaitGeometry: {};
 export interface ShapeEngine {
     isHit: (rectangle: RectangleClient, point: Point) => boolean;
     getNearestPoint: (rectangle: RectangleClient, point: Point) => Point;
+    getNearestCrossingPoint?: (rectangle: RectangleClient, point: Point) => Point;
     getConnectorPoints: (rectangle: RectangleClient) => Point[];
     getCornerPoints: (rectangle: RectangleClient) => Point[];
     getEdgeByConnectionPoint?: (rectangle: RectangleClient, point: PointOfRectangle) => [Point, Point] | null;

package/interfaces/line.d.ts

@@ -41,6 +41,10 @@ export interface LineHandleRef {
     vector: Vector;
     boundElement?: PlaitGeometry;
 }
+export interface LineHandleRefPair {
+    source: LineHandleRef;
+    target: LineHandleRef;
+}
 export interface PlaitLine extends PlaitElement {
     type: 'line';
     shape: LineShape;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plait/draw",
-  "version": "0.50.1",
+  "version": "0.51.1",
   "peerDependencies": {
     "@angular/common": "^16.0.0",
     "@angular/core": "^16.0.0",

package/plugins/with-draw-resize.d.ts

@@ -0,0 +1,13 @@
+import { ResizeRef, ResizeState } from '@plait/common';
+import { PlaitBoard, Point } from '@plait/core';
+import { PlaitDrawElement } from '../interfaces';
+export declare function withDrawResize(board: PlaitBoard): PlaitBoard;
+export declare const getResizeOriginPointAndHandlePoint: (board: PlaitBoard, resizeRef: ResizeRef<PlaitDrawElement | PlaitDrawElement[]>) => {
+    originPoint: Point;
+    handlePoint: Point;
+};
+export declare const getResizeZoom: (resizeState: ResizeState, resizeOriginPoint: Point, resizeHandlePoint: Point, isFromCorner: boolean, isAspectRatio: boolean) => {
+    xZoom: number;
+    yZoom: number;
+};
+export declare const movePointByZoomAndOriginPoint: (p: Point, resizeOriginPoint: Point, xZoom: number, yZoom: number) => Point;

package/utils/geometry.d.ts

@@ -11,7 +11,6 @@ export type TextProperties = Partial<CustomText> & {
     textHeight?: number;
 };
 export declare const createGeometryElement: (shape: GeometryShapes, points: [Point, Point], text: string | Element, options?: GeometryStyleOptions, textProperties?: TextProperties) => PlaitGeometry;
-export declare const getPointsByCenterPoint: (point: Point, width: number, height: number) => [Point, Point];
 export declare const getTextRectangle: (element: PlaitGeometry) => {
     height: number;
     width: number;
@@ -20,9 +19,8 @@ export declare const getTextRectangle: (element: PlaitGeometry) => {
 };
 export declare const drawBoundMask: (board: PlaitBoard, element: PlaitGeometry) => SVGGElement;
 export declare const drawGeometry: (board: PlaitBoard, outerRectangle: RectangleClient, shape: GeometryShapes, options: Options) => SVGGElement;
-export declare const getNearestPoint: (element: PlaitShape, point: Point, inflateDelta?: number) => Point;
+export declare const getNearestPoint: (element: PlaitShape, point: Point) => Point;
 export declare const getCenterPointsOnPolygon: (points: Point[]) => Point[];
-export declare const getEdgeOnPolygonByPoint: (corners: Point[], point: Point) => [Point, Point] | null;
 export declare const getDefaultFlowchartProperty: (symbol: FlowchartSymbols) => {
     width: number;
     height: number;

package/utils/hit.d.ts

@@ -1,5 +1,7 @@
 import { PlaitElement, Selection, PlaitBoard, Point } from '@plait/core';
-import { PlaitGeometry } from '../interfaces';
+import { PlaitGeometry, PlaitLine } from '../interfaces';
 export declare const isTextExceedingBounds: (geometry: PlaitGeometry) => boolean;
+export declare const isHitLineText: (board: PlaitBoard, element: PlaitLine, point: Point) => boolean;
+export declare const isHitPolyLine: (pathPoints: Point[], point: Point, strokeWidth: number, expand?: number) => boolean;
 export declare const isRectangleHitDrawElement: (board: PlaitBoard, element: PlaitElement, selection: Selection) => boolean | null;
 export declare const isHitDrawElement: (board: PlaitBoard, element: PlaitElement, point: Point) => boolean | null;

package/utils/index.d.ts

@@ -1,4 +1,4 @@
-export * from './line';
+export * from './line/index';
 export * from './geometry';
 export * from './selected';
 export * from './style';

package/utils/line/elbow.d.ts

@@ -0,0 +1,19 @@
+import { Point, PlaitBoard } from '@plait/core';
+import { LineHandleRefPair, PlaitLine } from '../../interfaces';
+export declare const getElbowPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const getNextSourceAndTargetPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const getSourceAndTargetRectangle: (board: PlaitBoard, element: PlaitLine, handleRefPair: LineHandleRefPair) => {
+    sourceRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    targetRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export declare function getNextRenderPoints(board: PlaitBoard, element: PlaitLine, renderPoints?: Point[]): Point[];

package/utils/line/index.d.ts

@@ -0,0 +1,5 @@
+export * from './elbow';
+export * from './line-arrow';
+export * from './line-basic';
+export * from './line-common';
+export * from './line-resize';

package/utils/{line-arrow.d.ts → line/line-arrow.d.ts}

@@ -1,4 +1,4 @@
 import { Point } from '@plait/core';
-import { PlaitLine } from '../interfaces';
+import { PlaitLine } from '../../interfaces';
 import { Options } from 'roughjs/bin/core';
 export declare const drawLineArrow: (element: PlaitLine, points: Point[], options: Options) => SVGGElement | null;

package/utils/line/line-basic.d.ts

@@ -0,0 +1,13 @@
+import { Point, PlaitBoard, RectangleClient } from '@plait/core';
+import { LineHandle, LineShape, LineText, PlaitLine, PlaitShape } from '../../interfaces';
+export declare const createLineElement: (shape: LineShape, points: [Point, Point], source: LineHandle, target: LineHandle, texts?: LineText[], options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>) => PlaitLine;
+export declare const getLinePoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const getCurvePoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare function getMiddlePoints(board: PlaitBoard, element: PlaitLine): Point[];
+export declare const drawLine: (board: PlaitBoard, element: PlaitLine) => SVGGElement;
+export declare const getConnectionByNearestPoint: (board: PlaitBoard, point: Point, hitElement: PlaitShape) => Point;
+export declare const getHitConnectorPoint: (point: Point, hitElement: PlaitShape, rectangle: RectangleClient) => Point | undefined;
+export declare const getLineTextRectangle: (board: PlaitBoard, element: PlaitLine, index: number) => RectangleClient;
+export declare const getLines: (board: PlaitBoard) => PlaitLine[];
+export declare const Q2C: (points: Point[]) => Point[];
+export declare const handleLineCreating: (board: PlaitBoard, lineShape: LineShape, sourcePoint: Point, movingPoint: Point, sourceElement: PlaitShape | null, lineShapeG: SVGGElement) => PlaitLine;

package/utils/line/line-common.d.ts

@@ -0,0 +1,35 @@
+import { Point, PlaitBoard, PointOfRectangle, Direction, Vector } from '@plait/core';
+import { LineHandleRefPair, PlaitGeometry, PlaitLine } from '../../interfaces';
+export declare const getLineHandleRefPair: (board: PlaitBoard, element: PlaitLine) => LineHandleRefPair;
+export declare const getConnectionPoint: (geometry: PlaitGeometry, connection: Point, direction?: Direction, delta?: number) => Point;
+export declare const getVectorByConnection: (boundElement: PlaitGeometry, connection: PointOfRectangle) => Vector;
+export declare const getElbowLineRouteOptions: (board: PlaitBoard, element: PlaitLine, handleRefPair?: LineHandleRefPair) => {
+    sourcePoint: PointOfRectangle;
+    nextSourcePoint: Point;
+    sourceRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    sourceOuterRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    targetPoint: PointOfRectangle;
+    nextTargetPoint: Point;
+    targetRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    targetOuterRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};

package/utils/line/line-resize.d.ts

@@ -0,0 +1,23 @@
+import { ElbowLineRouteOptions, ResizeState } from '@plait/common';
+import { PlaitBoard, Point } from '@plait/core';
+import { PlaitLine } from '../../interfaces';
+export declare const alignPoints: (basePoint: Point, movingPoint: Point) => Point;
+export declare function getResizedPreviousAndNextPoint(nextRenderPoints: Point[], sourcePoint: Point, targetPoint: Point, handleIndex: number): {
+    previous: Point | null;
+    next: Point | null;
+};
+export declare function alignElbowSegment(startKeyPoint: Point, endKeyPoint: Point, resizeState: ResizeState, resizedPreviousAndNextPoint: {
+    previous: Point | null;
+    next: Point | null;
+}): Point[];
+export declare function getIndexAndDeleteCountByKeyPoint(board: PlaitBoard, element: PlaitLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): {
+    index: null;
+    deleteCount: null;
+} | {
+    index: number;
+    deleteCount: number | null;
+};
+export declare function getMirrorDataPoints(board: PlaitBoard, nextDataPoints: Point[], nextKeyPoints: Point[], params: ElbowLineRouteOptions): Point[];
+export declare function isUpdatedHandleIndex(board: PlaitBoard, element: PlaitLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): boolean;
+export declare function getMidKeyPoints(simplifiedNextKeyPoints: Point[], startPoint: Point, endPoint: Point): Point[];
+export declare const hasIllegalElbowPoint: (midDataPoints: Point[]) => boolean;

package/utils/polygon.d.ts

@@ -0,0 +1,4 @@
+import { Point } from '@plait/core';
+export declare const getCenterPointsOnPolygon: (points: Point[]) => Point[];
+export declare const getCrossingPointBetweenPointAndPolygon: (corners: Point[], point: Point) => Point[];
+export declare const getPolygonEdgeByConnectionPoint: (corners: Point[], point: Point) => [Point, Point] | null;

package/utils/position/geometry.d.ts

@@ -1,8 +1,7 @@
-import { PlaitBoard, Point } from '@plait/core';
+import { PlaitBoard, Point, RectangleClient } from '@plait/core';
 import { PlaitGeometry } from '../../interfaces';
 import { ResizeHandle } from '@plait/common';
-import { PlaitImage } from '../../interfaces/image';
-export declare const getHitGeometryResizeHandleRef: (board: PlaitBoard, element: PlaitGeometry | PlaitImage, point: Point) => {
+export declare const getHitRectangleResizeHandleRef: (board: PlaitBoard, rectangle: RectangleClient, point: Point) => {
     rectangle: {
         x: number;
         y: number;

package/utils/position/line.d.ts

@@ -7,8 +7,10 @@ export declare enum LineResizeHandle {
 }
 export declare const getHitLineResizeHandleRef: (board: PlaitBoard, element: PlaitLine, point: Point) => {
     handle: LineResizeHandle;
-    index: number;
+    handleIndex: number;
 } | {
-    index: number;
+    handleIndex: number;
     handle?: undefined;
 } | undefined;
+export declare function getHitPointIndex(points: Point[], movingPoint: Point): number;
+export declare const getHitLineTextIndex: (board: PlaitBoard, element: PlaitLine, point: Point) => number;

package/utils/resize-align-reaction.d.ts

@@ -0,0 +1,42 @@
+import { ResizeState } from '@plait/common';
+import { DirectionFactors, PlaitBoard, PlaitElement, Point, RectangleClient } from '@plait/core';
+export interface ResizeAlignDelta {
+    deltaX: number;
+    deltaY: number;
+}
+export interface AlignLineRef extends ResizeAlignDelta {
+    xZoom: number;
+    yZoom: number;
+    activePoints: Point[];
+}
+export interface ResizeAlignRef extends AlignLineRef {
+    alignG: SVGGElement;
+}
+export interface ResizeAlignOptions {
+    resizeState: ResizeState;
+    resizeOriginPoints: Point[];
+    activeRectangle: RectangleClient;
+    directionFactors: DirectionFactors;
+    originPoint: Point;
+    handlePoint: Point;
+    isFromCorner: boolean;
+    isAspectRatio: boolean;
+}
+type TripleAlignAxis = [number, number, number];
+export declare class ResizeAlignReaction {
+    private board;
+    private activeElements;
+    alignRectangles: RectangleClient[];
+    constructor(board: PlaitBoard, activeElements: PlaitElement[]);
+    getAlignRectangle(): RectangleClient[];
+    getAlignLineRef(resizeAlignDelta: ResizeAlignDelta, resizeAlignOptions: ResizeAlignOptions): AlignLineRef;
+    getEqualLineDelta(resizeAlignOptions: ResizeAlignOptions): ResizeAlignDelta;
+    drawEqualLines(activePoints: Point[], resizeAlignOptions: ResizeAlignOptions): SVGGElement;
+    getAlignLineDelta(resizeAlignOptions: ResizeAlignOptions): ResizeAlignDelta;
+    drawAlignLines(activePoints: Point[], resizeAlignOptions: ResizeAlignOptions): SVGGElement;
+    handleResizeAlign(resizeAlignOptions: ResizeAlignOptions): ResizeAlignRef;
+}
+export declare const getTripleAlignAxis: (rectangle: RectangleClient, isHorizontal: boolean) => TripleAlignAxis;
+export declare const isAlign: (axis: number, rectangle: RectangleClient, isHorizontal: boolean) => boolean;
+export declare const getClosestDelta: (axis: number, rectangle: RectangleClient, isHorizontal: boolean) => number;
+export {};

package/utils/resize-align.d.ts

@@ -0,0 +1,8 @@
+import { PlaitBoard, Point } from '@plait/core';
+import { ResizeRef, ResizeState } from '@plait/common';
+import { PlaitDrawElement } from '../interfaces';
+import { ResizeAlignRef } from './resize-align-reaction';
+export declare function getResizeAlignRef(board: PlaitBoard, resizeRef: ResizeRef<PlaitDrawElement | PlaitDrawElement[]>, resizeState: ResizeState, resizeOriginPointAndHandlePoint: {
+    originPoint: Point;
+    handlePoint: Point;
+}, isAspectRatio: boolean, isFromCorner: boolean): ResizeAlignRef;

package/esm2022/utils/line-arrow.mjs

@@ -1,123 +0,0 @@
-import { arrowPoints, createG, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate } from '@plait/core';
-import { LineMarkerType, PlaitLine } from '../interfaces';
-import { getFactorByPoints, getExtendPoint } 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 directionFactor = getFactorByPoints(source, target);
-    const strokeWidth = getStrokeWidthByElement(element);
-    const endPoint = [target[0] + (strokeWidth * directionFactor.x) / 2, target[1] + (strokeWidth * directionFactor.y) / 2];
-    const distance = distanceBetweenPointAndPoint(...source, ...endPoint);
-    const middlePoint = [
-        endPoint[0] - (((distance * 3) / 5 + strokeWidth) / 2) * directionFactor.x,
-        endPoint[1] - (((distance * 3) / 5 + strokeWidth) / 2) * directionFactor.y
-    ];
-    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 directionFactor = getFactorByPoints(source, target);
-    const strokeWidth = getStrokeWidthByElement(element);
-    const endPoint = [target[0] + (strokeWidth * directionFactor.x) / 2, target[1] + (strokeWidth * directionFactor.y) / 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-arrow.ts"],"names":[],"mappings":"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","sourcesContent":["import { Point, arrowPoints, createG, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate } from '@plait/core';\nimport { LineMarkerType, PlaitLine } from '../interfaces';\nimport { Options } from 'roughjs/bin/core';\nimport { getFactorByPoints, getExtendPoint } 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 directionFactor = getFactorByPoints(source, target);\n    const strokeWidth = getStrokeWidthByElement(element);\n    const endPoint: Point = [target[0] + (strokeWidth * directionFactor.x) / 2, target[1] + (strokeWidth * directionFactor.y) / 2];\n    const distance = distanceBetweenPointAndPoint(...source, ...endPoint);\n    const middlePoint: Point = [\n        endPoint[0] - (((distance * 3) / 5 + strokeWidth) / 2) * directionFactor.x,\n        endPoint[1] - (((distance * 3) / 5 + strokeWidth) / 2) * directionFactor.y\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 directionFactor = getFactorByPoints(source, target);\n    const strokeWidth = getStrokeWidthByElement(element);\n    const endPoint: Point = [target[0] + (strokeWidth * directionFactor.x) / 2, target[1] + (strokeWidth * directionFactor.y) / 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"]}