@libs-ui/components-draw-line 0.2.61

package/esm2022/draw-line.directive.mjs

@@ -0,0 +1,595 @@
+import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, Input, NgZone, Output, inject } from "@angular/core";
+import { checkMouseOverInContainer, cloneDeep, get } from "@libs-ui/utils";
+import { Subject, fromEvent, mergeMap, startWith, takeUntil, tap } from "rxjs";
+import { MoCanvasConnectNavigationNewElementUtil } from "./util/connect-navigation-new-element.util";
+import * as i0 from "@angular/core";
+export class LibsUiComponentsDrawLineDirective {
+    cdr = inject(ChangeDetectorRef);
+    zone = inject(NgZone);
+    elementRef = inject(ElementRef);
+    intervalScrollToElement;
+    dataDraw = [];
+    dataReachablePointRange = [];
+    onDrawLineEnd = new Subject();
+    onDestroy = new Subject();
+    viewBoxConfig;
+    svgElement;
+    drawRectDebug;
+    outDrawLineFunctionControl = new EventEmitter();
+    outConnected = new EventEmitter();
+    ngAfterViewInit() {
+        this.svgElement = this.svgElement || document.createElementNS("http://www.w3.org/2000/svg", "svg");
+        this.elementRef.nativeElement.append(this.svgElement);
+        this.outDrawLineFunctionControl.emit({
+            setData: this.setData.bind(this),
+            setReachablePointRange: this.setReachablePointRange.bind(this),
+            removeLine: this.removeLine.bind(this),
+            removeReachablePointRange: this.removeReachablePointRange.bind(this),
+            updateViewBox: this.updateViewBox.bind(this)
+        });
+    }
+    setData(data) {
+        const newData = [];
+        data.forEach(item => {
+            if (this.dataDraw.find(dataDraw => dataDraw.id === item.id && item.points.start.x === dataDraw.points.start.x && item.points.start.y === dataDraw.points.start.y && item.points.end.x === dataDraw.points.end.x && item.points.end.y === dataDraw.points.end.y)) {
+                return;
+            }
+            const itemClone = cloneDeep(item);
+            itemClone.ref = item;
+            newData.push(itemClone);
+        });
+        this.dataDraw.push(...newData);
+        this.startProcessDataRow(newData);
+    }
+    setReachablePointRange(data) {
+        const newData = [];
+        data.forEach(item => {
+            if (this.dataReachablePointRange.find(dataDraw => dataDraw.id === item.id || item.x === dataDraw.x && item.y === dataDraw.y)) {
+                return;
+            }
+            const itemClone = cloneDeep(item);
+            itemClone.ref = item;
+            newData.push(itemClone);
+        });
+        this.dataReachablePointRange.push(...newData);
+        this.startProcessDataReachablePointRange(newData);
+    }
+    removeLine(id, points) {
+        const dataDrawById = this.dataDraw.filter(item => item.id === id);
+        if (!dataDrawById?.length) {
+            return;
+        }
+        const removeByItem = (item) => {
+            this.removeElementOfPoints(item.points);
+            item.points.separatedPoints?.forEach(separatedPoints => this.removeElementOfPoints(separatedPoints));
+        };
+        if (!points?.length) {
+            dataDrawById.forEach(item => removeByItem(item));
+            this.dataDraw = this.dataDraw.filter(item => item.id !== id);
+            this.updateViewBox();
+            return;
+        }
+        points.forEach(point => {
+            const dataDrawRemoveByPoint = dataDrawById.find(item => item.points.start.x === point.start.x && item.points.start.y === point.start.y && item.points.end.x === point.end.x && item.points.end.y === point.end.y);
+            if (dataDrawRemoveByPoint) {
+                dataDrawRemoveByPoint.isRemove = true;
+                removeByItem(dataDrawRemoveByPoint);
+                this.dataDraw = this.dataDraw.filter(item => item.id !== id && !item.isRemove);
+            }
+        });
+        this.updateViewBox();
+    }
+    removeReachablePointRange(ids) {
+        this.clearRect();
+        if (!ids.length) {
+            return;
+        }
+        ids.forEach(id => {
+            const itemRemove = this.dataReachablePointRange?.find(item => item.id === id);
+            if (!itemRemove) {
+                return;
+            }
+            itemRemove.onDestroyEvent?.next();
+            itemRemove.element?.remove();
+            this.dataReachablePointRange = this.dataReachablePointRange?.filter(item => item.id !== id);
+        });
+    }
+    startProcessDataRow(dataDraw) {
+        this.zone.runOutsideAngular(() => {
+            dataDraw.forEach(item => {
+                const { pathElement, arrowElement, circleStartElement, circleEndElement } = this.createPathAndArrowElement(item.id);
+                item.points.obstacleRect?.forEach(data => this.addRect('rect', data));
+                item.points.pathElement = pathElement;
+                item.points.arrowElement = arrowElement;
+                if (item.startCircle) {
+                    item.points.circleStartElement = circleStartElement;
+                    this.svgElement.append(circleStartElement);
+                }
+                if (item.endCircle) {
+                    item.points.circleEndElement = circleEndElement;
+                    this.svgElement.append(circleEndElement);
+                }
+                item.points.onDestroyEvent = new Subject();
+                this.drawLine(item);
+            });
+            this.updateViewBox();
+        });
+    }
+    startProcessDataReachablePointRange(data) {
+        this.zone.runOutsideAngular(() => {
+            data.forEach(item => {
+                item.onDestroyEvent = new Subject();
+                item.element = this.createPathAndArrowElement(item.id).circleEndElement;
+                this.svgElement.append(item.element);
+                this.updateAttributeCircle(item.element, item.id, item, item.style);
+                this.onDrawLineEnd.pipe(takeUntil(item.onDestroyEvent), takeUntil(this.onDestroy)).subscribe(eventData => {
+                    const { dataLine, event } = eventData;
+                    if (!checkMouseOverInContainer(event, item.element) || !dataLine.ref || !item.ref) {
+                        return;
+                    }
+                    item.idConnected = eventData.dataLine.id;
+                    eventData.dataLine.idConnected = item.id;
+                    this.outConnected.emit({
+                        dataLine: dataLine.ref,
+                        dataReachablePointRange: item.ref
+                    });
+                });
+            });
+            this.updateViewBox();
+        });
+    }
+    removeElementOfPoints(points) {
+        this.zone.runOutsideAngular(() => {
+            points.onDestroyEvent?.next();
+            points.onDestroyEvent?.complete();
+            points?.pathElement?.remove();
+            points?.arrowElement?.remove();
+            points?.circleStartElement?.remove();
+            points.circleEndElement?.remove();
+        });
+    }
+    drawLine(data) {
+        this.zone.runOutsideAngular(() => {
+            const { points, mode } = data;
+            let { curve } = data?.lineStyle || {};
+            if (mode !== 'quart-in') {
+                curve = curve ?? 10;
+            }
+            const preLengthSeparatedPoints = points.separatedPoints?.length;
+            points.separatedPoints?.forEach(separatedPoints => this.removeElementOfPoints(separatedPoints));
+            points.separatedPoints = [];
+            MoCanvasConnectNavigationNewElementUtil.START_MODE = 'right-left';
+            if (data.startEndMode) {
+                MoCanvasConnectNavigationNewElementUtil.START_MODE = data.startEndMode;
+            }
+            this.calculatorSeparatedPoints(data.id, points, curve || 10, points.separatedPoints, points.obstacleRect || []);
+            if (!preLengthSeparatedPoints && points.separatedPoints.length) {
+                this.removeElementOfPoints(points);
+                const { pathElement, arrowElement } = this.createPathAndArrowElement(data.id);
+                points.pathElement = pathElement;
+                points.arrowElement = arrowElement;
+                points.initialized = false;
+            }
+            if (!points.separatedPoints?.length) {
+                this.buildPathAndDraw(data, points, mode);
+                return;
+            }
+            points.separatedPoints.forEach(separatedPoints => {
+                this.buildPathAndDraw(data, separatedPoints, separatedPoints.mode || mode);
+            });
+        });
+    }
+    updateViewBox(viewBoxConfig) {
+        if (viewBoxConfig) {
+            this.viewBoxConfig = viewBoxConfig;
+        }
+        const xPoints = new Set([0]);
+        const yPoints = new Set([0]);
+        const addPoints = (points) => {
+            xPoints.add(points.start.x);
+            xPoints.add(points.end.x);
+            yPoints.add(points.start.y);
+            yPoints.add(points.end.y);
+        };
+        this.dataDraw?.forEach(item => {
+            const points = item.points;
+            addPoints(points);
+            points.separatedPoints?.forEach(separatedPoints => addPoints(separatedPoints));
+            points.obstacleRect?.forEach(obstacleRect => {
+                addPoints({
+                    start: { x: obstacleRect.x - (obstacleRect.gapXObstacleRect || 8), y: obstacleRect.y - (obstacleRect.gapYObstacleRect || 8) },
+                    end: { x: obstacleRect.x + obstacleRect.width + (obstacleRect.gapXObstacleRect || 8) * 2, y: obstacleRect.y + obstacleRect.height + (obstacleRect.gapYObstacleRect || 8) * 2 }
+                });
+            });
+        });
+        const xMax = this.viewBoxConfig?.width ?? (xPoints.size ? Math.max(...xPoints) : 0) + 14;
+        const yMax = this.viewBoxConfig?.height ?? (yPoints.size ? Math.max(...yPoints) : 0) + 14;
+        if (!this.viewBoxConfig?.ignoreViewBox) {
+            const rectSvgElement = this.svgElement.getBoundingClientRect();
+            this.svgElement?.setAttribute('viewBox', `${this.viewBoxConfig?.minX ?? rectSvgElement.x} ${this.viewBoxConfig?.minY ?? rectSvgElement.y} ${xMax} ${yMax}`);
+        }
+        this.svgElement?.setAttribute('width', `${xMax ?? 0}`);
+        this.svgElement?.setAttribute('height', `${yMax ?? 0}`);
+    }
+    isPointInsideSquare(point, square) {
+        const { x, y } = point;
+        const { x: squareX, y: squareY, width, height } = square;
+        return x >= squareX && x <= squareX + width && y >= squareY && y <= squareY + height;
+    }
+    calculatorSeparatedPoints(name, points, curve, separatedPoints, obstacleRects) {
+        if (!obstacleRects.length) {
+            return;
+        }
+        const elementStart = obstacleRects.find(item => this.isPointInsideSquare(points.start, item));
+        const elementEnd = obstacleRects.find(item => this.isPointInsideSquare(points.end, item));
+        if (this.viewBoxConfig?.marginBetweenElement) {
+            MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT = this.viewBoxConfig?.marginBetweenElement ?? 32;
+        }
+        MoCanvasConnectNavigationNewElementUtil.setXYConnectElements(elementStart ?? { ...points.start, width: 1, height: 1 }, elementEnd ?? { ...points.end, width: 1, height: 1 }, obstacleRects, separatedPoints, curve);
+        separatedPoints?.forEach(item => {
+            item.pathElement = this.createPathAndArrowElement(name).pathElement;
+        });
+    }
+    buildPathAndDraw(data, points, mode) {
+        let dPath = {};
+        const styleConfig = {
+            stroke: data.lineStyle?.stroke ?? '#9CA2AD',
+            strokeDasharray: data.lineStyle?.strokeDasharray,
+            strokeWidth: data.lineStyle?.strokeWidth ?? '1px',
+            fill: data.lineStyle?.fill ?? 'none',
+            curve: data.lineStyle?.curve ?? 10,
+            distancePoint: data.lineStyle?.distancePoint ?? 10
+        };
+        points.pathElement?.setAttribute('stroke', styleConfig.stroke);
+        points.pathElement?.setAttribute('fill', styleConfig.fill);
+        points.pathElement?.setAttribute('stroke-width', styleConfig.strokeWidth);
+        if (styleConfig.strokeDasharray) {
+            points.pathElement?.setAttribute('stroke-dasharray', styleConfig.strokeDasharray);
+        }
+        let { curve, distancePoint } = styleConfig;
+        mode = mode || "quart-in";
+        if (mode !== 'quart-in') {
+            curve = curve ?? 10;
+            distancePoint = distancePoint ?? 10;
+        }
+        if (mode === 'quart-in' || points.start.x === points.end.x || points.start.y === points.end.y) {
+            this.drawBalancedCurve(dPath, points);
+            if (mode === 'quart-in') {
+                dPath = {};
+                this.drawBendBothEndsCurve(dPath, points);
+            }
+            points.pathElement?.setAttribute('d', this.builDAttributeToString(dPath));
+            this.drawRectAndInitEvent(data, mode);
+            return;
+        }
+        const result = this.calculatorDistancePointAndCurve(points, distancePoint, curve, mode);
+        distancePoint = result.distancePoint;
+        curve = result.curve;
+        this.buildDAttributeByPointEndModeHorizontal(dPath, points, distancePoint || 0, curve || 0, mode);
+        this.buildDAttributeByPointEndModeVertical(dPath, points, distancePoint || 0, curve || 0, mode);
+        points.pathElement?.setAttribute('d', this.builDAttributeToString(dPath));
+        this.drawRectAndInitEvent(data, mode);
+    }
+    calculatorDistancePointAndCurve(points, distancePoint, curve, mode) {
+        if ((!mode.includes('vertical') && !mode.includes('horizontal'))) {
+            return { curve, distancePoint };
+        }
+        const gapX = Math.abs(points.start.x - points.end.x);
+        const gapY = Math.abs(points.start.y - points.end.y);
+        const multiplierCurve = mode.includes('horizontal') ? 1 : 2;
+        const multiplierDistance = mode.includes('horizontal') ? 2 : 1;
+        if (!mode.includes('single-curve')) {
+            if (gapX < distancePoint * multiplierDistance + curve * multiplierCurve) {
+                distancePoint = curve = gapX / 3;
+            }
+            if (gapY < distancePoint * multiplierDistance + curve * multiplierCurve) {
+                distancePoint = curve = gapY / 3;
+            }
+            return { curve, distancePoint };
+        }
+        const minGap = Math.min(gapX, gapY);
+        if (minGap < distancePoint) {
+            distancePoint = minGap;
+        }
+        if (minGap < curve) {
+            curve = minGap;
+        }
+        return { curve, distancePoint };
+    }
+    drawRectAndInitEvent(data, mode) {
+        const points = data.points;
+        this.updateStyleArrow(points, mode, data);
+        if (data.startCircle && points.circleStartElement) {
+            this.updateAttributeCircle(points.circleStartElement, data.id, points.start, data.startCircleStyle);
+        }
+        if (data.endCircle && points.circleEndElement) {
+            this.updateAttributeCircle(points.circleEndElement, data.id, points.end, data.endCircleStyle);
+        }
+        this.initEvent(data);
+    }
+    drawBalancedCurve(dPath, points) {
+        dPath.M = { x: points.start.x, y: points.start.y };
+        dPath.Q = [{ x: points.start.x + (points.end.x - points.start.x) / 4, y: points.start.y + (points.end.y - points.start.y) / 2 }, { x: points.start.x + (points.end.x - points.start.x) / 2, y: points.start.y + (points.end.y - points.start.y) / 2 }];
+        dPath.Q2 = [{ x: points.end.x - (points.end.x - points.start.x) / 4, y: points.start.y + (points.end.y - points.start.y) / 2 }, { x: points.end.x, y: points.end.y }];
+    }
+    drawBendBothEndsCurve(dPath, points) {
+        const pointXCurve = (points.start.x + points.end.x) * 0.5;
+        const pointControl1 = { x: pointXCurve, y: points.start.y };
+        const pointControl2 = { x: pointXCurve, y: points.end.y };
+        dPath.M = { x: points.start.x, y: points.start.y };
+        dPath.C = [{ x: pointControl1.x, y: pointControl1.y }, { x: pointControl2.x, y: pointControl2.y }, { x: points.end.x, y: points.end.y }];
+    }
+    buildDAttributeByPointEndModeHorizontal(dPath, points, distancePoint, curve, mode) {
+        if (!mode.includes('horizontal')) {
+            return;
+        }
+        const multiplierX = points.start.x < points.end.x ? -1 : 1;
+        const multiplierY = points.start.y < points.end.y ? 1 : -1;
+        const reverseMultiplier = -1;
+        dPath.M = { x: points.start.x, y: points.start.y };
+        dPath.L = { x: points.end.x + ((distancePoint * 2 + curve) * multiplierX), y: points.start.y };
+        if (mode.includes('horizontal-single')) {
+            dPath.L.x = points.end.x + (curve * multiplierX);
+        }
+        dPath.Q = [{ x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: points.start.y }, { x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: points.start.y + (curve * multiplierY) }];
+        dPath.L2 = { x: dPath.Q[1].x, y: points.end.y + (curve * multiplierY * reverseMultiplier) };
+        if (mode.includes('horizontal-single')) {
+            dPath.L2 = points.end;
+        }
+        if (mode === 'horizontal') {
+            dPath.Q2 = [{ x: dPath.L2.x, y: points.end.y }, { x: dPath.L2.x + (distancePoint * multiplierX * reverseMultiplier), y: points.end.y }];
+            dPath.L3 = { x: points.end.x, y: points.end.y };
+        }
+    }
+    buildDAttributeByPointEndModeVertical(dPath, points, distancePoint, curve, mode) {
+        if (!mode.includes('vertical')) {
+            return;
+        }
+        const multiplierX = points.start.x < points.end.x ? -1 : 1;
+        const multiplierY = points.start.y < points.end.y ? 1 : -1;
+        const reverseMultiplier = -1;
+        dPath.M = points.start;
+        dPath.L = { x: points.start.x, y: points.start.y + (distancePoint * multiplierY) };
+        if (mode.includes('vertical-single')) {
+            dPath.L.y = points.end.y + (distancePoint * multiplierY * reverseMultiplier);
+        }
+        dPath.Q = [{ x: dPath.L.x, y: dPath.L.y + (curve * multiplierY) }, { x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: dPath.L.y + (curve * multiplierY) }];
+        dPath.L2 = { x: points.end.x + ((curve * 2) * multiplierX), y: dPath.Q[1].y };
+        if (mode.includes('vertical-single')) {
+            dPath.L2 = points.end;
+        }
+        if (mode === 'vertical') {
+            dPath.Q2 = [{ x: points.end.x, y: dPath.L2.y }, { x: points.end.x, y: dPath.L2.y + (curve * multiplierY) }];
+            dPath.L3 = { x: points.end.x, y: points.end.y };
+        }
+    }
+    builDAttributeToString(dAttribute) {
+        let dString = '';
+        Object.keys(dAttribute).forEach(key => {
+            const data = get(dAttribute, key);
+            if (Array.isArray(data)) {
+                const [point1, point2, point3] = data;
+                dString = `${dString}${key.replace(/\d/g, '')}${point1.x},${point1.y} ${point2.x},${point2.y}${point3 ? ' ' + point3.x + ',' + point3.y : ''}
+        `;
+                return;
+            }
+            dString = `${dString}${key.replace(/\d/g, '')}${data.x},${data.y}
+      `;
+        });
+        return dString;
+    }
+    updateStyleArrow(points, mode, data) {
+        if (!points.arrowElement || data.ignoreDrawArrow) {
+            return;
+        }
+        const styleConfig = {
+            fill: data.arrowStyle?.fill ?? '#9CA2AD',
+            stroke: data.arrowStyle?.stroke ?? 'none',
+            strokeWidth: data.arrowStyle?.strokeWidth ?? '0',
+            width: data.arrowStyle?.width ?? 6,
+            height: data.arrowStyle?.height ?? 8
+        };
+        const pointEnd = cloneDeep(points.end);
+        const arrowElement = points.arrowElement;
+        const direction = data.arrowDirection || this.getDirection(points, mode);
+        switch (direction) {
+            case 'right':
+                if (mode.includes('horizontal') || mode.includes('vertical')) {
+                    pointEnd.x -= styleConfig.height;
+                }
+                arrowElement?.setAttribute('points', `${pointEnd.x},${pointEnd.y - styleConfig.width}  ${pointEnd.x + styleConfig.height},${pointEnd.y} ${pointEnd.x},${pointEnd.y + styleConfig.width} `);
+                break;
+            case 'left':
+                if (mode.includes('horizontal') || mode.includes('vertical')) {
+                    pointEnd.x += styleConfig.height;
+                }
+                arrowElement?.setAttribute('points', `${pointEnd.x},${pointEnd.y - styleConfig.width}  ${pointEnd.x - styleConfig.height},${pointEnd.y} ${pointEnd.x},${pointEnd.y + styleConfig.width} `);
+                break;
+            case 'top':
+                if (mode.includes('horizontal') || mode.includes('vertical')) {
+                    pointEnd.y += styleConfig.height;
+                }
+                arrowElement?.setAttribute('points', `${pointEnd.x - styleConfig.width},${pointEnd.y}  ${pointEnd.x},${pointEnd.y - styleConfig.height} ${pointEnd.x + styleConfig.width},${pointEnd.y} `);
+                break;
+            case 'bottom':
+                if (mode.includes('horizontal') || mode.includes('vertical')) {
+                    pointEnd.y -= styleConfig.height;
+                }
+                arrowElement?.setAttribute('points', `${pointEnd.x - styleConfig.width},${pointEnd.y}  ${pointEnd.x},${pointEnd.y + styleConfig.height} ${pointEnd.x + styleConfig.width},${pointEnd.y} `);
+                break;
+        }
+        arrowElement?.setAttribute('fill', styleConfig.fill);
+        arrowElement?.setAttribute('stroke', styleConfig.stroke);
+        arrowElement?.setAttribute('stroke-width', styleConfig.strokeWidth);
+    }
+    updateAttributeCircle(circleElement, name, point, circleStyle) {
+        circleElement.setAttribute('name', name);
+        circleElement.setAttribute('cx', `${point.x}`);
+        circleElement.setAttribute('cy', `${point.y}`);
+        circleElement.setAttribute('r', `${circleStyle?.r ?? 2}`);
+        circleElement.setAttribute('fill', `${circleStyle?.fill ?? 'green'}`);
+        circleElement.setAttribute('stroke', `${circleStyle?.stroke ?? '#9CA2AD'}`);
+        circleElement.setAttribute('stroke-width', `${circleStyle?.strokeWidth ?? '1px'}`);
+        return circleElement;
+    }
+    getDirection(points, mode) {
+        let pointStart = { ...points.start };
+        if (points.separatedPoints) {
+            const lineToEnd = points.separatedPoints.find(item => item.end.x === points.end.x && item.end.y === points.end.y);
+            if (lineToEnd) {
+                pointStart = lineToEnd.start;
+            }
+        }
+        const modeHorizontal = pointStart.x < points.end.x ? 'right' : 'left';
+        const modeVertical = pointStart.y < points.end.y ? 'bottom' : 'top';
+        if (Math.abs(points.end.x - pointStart.x) > Math.abs(points.end.y - pointStart.y)) {
+            return modeHorizontal;
+        }
+        return modeVertical;
+    }
+    initEvent(data) {
+        const points = data.points;
+        let preEvent = undefined;
+        if ((!points.arrowElement && !points.circleEndElement) || !points.onDestroyEvent || points.initialized) {
+            return;
+        }
+        points.initialized = true;
+        const stopEventMouse = (mouseEvent) => {
+            mouseEvent.preventDefault();
+            mouseEvent.stopPropagation();
+        };
+        const documentMouseUp = fromEvent(document, 'mouseup')
+            .pipe(tap((eventMouseUp) => {
+            stopEventMouse(eventMouseUp);
+            if (preEvent) {
+                preEvent = undefined;
+                this.onDrawLineEnd.next({ dataLine: data, event: eventMouseUp });
+            }
+        }), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy));
+        const documentMouseMove = fromEvent(document, 'mousemove').pipe(tap((eventMousemove) => stopEventMouse(eventMousemove)), takeUntil((documentMouseUp)), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy));
+        const handlerDrag = (dragMouseEvent) => {
+            if (!preEvent) {
+                preEvent = dragMouseEvent;
+            }
+            const pointEnd = cloneDeep(points.end);
+            const movementX = dragMouseEvent.clientX - preEvent.clientX;
+            const movementY = dragMouseEvent.clientY - preEvent.clientY;
+            preEvent = dragMouseEvent;
+            pointEnd.x += movementX;
+            pointEnd.y += movementY;
+            if (data.points?.obstacleRect?.length && data.points?.obstacleRect.some(obstacleRect => this.checkPointIncludeRect(pointEnd, obstacleRect))) {
+                return;
+            }
+            points.end.x = pointEnd.x;
+            points.end.y = pointEnd.y;
+            this.drawLine(data);
+            this.updateViewBox();
+        };
+        if (points.arrowElement) {
+            const elementMouseDownArrow = fromEvent(points.arrowElement, 'mousedown').pipe(tap(eventMousedown => {
+                stopEventMouse(eventMousedown);
+            }), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy));
+            const dragArrow = elementMouseDownArrow.pipe(mergeMap((mouseEvent) => documentMouseMove.pipe(startWith((mouseEvent)))));
+            dragArrow.pipe(tap(handlerDrag), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy)).subscribe();
+        }
+        if (points.circleEndElement) {
+            const elementMouseDownCircle = fromEvent(points.circleEndElement, 'mousedown').pipe(tap(eventMousedown => {
+                stopEventMouse(eventMousedown);
+            }), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy));
+            const dragCircle = elementMouseDownCircle.pipe(mergeMap((mouseEvent) => documentMouseMove.pipe(startWith((mouseEvent)))));
+            dragCircle.pipe(tap(handlerDrag), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy)).subscribe();
+        }
+    }
+    checkPointIncludeRect(point, obstacleRect) {
+        const gapDefault = 8;
+        obstacleRect = {
+            x: obstacleRect.x - (obstacleRect.gapXObstacleRect || gapDefault),
+            y: obstacleRect.y - (obstacleRect.gapYObstacleRect || gapDefault),
+            width: obstacleRect.width + (obstacleRect.gapXObstacleRect || gapDefault) * 2,
+            height: obstacleRect.height + (obstacleRect.gapYObstacleRect || gapDefault) * 2
+        };
+        if ((obstacleRect.x <= point.x && point.x <= obstacleRect.x + obstacleRect.width) && (obstacleRect.y <= point.y && point.y <= obstacleRect.y + obstacleRect.height)) {
+            return true;
+        }
+        return false;
+    }
+    createPathAndArrowElement(name) {
+        const pathElement = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        const arrowElement = document.createElementNS("http://www.w3.org/2000/svg", "polyline");
+        const circleStartElement = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+        const circleEndElement = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+        pathElement.setAttribute('name', name);
+        arrowElement.setAttribute('name', name);
+        this.svgElement.append(pathElement);
+        this.svgElement.append(arrowElement);
+        return { pathElement, arrowElement, circleStartElement, circleEndElement };
+    }
+    addCircle(name, point) {
+        if (!this.drawRectDebug) {
+            return;
+        }
+        const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+        circle.setAttribute('name', name);
+        circle.setAttribute('cx', `${point.x}`);
+        circle.setAttribute('cy', `${point.y}`);
+        circle.setAttribute('r', '2');
+        circle.setAttribute('style', 'fill: none; stroke: blue; stroke-width: 1px;');
+        this.svgElement.appendChild(circle);
+    }
+    clearCircle() {
+        if (!this.drawRectDebug) {
+            return;
+        }
+        Array.from(this.svgElement.getElementsByTagName('circle'))?.forEach(item => item.remove());
+    }
+    addRect(name, rect) {
+        if (!this.drawRectDebug) {
+            return;
+        }
+        const rectElement = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        const textElement = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        rectElement.setAttribute('name', name);
+        rectElement.setAttribute('x', `${rect.x}`);
+        rectElement.setAttribute('y', `${rect.y}`);
+        rectElement.setAttribute('width', `${rect.width}`);
+        rectElement.setAttribute('height', `${rect.height}`);
+        rectElement.setAttribute('style', 'fill: blue; stroke: blue;');
+        this.svgElement.appendChild(rectElement);
+        textElement.setAttribute('x', `${rect.x}`);
+        textElement.setAttribute('y', `${rect.y}`);
+        textElement.textContent = rect.id ?? '';
+        this.svgElement.appendChild(textElement);
+    }
+    clearRect() {
+        if (!this.drawRectDebug) {
+            return;
+        }
+        Array.from(this.svgElement.getElementsByTagName('rect'))?.forEach(item => item.remove());
+        Array.from(this.svgElement.getElementsByTagName('text'))?.forEach(item => item.remove());
+    }
+    ngOnDestroy() {
+        this.onDestroy.next();
+        this.onDestroy.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiComponentsDrawLineDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LibsUiComponentsDrawLineDirective, isStandalone: true, selector: "[LibsUiComponentsDrawLineDirective]", inputs: { viewBoxConfig: "viewBoxConfig", svgElement: "svgElement", drawRectDebug: "drawRectDebug" }, outputs: { outDrawLineFunctionControl: "outDrawLineFunctionControl", outConnected: "outConnected" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiComponentsDrawLineDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: "[LibsUiComponentsDrawLineDirective]",
+                    standalone: true,
+                }]
+        }], propDecorators: { viewBoxConfig: [{
+                type: Input
+            }], svgElement: [{
+                type: Input
+            }], drawRectDebug: [{
+                type: Input
+            }], outDrawLineFunctionControl: [{
+                type: Output
+            }], outConnected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draw-line.directive.js","sourceRoot":"","sources":["../../../../../libs-ui/components/draw-line/src/draw-line.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectorRef, Directive, ElementRef, EventEmitter, Input, NgZone, OnDestroy, Output, inject } from \"@angular/core\";\nimport { checkMouseOverInContainer, cloneDeep, get } from \"@libs-ui/utils\";\nimport { Observable, Subject, fromEvent, mergeMap, startWith, takeUntil, tap } from \"rxjs\";\nimport { IAttributeDOnPath, ICircleStyle, IDrawLineDataInput, IMoDrawLineFunctionControl, IPoint, IPoints, IReachablePointRange, IRect, IViewBoxConfig, TYPE_DIRECTION, TYPE_MODE } from \"./draw-line.interface\";\nimport { MoCanvasConnectNavigationNewElementUtil } from \"./util/connect-navigation-new-element.util\";\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: \"[LibsUiComponentsDrawLineDirective]\",\n  standalone: true,\n})\nexport class LibsUiComponentsDrawLineDirective implements AfterViewInit, OnDestroy {\n  protected cdr = inject(ChangeDetectorRef);\n  protected zone = inject(NgZone);\n  protected elementRef = inject(ElementRef);\n  protected intervalScrollToElement?: number;\n  private dataDraw: Array<IDrawLineDataInput> = [];\n  private dataReachablePointRange: Array<IReachablePointRange> = [];\n  private onDrawLineEnd: Subject<{\n    dataLine: IDrawLineDataInput,\n    event: MouseEvent\n  }> = new Subject();\n  private onDestroy = new Subject<void>();\n\n  @Input() viewBoxConfig?: IViewBoxConfig;\n  @Input() svgElement!: SVGSVGElement;\n  @Input() drawRectDebug?: boolean;\n\n  @Output() outDrawLineFunctionControl: EventEmitter<IMoDrawLineFunctionControl> = new EventEmitter();\n  @Output() outConnected: EventEmitter<{ dataLine: IDrawLineDataInput, dataReachablePointRange: IReachablePointRange }> = new EventEmitter();\n\n\n  ngAfterViewInit(): void {\n    this.svgElement = this.svgElement || document.createElementNS(\"http://www.w3.org/2000/svg\", \"svg\");\n    this.elementRef.nativeElement.append(this.svgElement);\n    this.outDrawLineFunctionControl.emit({\n      setData: this.setData.bind(this),\n      setReachablePointRange: this.setReachablePointRange.bind(this),\n      removeLine: this.removeLine.bind(this),\n      removeReachablePointRange: this.removeReachablePointRange.bind(this),\n      updateViewBox: this.updateViewBox.bind(this)\n    });\n  }\n\n  private setData(data: Array<IDrawLineDataInput>) {\n    const newData: Array<IDrawLineDataInput> = [];\n\n    data.forEach(item => {\n      if (this.dataDraw.find(dataDraw => dataDraw.id === item.id && item.points.start.x === dataDraw.points.start.x && item.points.start.y === dataDraw.points.start.y && item.points.end.x === dataDraw.points.end.x && item.points.end.y === dataDraw.points.end.y)) {\n        return;\n      }\n      const itemClone = cloneDeep(item);\n\n      itemClone.ref = item;\n      newData.push(itemClone);\n    });\n\n    this.dataDraw.push(...newData);\n    this.startProcessDataRow(newData);\n  }\n\n\n  setReachablePointRange(data: Array<IReachablePointRange>) {\n    const newData: Array<IReachablePointRange> = [];\n\n    data.forEach(item => {\n      if (this.dataReachablePointRange.find(dataDraw => dataDraw.id === item.id || item.x === dataDraw.x && item.y === dataDraw.y)) {\n        return;\n      }\n      const itemClone = cloneDeep(item);\n\n      itemClone.ref = item;\n      newData.push(itemClone);\n    });\n\n    this.dataReachablePointRange.push(...newData);\n    this.startProcessDataReachablePointRange(newData);\n  }\n\n  private removeLine(id: string, points?: Array<IPoints>) {\n    const dataDrawById = this.dataDraw.filter(item => item.id === id);\n\n    if (!dataDrawById?.length) {\n      return;\n    }\n\n    const removeByItem = (item: IDrawLineDataInput) => {\n      this.removeElementOfPoints(item.points);\n      item.points.separatedPoints?.forEach(separatedPoints => this.removeElementOfPoints(separatedPoints));\n\n    };\n\n    if (!points?.length) {\n      dataDrawById.forEach(item => removeByItem(item));\n      this.dataDraw = this.dataDraw.filter(item => item.id !== id);\n      this.updateViewBox();\n\n      return;\n    }\n\n    points.forEach(point => {\n      const dataDrawRemoveByPoint = dataDrawById.find(item => item.points.start.x === point.start.x && item.points.start.y === point.start.y && item.points.end.x === point.end.x && item.points.end.y === point.end.y);\n\n      if (dataDrawRemoveByPoint) {\n        dataDrawRemoveByPoint.isRemove = true;\n        removeByItem(dataDrawRemoveByPoint);\n        this.dataDraw = this.dataDraw.filter(item => item.id !== id && !item.isRemove);\n      }\n    });\n    this.updateViewBox();\n\n  }\n\n  private removeReachablePointRange(ids: Array<string>) {\n    this.clearRect();\n    if (!ids.length) {\n      return;\n    }\n\n    ids.forEach(id => {\n      const itemRemove = this.dataReachablePointRange?.find(item => item.id === id);\n\n      if (!itemRemove) {\n        return;\n      }\n      itemRemove.onDestroyEvent?.next();\n      itemRemove.element?.remove();\n      this.dataReachablePointRange = this.dataReachablePointRange?.filter(item => item.id !== id);\n    });\n  }\n\n  private startProcessDataRow(dataDraw: Array<IDrawLineDataInput>) {\n    this.zone.runOutsideAngular(() => {\n      dataDraw.forEach(item => {\n        const { pathElement, arrowElement, circleStartElement, circleEndElement } = this.createPathAndArrowElement(item.id);\n\n        item.points.obstacleRect?.forEach(data => this.addRect('rect', data));\n        item.points.pathElement = pathElement;\n        item.points.arrowElement = arrowElement;\n        if (item.startCircle) {\n          item.points.circleStartElement = circleStartElement;\n          this.svgElement.append(circleStartElement);\n        }\n        if (item.endCircle) {\n          item.points.circleEndElement = circleEndElement;\n          this.svgElement.append(circleEndElement);\n        }\n        item.points.onDestroyEvent = new Subject();\n        this.drawLine(item);\n      });\n      this.updateViewBox();\n    });\n  }\n  private startProcessDataReachablePointRange(data: Array<IReachablePointRange>) {\n    this.zone.runOutsideAngular(() => {\n      data.forEach(item => {\n        item.onDestroyEvent = new Subject();\n        item.element = this.createPathAndArrowElement(item.id).circleEndElement;\n        this.svgElement.append(item.element);\n        this.updateAttributeCircle(item.element, item.id, item, item.style);\n        this.onDrawLineEnd.pipe(takeUntil(item.onDestroyEvent), takeUntil(this.onDestroy)).subscribe(eventData => {\n          const { dataLine, event } = eventData;\n\n          if (!checkMouseOverInContainer(event, item.element as unknown as HTMLElement) || !dataLine.ref || !item.ref) {\n            return;\n          }\n\n          item.idConnected = eventData.dataLine.id;\n          eventData.dataLine.idConnected = item.id;\n          this.outConnected.emit({\n            dataLine: dataLine.ref,\n            dataReachablePointRange: item.ref\n          });\n        });\n      });\n      this.updateViewBox();\n    });\n  }\n\n  private removeElementOfPoints(points: IPoints) {\n    this.zone.runOutsideAngular(() => {\n      points.onDestroyEvent?.next();\n      points.onDestroyEvent?.complete();\n      points?.pathElement?.remove();\n      points?.arrowElement?.remove();\n      points?.circleStartElement?.remove();\n      points.circleEndElement?.remove();\n    });\n  }\n\n  private drawLine(data: IDrawLineDataInput) {\n    this.zone.runOutsideAngular(() => {\n      const { points, mode } = data;\n      let { curve } = data?.lineStyle || {};\n\n      if (mode !== 'quart-in') {\n        curve = curve ?? 10;\n      }\n      const preLengthSeparatedPoints = points.separatedPoints?.length;\n\n      points.separatedPoints?.forEach(separatedPoints => this.removeElementOfPoints(separatedPoints));\n      points.separatedPoints = [];\n      MoCanvasConnectNavigationNewElementUtil.START_MODE = 'right-left';\n      if (data.startEndMode) {\n        MoCanvasConnectNavigationNewElementUtil.START_MODE = data.startEndMode;\n      }\n      this.calculatorSeparatedPoints(data.id, points, curve || 10, points.separatedPoints, points.obstacleRect || []);\n      if (!preLengthSeparatedPoints && points.separatedPoints.length) {\n        this.removeElementOfPoints(points);\n        const { pathElement, arrowElement } = this.createPathAndArrowElement(data.id);\n\n        points.pathElement = pathElement;\n        points.arrowElement = arrowElement;\n        points.initialized = false;\n      }\n      if (!points.separatedPoints?.length) {\n        this.buildPathAndDraw(data, points, mode);\n\n        return;\n      }\n\n      points.separatedPoints.forEach(separatedPoints => {\n        this.buildPathAndDraw(data, separatedPoints, separatedPoints.mode || mode);\n      });\n    });\n  }\n\n  private updateViewBox(viewBoxConfig?: IViewBoxConfig) {\n    if (viewBoxConfig) {\n      this.viewBoxConfig = viewBoxConfig;\n    }\n    const xPoints: Set<number> = new Set([0]);\n    const yPoints: Set<number> = new Set([0]);\n\n    const addPoints = (points: IPoints) => {\n      xPoints.add(points.start.x);\n      xPoints.add(points.end.x);\n      yPoints.add(points.start.y);\n      yPoints.add(points.end.y);\n    };\n\n    this.dataDraw?.forEach(item => {\n      const points = item.points;\n\n      addPoints(points);\n      points.separatedPoints?.forEach(separatedPoints => addPoints(separatedPoints));\n      points.obstacleRect?.forEach(obstacleRect => {\n        addPoints({\n          start: { x: obstacleRect.x - (obstacleRect.gapXObstacleRect || 8), y: obstacleRect.y - (obstacleRect.gapYObstacleRect || 8) },\n          end: { x: obstacleRect.x + obstacleRect.width + (obstacleRect.gapXObstacleRect || 8) * 2, y: obstacleRect.y + obstacleRect.height + (obstacleRect.gapYObstacleRect || 8) * 2 }\n        });\n      });\n    });\n\n    const xMax = this.viewBoxConfig?.width ?? (xPoints.size ? Math.max(...xPoints) : 0) + 14;\n    const yMax = this.viewBoxConfig?.height ?? (yPoints.size ? Math.max(...yPoints) : 0) + 14;\n\n    if (!this.viewBoxConfig?.ignoreViewBox) {\n      const rectSvgElement = this.svgElement.getBoundingClientRect();\n\n      this.svgElement?.setAttribute('viewBox', `${this.viewBoxConfig?.minX ?? rectSvgElement.x} ${this.viewBoxConfig?.minY ?? rectSvgElement.y} ${xMax} ${yMax}`);\n    }\n    this.svgElement?.setAttribute('width', `${xMax ?? 0}`);\n    this.svgElement?.setAttribute('height', `${yMax ?? 0}`);\n  }\n\n  private isPointInsideSquare(point: IPoint, square: IRect): boolean {\n    const { x, y } = point;\n    const { x: squareX, y: squareY, width, height } = square;\n\n    return x >= squareX && x <= squareX + width && y >= squareY && y <= squareY + height;\n  }\n\n  private calculatorSeparatedPoints(name: string, points: IPoints, curve: number, separatedPoints: Array<IPoints>, obstacleRects: Array<IRect>) {\n    if (!obstacleRects.length) {\n      return;\n    }\n\n    const elementStart = obstacleRects.find(item => this.isPointInsideSquare(points.start, item));\n    const elementEnd = obstacleRects.find(item => this.isPointInsideSquare(points.end, item));\n\n    if (this.viewBoxConfig?.marginBetweenElement) {\n      MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT = this.viewBoxConfig?.marginBetweenElement ?? 32;\n    }\n    MoCanvasConnectNavigationNewElementUtil.setXYConnectElements(elementStart ?? { ...points.start, width: 1, height: 1 }, elementEnd ?? { ...points.end, width: 1, height: 1 }, obstacleRects, separatedPoints, curve);\n    separatedPoints?.forEach(item => {\n      item.pathElement = this.createPathAndArrowElement(name).pathElement;\n    });\n  }\n\n  private buildPathAndDraw(data: IDrawLineDataInput, points: IPoints, mode?: TYPE_MODE) {\n    let dPath = {} as IAttributeDOnPath;\n    const styleConfig = {\n      stroke: data.lineStyle?.stroke ?? '#9CA2AD',\n      strokeDasharray: data.lineStyle?.strokeDasharray,\n      strokeWidth: data.lineStyle?.strokeWidth ?? '1px',\n      fill: data.lineStyle?.fill ?? 'none',\n      curve: data.lineStyle?.curve ?? 10,\n      distancePoint: data.lineStyle?.distancePoint ?? 10\n    };\n\n    points.pathElement?.setAttribute('stroke', styleConfig.stroke);\n    points.pathElement?.setAttribute('fill', styleConfig.fill);\n    points.pathElement?.setAttribute('stroke-width', styleConfig.strokeWidth);\n    if (styleConfig.strokeDasharray) {\n      points.pathElement?.setAttribute('stroke-dasharray', styleConfig.strokeDasharray);\n    }\n    let { curve, distancePoint } = styleConfig;\n\n    mode = mode || \"quart-in\";\n    if (mode !== 'quart-in') {\n      curve = curve ?? 10;\n      distancePoint = distancePoint ?? 10;\n    }\n    if (mode === 'quart-in' || points.start.x === points.end.x || points.start.y === points.end.y) {\n      this.drawBalancedCurve(dPath, points);\n\n      if (mode === 'quart-in') {\n        dPath = {} as IAttributeDOnPath;\n        this.drawBendBothEndsCurve(dPath, points);\n      }\n      points.pathElement?.setAttribute('d', this.builDAttributeToString(dPath));\n      this.drawRectAndInitEvent(data, mode);\n\n      return;\n    }\n    const result = this.calculatorDistancePointAndCurve(points, distancePoint, curve, mode);\n\n    distancePoint = result.distancePoint;\n    curve = result.curve;\n\n    this.buildDAttributeByPointEndModeHorizontal(dPath, points, distancePoint || 0, curve || 0, mode);\n    this.buildDAttributeByPointEndModeVertical(dPath, points, distancePoint || 0, curve || 0, mode);\n    points.pathElement?.setAttribute('d', this.builDAttributeToString(dPath));\n    this.drawRectAndInitEvent(data, mode);\n  }\n\n  private calculatorDistancePointAndCurve(points: IPoints, distancePoint: number, curve: number, mode: TYPE_MODE) {\n    if ((!mode.includes('vertical') && !mode.includes('horizontal'))) {\n      return { curve, distancePoint };\n    }\n    const gapX = Math.abs(points.start.x - points.end.x);\n    const gapY = Math.abs(points.start.y - points.end.y);\n    const multiplierCurve = mode.includes('horizontal') ? 1 : 2;\n    const multiplierDistance = mode.includes('horizontal') ? 2 : 1;\n\n    if (!mode.includes('single-curve')) {\n      if (gapX < distancePoint * multiplierDistance + curve * multiplierCurve) {\n        distancePoint = curve = gapX / 3;\n      }\n      if (gapY < distancePoint * multiplierDistance + curve * multiplierCurve) {\n        distancePoint = curve = gapY / 3;\n      }\n\n      return { curve, distancePoint };\n    }\n    const minGap = Math.min(gapX, gapY);\n\n    if (minGap < distancePoint) {\n      distancePoint = minGap;\n    }\n    if (minGap < curve) {\n      curve = minGap;\n    }\n\n    return { curve, distancePoint };\n  }\n\n  private drawRectAndInitEvent(data: IDrawLineDataInput, mode: TYPE_MODE) {\n    const points = data.points;\n\n    this.updateStyleArrow(points, mode, data);\n    if (data.startCircle && points.circleStartElement) {\n      this.updateAttributeCircle(points.circleStartElement, data.id, points.start, data.startCircleStyle);\n    }\n    if (data.endCircle && points.circleEndElement) {\n      this.updateAttributeCircle(points.circleEndElement, data.id, points.end, data.endCircleStyle);\n    }\n    this.initEvent(data);\n  }\n\n  private drawBalancedCurve(dPath: IAttributeDOnPath, points: IPoints) {\n    dPath.M = { x: points.start.x, y: points.start.y };\n    dPath.Q = [{ x: points.start.x + (points.end.x - points.start.x) / 4, y: points.start.y + (points.end.y - points.start.y) / 2 }, { x: points.start.x + (points.end.x - points.start.x) / 2, y: points.start.y + (points.end.y - points.start.y) / 2 }];\n    dPath.Q2 = [{ x: points.end.x - (points.end.x - points.start.x) / 4, y: points.start.y + (points.end.y - points.start.y) / 2 }, { x: points.end.x, y: points.end.y }];\n  }\n\n  private drawBendBothEndsCurve(dPath: IAttributeDOnPath, points: IPoints) {\n    const pointXCurve = (points.start.x + points.end.x) * 0.5;\n    const pointControl1 = { x: pointXCurve, y: points.start.y };\n    const pointControl2 = { x: pointXCurve, y: points.end.y };\n\n    dPath.M = { x: points.start.x, y: points.start.y };\n    dPath.C = [{ x: pointControl1.x, y: pointControl1.y }, { x: pointControl2.x, y: pointControl2.y }, { x: points.end.x, y: points.end.y }];\n  }\n\n  private buildDAttributeByPointEndModeHorizontal(dPath: IAttributeDOnPath, points: IPoints, distancePoint: number, curve: number, mode: TYPE_MODE) {\n    if (!mode.includes('horizontal')) {\n      return;\n    }\n    const multiplierX = points.start.x < points.end.x ? -1 : 1;\n    const multiplierY = points.start.y < points.end.y ? 1 : -1;\n    const reverseMultiplier = -1;\n\n    dPath.M = { x: points.start.x, y: points.start.y };\n    dPath.L = { x: points.end.x + ((distancePoint * 2 + curve) * multiplierX), y: points.start.y };\n    if (mode.includes('horizontal-single')) {\n      dPath.L.x = points.end.x + (curve * multiplierX);\n    }\n    dPath.Q = [{ x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: points.start.y }, { x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: points.start.y + (curve * multiplierY) }];\n    dPath.L2 = { x: dPath.Q[1].x, y: points.end.y + (curve * multiplierY * reverseMultiplier) };\n    if (mode.includes('horizontal-single')) {\n      dPath.L2 = points.end;\n    }\n    if (mode === 'horizontal') {\n      dPath.Q2 = [{ x: dPath.L2.x, y: points.end.y }, { x: dPath.L2.x + (distancePoint * multiplierX * reverseMultiplier), y: points.end.y }];\n      dPath.L3 = { x: points.end.x, y: points.end.y };\n    }\n  }\n\n  private buildDAttributeByPointEndModeVertical(dPath: IAttributeDOnPath, points: IPoints, distancePoint: number, curve: number, mode: TYPE_MODE) {\n    if (!mode.includes('vertical')) {\n      return;\n    }\n    const multiplierX = points.start.x < points.end.x ? -1 : 1;\n    const multiplierY = points.start.y < points.end.y ? 1 : -1;\n    const reverseMultiplier = -1;\n\n    dPath.M = points.start;\n    dPath.L = { x: points.start.x, y: points.start.y + (distancePoint * multiplierY) };\n    if (mode.includes('vertical-single')) {\n      dPath.L.y = points.end.y + (distancePoint * multiplierY * reverseMultiplier);\n    }\n    dPath.Q = [{ x: dPath.L.x, y: dPath.L.y + (curve * multiplierY) }, { x: dPath.L.x + (curve * multiplierX * reverseMultiplier), y: dPath.L.y + (curve * multiplierY) }];\n    dPath.L2 = { x: points.end.x + ((curve * 2) * multiplierX), y: dPath.Q[1].y };\n    if (mode.includes('vertical-single')) {\n      dPath.L2 = points.end;\n    }\n    if (mode === 'vertical') {\n      dPath.Q2 = [{ x: points.end.x, y: dPath.L2.y }, { x: points.end.x, y: dPath.L2.y + (curve * multiplierY) }];\n      dPath.L3 = { x: points.end.x, y: points.end.y };\n    }\n  }\n\n  private builDAttributeToString(dAttribute: IAttributeDOnPath): string {\n    let dString = '';\n\n    Object.keys(dAttribute).forEach(key => {\n      const data = get(dAttribute, key);\n\n      if (Array.isArray(data)) {\n        const [point1, point2, point3] = data;\n\n        dString = `${dString}${key.replace(/\\d/g, '')}${point1.x},${point1.y} ${point2.x},${point2.y}${point3 ? ' ' + point3.x + ',' + point3.y : ''}\n        `;\n\n        return;\n      }\n      dString = `${dString}${key.replace(/\\d/g, '')}${data.x},${data.y}\n      `;\n    });\n\n    return dString;\n  }\n\n  private updateStyleArrow(points: IPoints, mode: TYPE_MODE, data: IDrawLineDataInput) {\n    if (!points.arrowElement || data.ignoreDrawArrow) {\n      return;\n    }\n    const styleConfig = {\n      fill: data.arrowStyle?.fill ?? '#9CA2AD',\n      stroke: data.arrowStyle?.stroke ?? 'none',\n      strokeWidth: data.arrowStyle?.strokeWidth ?? '0',\n      width: data.arrowStyle?.width ?? 6,\n      height: data.arrowStyle?.height ?? 8\n    };\n    const pointEnd = cloneDeep(points.end);\n    const arrowElement = points.arrowElement;\n    const direction = data.arrowDirection || this.getDirection(points, mode);\n\n    switch (direction) {\n      case 'right':\n        if (mode.includes('horizontal') || mode.includes('vertical')) {\n          pointEnd.x -= styleConfig.height;\n        }\n        arrowElement?.setAttribute('points', `${pointEnd.x},${pointEnd.y - styleConfig.width}  ${pointEnd.x + styleConfig.height},${pointEnd.y} ${pointEnd.x},${pointEnd.y + styleConfig.width} `);\n        break;\n\n      case 'left':\n        if (mode.includes('horizontal') || mode.includes('vertical')) {\n          pointEnd.x += styleConfig.height;\n        }\n        arrowElement?.setAttribute('points', `${pointEnd.x},${pointEnd.y - styleConfig.width}  ${pointEnd.x - styleConfig.height},${pointEnd.y} ${pointEnd.x},${pointEnd.y + styleConfig.width} `);\n        break;\n\n      case 'top':\n        if (mode.includes('horizontal') || mode.includes('vertical')) {\n          pointEnd.y += styleConfig.height;\n        }\n        arrowElement?.setAttribute('points', `${pointEnd.x - styleConfig.width},${pointEnd.y}  ${pointEnd.x},${pointEnd.y - styleConfig.height} ${pointEnd.x + styleConfig.width},${pointEnd.y} `);\n        break;\n\n      case 'bottom':\n        if (mode.includes('horizontal') || mode.includes('vertical')) {\n          pointEnd.y -= styleConfig.height;\n        }\n        arrowElement?.setAttribute('points', `${pointEnd.x - styleConfig.width},${pointEnd.y}  ${pointEnd.x},${pointEnd.y + styleConfig.height} ${pointEnd.x + styleConfig.width},${pointEnd.y} `);\n        break;\n    }\n\n    arrowElement?.setAttribute('fill', styleConfig.fill);\n    arrowElement?.setAttribute('stroke', styleConfig.stroke);\n    arrowElement?.setAttribute('stroke-width', styleConfig.strokeWidth);\n  }\n\n  private updateAttributeCircle(circleElement: SVGCircleElement, name: string, point: { x: number, y: number }, circleStyle?: ICircleStyle) {\n    circleElement.setAttribute('name', name);\n    circleElement.setAttribute('cx', `${point.x}`);\n    circleElement.setAttribute('cy', `${point.y}`);\n    circleElement.setAttribute('r', `${circleStyle?.r ?? 2}`);\n    circleElement.setAttribute('fill', `${circleStyle?.fill ?? 'green'}`);\n    circleElement.setAttribute('stroke', `${circleStyle?.stroke ?? '#9CA2AD'}`);\n    circleElement.setAttribute('stroke-width', `${circleStyle?.strokeWidth ?? '1px'}`);\n\n    return circleElement;\n  }\n\n  private getDirection(points: IPoints, mode: TYPE_MODE): TYPE_DIRECTION {\n    let pointStart = { ...points.start };\n\n    if (points.separatedPoints) {\n      const lineToEnd = points.separatedPoints.find(item => item.end.x === points.end.x && item.end.y === points.end.y)\n      if (lineToEnd) {\n        pointStart = lineToEnd.start;\n      }\n    }\n    const modeHorizontal = pointStart.x < points.end.x ? 'right' : 'left';\n    const modeVertical = pointStart.y < points.end.y ? 'bottom' : 'top';\n\n    if (Math.abs(points.end.x - pointStart.x) > Math.abs(points.end.y - pointStart.y)) {\n      return modeHorizontal;\n    }\n\n    return modeVertical;\n  }\n\n  private initEvent(data: IDrawLineDataInput) {\n    const points: IPoints = data.points;\n    let preEvent: MouseEvent | undefined = undefined;\n\n    if ((!points.arrowElement && !points.circleEndElement) || !points.onDestroyEvent || points.initialized) {\n      return;\n    }\n\n    points.initialized = true;\n    const stopEventMouse = (mouseEvent: MouseEvent) => {\n      mouseEvent.preventDefault();\n      mouseEvent.stopPropagation();\n    };\n    const documentMouseUp = fromEvent<MouseEvent>(document, 'mouseup')\n      .pipe(\n        tap((eventMouseUp) => {\n          stopEventMouse(eventMouseUp);\n          if (preEvent) {\n            preEvent = undefined;\n            this.onDrawLineEnd.next({ dataLine: data, event: eventMouseUp });\n          }\n        }),\n        takeUntil(points.onDestroyEvent),\n        takeUntil(this.onDestroy)\n      );\n    const documentMouseMove = fromEvent<MouseEvent>(document, 'mousemove').pipe(tap((eventMousemove) => stopEventMouse(eventMousemove)), takeUntil((documentMouseUp)), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy));\n    const handlerDrag = (dragMouseEvent: MouseEvent) => {\n      if (!preEvent) {\n        preEvent = dragMouseEvent;\n      }\n      const pointEnd = cloneDeep(points.end);\n\n      const movementX = dragMouseEvent.clientX - preEvent.clientX;\n      const movementY = dragMouseEvent.clientY - preEvent.clientY;\n\n      preEvent = dragMouseEvent;\n      pointEnd.x += movementX;\n      pointEnd.y += movementY;\n      if (data.points?.obstacleRect?.length && data.points?.obstacleRect.some(obstacleRect => this.checkPointIncludeRect(pointEnd, obstacleRect))) {\n\n        return;\n      }\n      points.end.x = pointEnd.x;\n      points.end.y = pointEnd.y;\n      this.drawLine(data);\n      this.updateViewBox();\n    };\n\n    if (points.arrowElement) {\n      const elementMouseDownArrow = fromEvent<MouseEvent>(points.arrowElement, 'mousedown').pipe(\n        tap(eventMousedown => {\n          stopEventMouse(eventMousedown);\n\n        }),\n        takeUntil(points.onDestroyEvent),\n        takeUntil(this.onDestroy)\n      );\n      const dragArrow = elementMouseDownArrow.pipe(mergeMap((mouseEvent: MouseEvent) => documentMouseMove.pipe(startWith((mouseEvent))))) as Observable<MouseEvent>;\n\n      dragArrow.pipe(tap(handlerDrag), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy)).subscribe();\n    }\n\n    if (points.circleEndElement) {\n      const elementMouseDownCircle = fromEvent<MouseEvent>(points.circleEndElement, 'mousedown').pipe(\n        tap(eventMousedown => {\n          stopEventMouse(eventMousedown);\n\n        }),\n        takeUntil(points.onDestroyEvent),\n        takeUntil(this.onDestroy)\n      );\n      const dragCircle = elementMouseDownCircle.pipe(mergeMap((mouseEvent: MouseEvent) => documentMouseMove.pipe(startWith((mouseEvent))))) as Observable<MouseEvent>;\n\n      dragCircle.pipe(tap(handlerDrag), takeUntil(points.onDestroyEvent), takeUntil(this.onDestroy)).subscribe();\n    }\n  }\n\n  private checkPointIncludeRect(point: { x: number, y: number }, obstacleRect: IRect): boolean {\n    const gapDefault = 8;\n\n    obstacleRect = {\n      x: obstacleRect.x - (obstacleRect.gapXObstacleRect || gapDefault),\n      y: obstacleRect.y - (obstacleRect.gapYObstacleRect || gapDefault),\n      width: obstacleRect.width + (obstacleRect.gapXObstacleRect || gapDefault) * 2,\n      height: obstacleRect.height + (obstacleRect.gapYObstacleRect || gapDefault) * 2\n    };\n    if ((obstacleRect.x <= point.x && point.x <= obstacleRect.x + obstacleRect.width) && (obstacleRect.y <= point.y && point.y <= obstacleRect.y + obstacleRect.height)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  private createPathAndArrowElement(name: string) {\n    const pathElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n    const arrowElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"polyline\");\n    const circleStartElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"circle\");\n    const circleEndElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"circle\");\n\n    pathElement.setAttribute('name', name);\n    arrowElement.setAttribute('name', name);\n    this.svgElement.append(pathElement);\n    this.svgElement.append(arrowElement);\n\n    return { pathElement, arrowElement, circleStartElement, circleEndElement };\n  }\n\n  private addCircle(name: string, point: { x: number, y: number }) {\n    if (!this.drawRectDebug) {\n      return;\n    }\n    const circle = document.createElementNS(\"http://www.w3.org/2000/svg\", \"circle\");\n\n    circle.setAttribute('name', name);\n    circle.setAttribute('cx', `${point.x}`);\n    circle.setAttribute('cy', `${point.y}`);\n    circle.setAttribute('r', '2');\n    circle.setAttribute('style', 'fill: none; stroke: blue; stroke-width: 1px;');\n    this.svgElement.appendChild(circle);\n  }\n\n  private clearCircle() {\n    if (!this.drawRectDebug) {\n      return;\n    }\n    Array.from(this.svgElement.getElementsByTagName('circle'))?.forEach(item => item.remove());\n  }\n\n  private addRect(name: string, rect: IRect) {\n    if (!this.drawRectDebug) {\n      return;\n    }\n    const rectElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"rect\");\n    const textElement = document.createElementNS(\"http://www.w3.org/2000/svg\", \"text\");\n\n    rectElement.setAttribute('name', name);\n    rectElement.setAttribute('x', `${rect.x}`);\n    rectElement.setAttribute('y', `${rect.y}`);\n    rectElement.setAttribute('width', `${rect.width}`);\n    rectElement.setAttribute('height', `${rect.height}`);\n    rectElement.setAttribute('style', 'fill: blue; stroke: blue;');\n    this.svgElement.appendChild(rectElement);\n\n    textElement.setAttribute('x', `${rect.x}`);\n    textElement.setAttribute('y', `${rect.y}`);\n    textElement.textContent = rect.id ?? '';\n    this.svgElement.appendChild(textElement);\n  }\n\n  private clearRect() {\n    if (!this.drawRectDebug) {\n      return;\n    }\n    Array.from(this.svgElement.getElementsByTagName('rect'))?.forEach(item => item.remove());\n    Array.from(this.svgElement.getElementsByTagName('text'))?.forEach(item => item.remove());\n  }\n\n  ngOnDestroy(): void {\n    this.onDestroy.next();\n    this.onDestroy.complete();\n  }\n}\n"]}