@libs-ui/components-draw-line 0.1.1-1

package/esm2022/draw-line.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/index.mjs

@@ -0,0 +1,3 @@
+export * from './draw-line.directive';
+export * from './draw-line.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzLXVpL2NvbXBvbmVudHMvZHJhdy1saW5lL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYXctbGluZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3LWxpbmUuaW50ZXJmYWNlJztcbiJdfQ==

package/esm2022/libs-ui-components-draw-line.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlicy11aS1jb21wb25lbnRzLWRyYXctbGluZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMtdWkvY29tcG9uZW50cy9kcmF3LWxpbmUvc3JjL2xpYnMtdWktY29tcG9uZW50cy1kcmF3LWxpbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/util/calculator-branch.util.mjs

@@ -0,0 +1,27 @@
+export class MoCanvasCalculatorBranchUtil {
+    /**
+     *
+     * above, left a + b; opposite = true a - b;
+     *
+     * under, right a - b; opposite = true a + b
+     */
+    static mathOperatorsCalculation(direction, a, b, opposite) {
+        switch (direction) {
+            case 'left':
+            case 'above':
+                if (opposite) {
+                    return (a ?? 0) - (b ?? 0);
+                }
+                return (a ?? 0) + (b ?? 0);
+            case 'right':
+            case 'under':
+                if (opposite) {
+                    return (a ?? 0) + (b ?? 0);
+                }
+                return (a ?? 0) - (b ?? 0);
+            default:
+                return (a ?? 0) - (b ?? 0);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/util/calculator-diretion-element.until.mjs

@@ -0,0 +1,350 @@
+import { range } from '@libs-ui/utils';
+import { MoCanvasCalculatorBranchUtil } from './calculator-branch.util';
+import { MoCanvasConnectNavigationNewElementUtil } from './connect-navigation-new-element.util';
+export class MoCanvasCalculatorDirectionElementUtil {
+    static checkUpDownLeftRight(firstPoint, endPoint, direction) {
+        const distance = (firstPoint ?? 0) - (endPoint ?? 0);
+        if (distance === 0) {
+            return 'center';
+        }
+        if (distance > 0) {
+            return direction === 'x' ? 'left' : 'above';
+        }
+        return direction === 'x' ? 'right' : 'under';
+    }
+    static drawLineQ(start, corner, lineCurveX, lineCurveY) {
+        const coordQ = {};
+        switch (corner) {
+            case 'right-under':
+                coordQ.x1 = start.x + lineCurveX;
+                coordQ.y1 = start.y;
+                coordQ.x = coordQ.x1;
+                coordQ.y = coordQ.y1 + lineCurveY;
+                break;
+            case 'under-left':
+                coordQ.x1 = start.x;
+                coordQ.y1 = start.y + lineCurveY;
+                coordQ.x = coordQ.x1 - lineCurveX;
+                coordQ.y = coordQ.y1;
+                break;
+            case 'left-above':
+                coordQ.x1 = start.x - lineCurveX;
+                coordQ.y1 = start.y;
+                coordQ.x = coordQ.x1;
+                coordQ.y = coordQ.y1 - lineCurveY;
+                break;
+            case 'above-right':
+                coordQ.x1 = start.x;
+                coordQ.y1 = start.y - lineCurveY;
+                coordQ.x = coordQ.x1 + lineCurveX;
+                coordQ.y = coordQ.y1;
+                break;
+            case 'under-right':
+                coordQ.x1 = start.x;
+                coordQ.y1 = start.y + lineCurveY;
+                coordQ.x = coordQ.x1 + lineCurveX;
+                coordQ.y = coordQ.y1;
+                break;
+            case 'right-above':
+                coordQ.x1 = start.x + lineCurveX;
+                coordQ.y1 = start.y;
+                coordQ.x = coordQ.x1;
+                coordQ.y = coordQ.y1 - lineCurveY;
+                break;
+            case 'above-left':
+                coordQ.x1 = start.x;
+                coordQ.y1 = start.y - lineCurveY;
+                coordQ.x = coordQ.x1 - lineCurveX;
+                coordQ.y = coordQ.y1;
+                break;
+            case 'left-under':
+                coordQ.x1 = start.x - lineCurveX;
+                coordQ.y1 = start.y;
+                coordQ.x = coordQ.x1;
+                coordQ.y = coordQ.y1 + lineCurveY;
+                break;
+            default:
+                break;
+        }
+        return coordQ;
+    }
+    /**Tránh khối phía bên phải */
+    static byPassElementOnRightSide(startX, startY, endY, lineCurve, elementBlockRoad, directionX, separatedPoints, key, coordLX) {
+        const topElementBlockRoad = elementBlockRoad.y ?? 0;
+        const bottomElementBlockRoad = (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0);
+        const directionY = this.checkUpDownLeftRight(startY, endY, 'y');
+        const Q1 = this.drawLineQ({ x: startX, y: startY ?? 0 }, `${directionX}-${directionY === 'under' ? 'under' : 'above'}`, lineCurve, lineCurve);
+        const L1 = {
+            x: Q1.x ?? 0,
+            y: directionY === 'under' ? bottomElementBlockRoad : topElementBlockRoad,
+        };
+        if (MoCanvasConnectNavigationNewElementUtil.START_MODE !== 'bottom-left') {
+            if ((directionY === 'under' && bottomElementBlockRoad - (Q1.y ?? 0) <= 0) || (directionY === 'above' && topElementBlockRoad - (Q1.y ?? 0) >= 0)) {
+                L1.y = Q1.y ?? 0;
+            }
+            if (Math.abs((L1.y ?? 0) - endY) <= 10) {
+                L1.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, L1.y, lineCurve);
+            }
+        }
+        const Q2 = this.drawLineQ({ x: L1.x, y: L1.y ?? 0 }, `${directionY === 'under' ? 'under' : 'above'}-${directionX}`, lineCurve, lineCurve);
+        const pathQ1 = `Q ${Q1.x1},${Q1.y1} ${Q1.x},${Q1.y} L ${L1.x} ${L1.y}`;
+        const pathQ2 = `Q ${Q2.x1},${Q2.y1} ${Q2.x},${Q2.y}`;
+        separatedPoints.push({ start: { x: coordLX ?? startX, y: startY }, end: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, mode: 'horizontal-single-curve', id: key, name: 'qr' });
+        separatedPoints.push({ start: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, end: { x: L1.x ?? 0, y: L1.y }, mode: 'horizontal', id: key, name: 'lr' });
+        separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y }, end: { x: Q2.x ?? 0, y: Q2.y ?? 0 }, mode: 'vertical-single-curve', id: key, name: 'q2r' });
+        return {
+            pathByPassQ: `${pathQ1} ${pathQ2}`,
+            endPath: {
+                x: Q2.x ?? 0,
+                y: Q2.y ?? 0,
+            },
+        };
+    }
+    /**Tránh khối phía bên trên */
+    static byPassElementOnTopBottomSide(startX, startY, endX, lineCurve, elementBlockRoad, directionY, separatedPoints, key) {
+        const leftElementBlockRoad = elementBlockRoad.x ?? 0;
+        const rightElementBlockRoad = (elementBlockRoad.x ?? 0) + (elementBlockRoad.width ?? 0);
+        const directionX = this.checkUpDownLeftRight(startX, endX, 'x') === 'left' ? 'left' : 'right'; // xem nên tránh sang trái hay phải
+        const Q1 = this.drawLineQ({ x: startX, y: startY ?? 0 }, `${directionY}-${directionX}`, lineCurve, lineCurve);
+        const L1 = {
+            x: directionX === 'left' ? leftElementBlockRoad : rightElementBlockRoad,
+            y: Q1.y ?? 0,
+        };
+        if ((directionX === 'right' && rightElementBlockRoad - (Q1.x ?? 0) <= 0) || (directionX === 'left' && leftElementBlockRoad - (Q1.x ?? 0) >= 0)) {
+            L1.x = Q1.x ?? 0;
+        }
+        const Q2 = this.drawLineQ({ x: L1.x, y: L1.y ?? 0 }, `${directionX}-${directionY}`, lineCurve, lineCurve);
+        if (Math.abs((Q2.x ?? 0) - leftElementBlockRoad) <= 10) {
+            Q2.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, Q2.x, lineCurve, true);
+        }
+        const pathQ1 = `Q ${Q1.x1},${Q1.y1} ${Q1.x},${Q1.y} L ${L1.x} ${L1.y}`;
+        const pathQ2 = `Q ${Q2.x1},${Q2.y1} ${Q2.x},${Q2.y}`;
+        separatedPoints.push({ start: { x: startX, y: startY }, end: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, mode: 'vertical-single-curve', id: key ?? 'qb' });
+        separatedPoints.push({ start: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, end: { x: L1.x ?? 0, y: L1.y ?? 0 }, mode: 'horizontal-single-curve', id: key ?? 'lb' });
+        separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y ?? 0 }, end: { x: Q2.x ?? 0, y: Q2.y ?? 0 }, mode: 'horizontal-single-curve', id: key ?? 'q2b' });
+        return {
+            pathByPassQ: `${pathQ1} ${pathQ2}`,
+            endPath: {
+                x: Q2.x ?? 0,
+                y: Q2.y ?? 0,
+            },
+        };
+    }
+    // kiểm tra đường thẳng và khối có cắt nhau không
+    static checkLinePassBlockHorizontal(start, end, xOrYOfLine, direction, obstacleRect, returnAllElementBlockRoad) {
+        const minimumDistanceFromBlock = 8;
+        start += minimumDistanceFromBlock + 1; // tránh khối xuất phát vào list
+        const listPointsOfLine = range(start, end + 1);
+        const elementBlockRoad = obstacleRect.filter((item) => {
+            const left = (item.x ?? 0) - minimumDistanceFromBlock;
+            const right = (item.x ?? 0) + (item.width ?? 0) + minimumDistanceFromBlock;
+            const top = (item.y ?? 0) - minimumDistanceFromBlock;
+            const bottom = (item.y ?? 0) + (item.height ?? 0) + minimumDistanceFromBlock;
+            if (direction === 'x' && listPointsOfLine.find((el) => left <= el && el <= right) && top <= xOrYOfLine && xOrYOfLine <= bottom) {
+                return true;
+            }
+            if (direction === 'y' && listPointsOfLine.find((el) => top <= el && el <= bottom) && left <= xOrYOfLine && xOrYOfLine <= right) {
+                return true;
+            }
+            return false;
+        });
+        if (!elementBlockRoad || !elementBlockRoad.length) {
+            return undefined;
+        }
+        if (returnAllElementBlockRoad) {
+            return elementBlockRoad;
+        }
+        if (direction === 'y') {
+            return elementBlockRoad.reduce((a, b) => (Math.abs((a.y ?? 0) - start) < Math.abs((b.y ?? 0) - start) ? a : b));
+        }
+        return elementBlockRoad.reduce((a, b) => (Math.abs((a.x ?? 0) - start) < Math.abs((b.x ?? 0) - start) ? a : b));
+    }
+    // kiểm tra hướng thẳng vẽ về điểm end xem có bị chắn bởi khối nào không, nếu có thì phải lùi lại điểm end nhé.
+    static checkBlocksElementStraightY(startX, startY, endPosition, obstacleRect) {
+        const elementBlockRoad = this.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect, true);
+        if (!elementBlockRoad || !elementBlockRoad.length) {
+            return;
+        }
+        return elementBlockRoad.reduce((a, b) => (Math.abs(a.x ?? 0 - startX) < Math.abs(b.x ?? 0 - startX) ? a : b));
+    }
+    // kiểm tra hướng ngang vẽ về điểm end xem có bị chắn bởi khối nào không, nếu có thì phải lùi lại điểm end nhé.
+    static checkBlocksElementX(startX, startY, endPosition, obstacleRect) {
+        const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect, true);
+        if (!elementBlockRoad || !elementBlockRoad.length) {
+            return;
+        }
+        return elementBlockRoad.reduce((a, b) => (Math.abs((a.y ?? 0) - startY) < Math.abs((b.y ?? 0) - startY) ? a : b));
+    }
+    // kiểm tra hướng sang phải là tránh khối
+    static checkAndAvoidBlocksLeft(startX, startY, lineCurve, endPosition, obstacleRect, separatedPoints) {
+        const coordLX = { x: endPosition.x, y: startY };
+        const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect);
+        if (!elementBlockRoad) {
+            separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '14' });
+            return coordLX;
+        }
+        const directionX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(startX, endPosition.x, 'x');
+        const specificXElement = directionX === 'right' ? (elementBlockRoad.x ?? 0) : (elementBlockRoad.x ?? 0) + (elementBlockRoad.width ?? 0);
+        coordLX.x = specificXElement + MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 + lineCurve / 2;
+        if (directionX === 'right') {
+            coordLX.x = specificXElement - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;
+        }
+        let startXBypassElement = coordLX.x;
+        if ((directionX === 'left' && startX - (coordLX.x ?? 0) <= 0) || (directionX === 'right' && startX - (coordLX.x ?? 0) >= 0)) {
+            coordLX.x = startX;
+            startXBypassElement = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, coordLX.x, lineCurve);
+        }
+        let lineByPassBlock = [];
+        let { endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, lineByPassBlock, undefined, coordLX.x);
+        if (MoCanvasConnectNavigationNewElementUtil.START_MODE === 'bottom-left' && elementBlockRoad.x + elementBlockRoad.width / 2 === endPosition.x && Math.abs(endPosition.y - elementBlockRoad.y) <= 20) {
+            // check xem khối chắn có phải là khối đích hay không?
+            lineByPassBlock = [];
+            const data = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSideNewMode(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineByPassBlock, undefined, coordLX.x);
+            endPath = data.endPath;
+        }
+        separatedPoints.push(...lineByPassBlock);
+        separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '15' });
+        const dataEndPath = this.checkAndAvoidBlocksLeft(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, obstacleRect, separatedPoints);
+        return dataEndPath;
+    }
+    // kiểm tra hướng sang phải là tránh khối
+    static checkAndAvoidBlocks(startX, startY, lineCurve, endPosition, obstacleRect, separatedPoints, pathPre) {
+        const coordLX = { x: endPosition.x - 30, y: startY };
+        const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect);
+        if (!elementBlockRoad) {
+            const elementBlockRoadStraightLineY = this.checkBlocksElementStraightY((coordLX.x ?? 0) + 10, coordLX.y ?? 0, endPosition, obstacleRect); // tính điểm end_x dự kiến theo trường hợp đẹp nhất xem nó có chắn bởi khối nào khi kéo xuống không
+            if (elementBlockRoadStraightLineY && (elementBlockRoadStraightLineY.x ?? 0) > startX) {
+                let toX = (elementBlockRoadStraightLineY.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;
+                if ((elementBlockRoadStraightLineY?.x ?? 0) - startX < MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT) {
+                    toX = (elementBlockRoadStraightLineY.x ?? 0) - ((elementBlockRoadStraightLineY?.x ?? 0) - startX) / 2;
+                }
+                coordLX.x = toX;
+            }
+            separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'end' });
+            return {
+                path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,
+                endPath: coordLX,
+            };
+        }
+        const directionX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(startX, endPosition.x, 'x');
+        coordLX.x = (elementBlockRoad.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;
+        let separatedPointsByPassElementOnRightSide = [];
+        const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(coordLX.x, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, separatedPointsByPassElementOnRightSide, 'checkAndAvoidBlocks', coordLX.x);
+        let line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;
+        // tính trước trường hợp sau để lùi line
+        const elementBlockRoadPre = this.checkLinePassBlockHorizontal(endPath.x ?? 0, endPosition.x, endPath.y ?? 0, 'x', obstacleRect);
+        if (!elementBlockRoadPre) {
+            const elementBlockRoadStraightLineY = this.checkBlocksElementStraightY((endPosition.x ?? 0) + 10, endPath.y ?? 0, endPosition, obstacleRect);
+            if (elementBlockRoadStraightLineY) {
+                const XNew = (elementBlockRoadStraightLineY.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;
+                if (XNew < (endPath.x ?? 0)) {
+                    separatedPointsByPassElementOnRightSide = [];
+                    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'u' });
+                    line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`;
+                    return {
+                        path: line,
+                        endPath: coordLX,
+                    };
+                }
+            }
+        }
+        separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsByPassElementOnRightSide);
+        separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'p' });
+        const data = this.checkAndAvoidBlocks(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, obstacleRect, separatedPoints, `${line}`);
+        return {
+            path: data.path,
+            endPath: data.endPath,
+        };
+    }
+    // kiểm tra hướng thẳng và tránh khối
+    static checkAndAvoidBlocksY(startX, startY, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, pathPre) {
+        const coordLX = { x: startX, y: endPosition.y };
+        const elementBlockRoad = this.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect);
+        if ((directionY === 'under' && startY > endPosition.y) || (directionY === 'above' && startY < endPosition.y)) {
+            separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'k' });
+            return {
+                path: pathPre ?? '',
+                endPath: { x: startX, y: startY },
+            };
+        }
+        if (!elementBlockRoad) {
+            separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'r' });
+            return {
+                path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,
+                endPath: coordLX,
+            };
+        }
+        const y = directionY === 'above' ? (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0) : (elementBlockRoad.y ?? 0);
+        coordLX.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, y, lineCurve * 2);
+        separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'ra' });
+        const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnTopBottomSide(coordLX.x ?? 0, coordLX.y ?? 0, endPosition.x, lineCurve, elementBlockRoad, directionY, separatedPoints);
+        // sau khi đã tránh thì tiếp tục kéo dài cho tời điểm end x, lại kiểm tra xem có khối nào chắn không?
+        const line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;
+        const data = this.checkAndAvoidBlocksY(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, `${line}`);
+        return {
+            path: data.path,
+            endPath: data.endPath,
+        };
+    }
+    // kiểm tra hướng thẳng và tránh khối
+    static checkAndAvoidBlocksYLeft(startX, startY, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, pathPre) {
+        const key = 'checkAndAvoidBlocksYLeft';
+        const coordLX = { x: startX, y: endPosition.y };
+        const elementBlockRoad = MoCanvasCalculatorDirectionElementUtil.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect);
+        if (!elementBlockRoad) {
+            const elementBlockRoadStraightLineX = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementX(coordLX.x ?? 0, coordLX.y ?? 0, endPosition, obstacleRect);
+            if (elementBlockRoadStraightLineX) {
+                const topElementBlockRoad = elementBlockRoadStraightLineX.y ?? 0;
+                const bottomElementBlockRoad = (elementBlockRoadStraightLineX.y ?? 0) + (elementBlockRoadStraightLineX.height ?? 0);
+                let toY = directionY === 'under' ? topElementBlockRoad : bottomElementBlockRoad;
+                toY = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, toY, lineCurve * 2);
+                if (toY > startY && MoCanvasConnectNavigationNewElementUtil.START_MODE !== 'bottom-left') {
+                    coordLX.y = toY;
+                }
+            }
+            separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: key, name: 'a' });
+            return {
+                path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,
+                endPath: coordLX,
+            };
+        }
+        const y = directionY === 'above' ? (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0) : (elementBlockRoad.y ?? 0);
+        const elementBlockRoadStraightLineX = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementX(coordLX.x ?? 0, coordLX.y ?? 0, endPosition, obstacleRect);
+        let ignoreBypassElement = false;
+        if (elementBlockRoadStraightLineX && elementBlockRoadStraightLineX.id === elementBlockRoad.id) {
+            ignoreBypassElement = true;
+        }
+        coordLX.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, y, lineCurve * 2);
+        let separatedPointsByPassElementOnRightSide = [];
+        const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnTopBottomSide(coordLX.x ?? 0, coordLX.y ?? 0, endPosition.x, lineCurve, elementBlockRoad, directionY, separatedPointsByPassElementOnRightSide, key);
+        let end = coordLX;
+        let line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`;
+        separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: key, name: 'b' });
+        if (ignoreBypassElement) {
+            separatedPointsByPassElementOnRightSide = [];
+            separatedPoints.push({ start: coordLX, end, mode: 'horizontal', id: key, name: 'c' });
+            return {
+                path: line,
+                endPath: end,
+            };
+        }
+        end = endPath;
+        line += ` ${pathByPassQ}`;
+        separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsByPassElementOnRightSide);
+        const data = this.checkAndAvoidBlocksYLeft(end.x ?? 0, end.y ?? 0, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, `${line}`);
+        return {
+            path: data.path,
+            endPath: data.endPath,
+        };
+    }
+    static byPassElementOnRightSideNewMode(startX, startY, endY, separatedPoints, key, coordLX) {
+        const start = { x: coordLX ?? startX, y: startY };
+        const end = { x: (start.x ?? 0) - 20, y: endY };
+        separatedPoints.push({ start: start, end: end, mode: 'horizontal', id: key, name: 'q2r' });
+        return {
+            pathByPassQ: ``,
+            endPath: end,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculator-diretion-element.until.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/draw-line/src/util/calculator-diretion-element.until.ts"],"names":[],"mappings":"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","sourcesContent":["import { range } from '@libs-ui/utils';\nimport { ICoordinatesSvg, IPoint, IPoints, IRect } from '../draw-line.interface';\nimport { MoCanvasCalculatorBranchUtil } from './calculator-branch.util';\nimport { MoCanvasConnectNavigationNewElementUtil } from './connect-navigation-new-element.util';\n\nexport interface IPositionXY {\n  x: number;\n  y: number;\n}\nexport type CornerDirection = 'right-under' | 'under-left' | 'left-above' | 'above-right' | 'under-right' | 'right-above' | 'above-left' | 'left-under'; // theo chiều\nexport class MoCanvasCalculatorDirectionElementUtil {\n  static checkUpDownLeftRight(firstPoint: number | undefined, endPoint: number | undefined, direction: 'x' | 'y'): string {\n    const distance = (firstPoint ?? 0) - (endPoint ?? 0);\n\n    if (distance === 0) {\n      return 'center';\n    }\n    if (distance > 0) {\n      return direction === 'x' ? 'left' : 'above';\n    }\n\n    return direction === 'x' ? 'right' : 'under';\n  }\n\n  static drawLineQ(start: { x: number; y: number }, corner: CornerDirection | string, lineCurveX: number, lineCurveY: number) {\n    const coordQ: ICoordinatesSvg = {};\n\n    switch (corner) {\n      case 'right-under':\n        coordQ.x1 = start.x + lineCurveX;\n        coordQ.y1 = start.y;\n        coordQ.x = coordQ.x1;\n        coordQ.y = coordQ.y1 + lineCurveY;\n        break;\n\n      case 'under-left':\n        coordQ.x1 = start.x;\n        coordQ.y1 = start.y + lineCurveY;\n        coordQ.x = coordQ.x1 - lineCurveX;\n        coordQ.y = coordQ.y1;\n        break;\n\n      case 'left-above':\n        coordQ.x1 = start.x - lineCurveX;\n        coordQ.y1 = start.y;\n        coordQ.x = coordQ.x1;\n        coordQ.y = coordQ.y1 - lineCurveY;\n        break;\n\n      case 'above-right':\n        coordQ.x1 = start.x;\n        coordQ.y1 = start.y - lineCurveY;\n        coordQ.x = coordQ.x1 + lineCurveX;\n        coordQ.y = coordQ.y1;\n        break;\n\n      case 'under-right':\n        coordQ.x1 = start.x;\n        coordQ.y1 = start.y + lineCurveY;\n        coordQ.x = coordQ.x1 + lineCurveX;\n        coordQ.y = coordQ.y1;\n        break;\n\n      case 'right-above':\n        coordQ.x1 = start.x + lineCurveX;\n        coordQ.y1 = start.y;\n        coordQ.x = coordQ.x1;\n        coordQ.y = coordQ.y1 - lineCurveY;\n        break;\n\n      case 'above-left':\n        coordQ.x1 = start.x;\n        coordQ.y1 = start.y - lineCurveY;\n        coordQ.x = coordQ.x1 - lineCurveX;\n        coordQ.y = coordQ.y1;\n        break;\n\n      case 'left-under':\n        coordQ.x1 = start.x - lineCurveX;\n        coordQ.y1 = start.y;\n        coordQ.x = coordQ.x1;\n        coordQ.y = coordQ.y1 + lineCurveY;\n        break;\n\n      default:\n        break;\n    }\n\n    return coordQ;\n  }\n\n  /**Tránh khối phía bên phải */\n  static byPassElementOnRightSide(startX: number, startY: number, endY: number, lineCurve: number, elementBlockRoad: IRect, directionX: string, separatedPoints: Array<IPoints>, key?: string, coordLX?: number) {\n    const topElementBlockRoad = elementBlockRoad.y ?? 0;\n    const bottomElementBlockRoad = (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0);\n    const directionY = this.checkUpDownLeftRight(startY, endY, 'y');\n    const Q1 = this.drawLineQ({ x: startX, y: startY ?? 0 }, `${directionX}-${directionY === 'under' ? 'under' : 'above'}`, lineCurve, lineCurve);\n    const L1 = {\n      x: Q1.x ?? 0,\n      y: directionY === 'under' ? bottomElementBlockRoad : topElementBlockRoad,\n    };\n\n    if (MoCanvasConnectNavigationNewElementUtil.START_MODE !== 'bottom-left') {\n      if ((directionY === 'under' && bottomElementBlockRoad - (Q1.y ?? 0) <= 0) || (directionY === 'above' && topElementBlockRoad - (Q1.y ?? 0) >= 0)) {\n        L1.y = Q1.y ?? 0;\n      }\n\n      if (Math.abs((L1.y ?? 0) - endY) <= 10) {\n        L1.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, L1.y, lineCurve);\n      }\n    }\n    const Q2 = this.drawLineQ({ x: L1.x, y: L1.y ?? 0 }, `${directionY === 'under' ? 'under' : 'above'}-${directionX}`, lineCurve, lineCurve);\n\n    const pathQ1 = `Q ${Q1.x1},${Q1.y1} ${Q1.x},${Q1.y} L ${L1.x} ${L1.y}`;\n    const pathQ2 = `Q ${Q2.x1},${Q2.y1} ${Q2.x},${Q2.y}`;\n\n    separatedPoints.push({ start: { x: coordLX ?? startX, y: startY }, end: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, mode: 'horizontal-single-curve', id: key, name: 'qr' });\n    separatedPoints.push({ start: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, end: { x: L1.x ?? 0, y: L1.y }, mode: 'horizontal', id: key, name: 'lr' });\n    separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y }, end: { x: Q2.x ?? 0, y: Q2.y ?? 0 }, mode: 'vertical-single-curve', id: key, name: 'q2r' });\n\n    return {\n      pathByPassQ: `${pathQ1} ${pathQ2}`,\n      endPath: {\n        x: Q2.x ?? 0,\n        y: Q2.y ?? 0,\n      },\n    };\n  }\n\n  /**Tránh khối phía bên trên */\n  static byPassElementOnTopBottomSide(startX: number, startY: number, endX: number, lineCurve: number, elementBlockRoad: IRect, directionY: string, separatedPoints: Array<IPoints>, key?: string) {\n    const leftElementBlockRoad = elementBlockRoad.x ?? 0;\n    const rightElementBlockRoad = (elementBlockRoad.x ?? 0) + (elementBlockRoad.width ?? 0);\n    const directionX = this.checkUpDownLeftRight(startX, endX, 'x') === 'left' ? 'left' : 'right'; // xem nên tránh sang trái hay phải\n\n    const Q1 = this.drawLineQ({ x: startX, y: startY ?? 0 }, `${directionY}-${directionX}`, lineCurve, lineCurve);\n    const L1 = {\n      x: directionX === 'left' ? leftElementBlockRoad : rightElementBlockRoad,\n      y: Q1.y ?? 0,\n    };\n\n    if ((directionX === 'right' && rightElementBlockRoad - (Q1.x ?? 0) <= 0) || (directionX === 'left' && leftElementBlockRoad - (Q1.x ?? 0) >= 0)) {\n      L1.x = Q1.x ?? 0;\n    }\n    const Q2 = this.drawLineQ({ x: L1.x, y: L1.y ?? 0 }, `${directionX}-${directionY}`, lineCurve, lineCurve);\n\n    if (Math.abs((Q2.x ?? 0) - leftElementBlockRoad) <= 10) {\n      Q2.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, Q2.x, lineCurve, true);\n    }\n\n    const pathQ1 = `Q ${Q1.x1},${Q1.y1} ${Q1.x},${Q1.y} L ${L1.x} ${L1.y}`;\n    const pathQ2 = `Q ${Q2.x1},${Q2.y1} ${Q2.x},${Q2.y}`;\n\n    separatedPoints.push({ start: { x: startX, y: startY }, end: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, mode: 'vertical-single-curve', id: key ?? 'qb' });\n    separatedPoints.push({ start: { x: Q1.x ?? 0, y: Q1.y ?? 0 }, end: { x: L1.x ?? 0, y: L1.y ?? 0 }, mode: 'horizontal-single-curve', id: key ?? 'lb' });\n    separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y ?? 0 }, end: { x: Q2.x ?? 0, y: Q2.y ?? 0 }, mode: 'horizontal-single-curve', id: key ?? 'q2b' });\n\n    return {\n      pathByPassQ: `${pathQ1} ${pathQ2}`,\n      endPath: {\n        x: Q2.x ?? 0,\n        y: Q2.y ?? 0,\n      },\n    };\n  }\n\n  // kiểm tra đường thẳng và khối có cắt nhau không\n  static checkLinePassBlockHorizontal(start: number, end: number, xOrYOfLine: number, direction: 'x' | 'y', obstacleRect: IRect[], returnAllElementBlockRoad?: boolean) {\n    const minimumDistanceFromBlock = 8;\n\n    start += minimumDistanceFromBlock + 1; // tránh khối xuất phát vào list\n    const listPointsOfLine = range(start, end + 1);\n\n    const elementBlockRoad = obstacleRect.filter((item) => {\n      const left = (item.x ?? 0) - minimumDistanceFromBlock;\n      const right = (item.x ?? 0) + (item.width ?? 0) + minimumDistanceFromBlock;\n      const top = (item.y ?? 0) - minimumDistanceFromBlock;\n      const bottom = (item.y ?? 0) + (item.height ?? 0) + minimumDistanceFromBlock;\n\n      if (direction === 'x' && listPointsOfLine.find((el) => left <= el && el <= right) && top <= xOrYOfLine && xOrYOfLine <= bottom) {\n        return true;\n      }\n      if (direction === 'y' && listPointsOfLine.find((el) => top <= el && el <= bottom) && left <= xOrYOfLine && xOrYOfLine <= right) {\n        return true;\n      }\n\n      return false;\n    });\n\n    if (!elementBlockRoad || !elementBlockRoad.length) {\n      return undefined;\n    }\n\n    if (returnAllElementBlockRoad) {\n      return elementBlockRoad;\n    }\n\n    if (direction === 'y') {\n      return elementBlockRoad.reduce((a: IRect, b: IRect) => (Math.abs((a.y ?? 0) - start) < Math.abs((b.y ?? 0) - start) ? a : b));\n    }\n\n    return elementBlockRoad.reduce((a: IRect, b: IRect) => (Math.abs((a.x ?? 0) - start) < Math.abs((b.x ?? 0) - start) ? a : b));\n  }\n\n  // kiểm tra hướng thẳng vẽ về điểm end xem có bị chắn bởi khối nào không, nếu có thì phải lùi lại điểm end nhé.\n  static checkBlocksElementStraightY(startX: number, startY: number, endPosition: { x: number; y: number }, obstacleRect: IRect[]) {\n    const elementBlockRoad = this.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect, true) as IRect[];\n\n    if (!elementBlockRoad || !elementBlockRoad.length) {\n      return;\n    }\n\n    return elementBlockRoad.reduce((a: IRect, b: IRect) => (Math.abs(a.x ?? 0 - startX) < Math.abs(b.x ?? 0 - startX) ? a : b));\n  }\n\n  // kiểm tra hướng ngang vẽ về điểm end xem có bị chắn bởi khối nào không, nếu có thì phải lùi lại điểm end nhé.\n  static checkBlocksElementX(startX: number, startY: number, endPosition: { x: number; y: number }, obstacleRect: IRect[]) {\n    const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect, true) as IRect[];\n\n    if (!elementBlockRoad || !elementBlockRoad.length) {\n      return;\n    }\n\n    return elementBlockRoad.reduce((a: IRect, b: IRect) => (Math.abs((a.y ?? 0) - startY) < Math.abs((b.y ?? 0) - startY) ? a : b));\n  }\n\n  // kiểm tra hướng sang phải là tránh khối\n  static checkAndAvoidBlocksLeft(startX: number, startY: number, lineCurve: number, endPosition: IPositionXY, obstacleRect: IRect[], separatedPoints: Array<IPoints>): IPoint {\n    const coordLX: IPoint = { x: endPosition.x, y: startY };\n    const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect) as IRect;\n\n    if (!elementBlockRoad) {\n      separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '14' });\n\n      return coordLX;\n    }\n\n    const directionX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(startX, endPosition.x, 'x');\n    const specificXElement = directionX === 'right' ? (elementBlockRoad.x ?? 0) : (elementBlockRoad.x ?? 0) + (elementBlockRoad.width ?? 0);\n\n    coordLX.x = specificXElement + MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 + lineCurve / 2;\n    if (directionX === 'right') {\n      coordLX.x = specificXElement - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;\n    }\n\n    let startXBypassElement = coordLX.x;\n\n    if ((directionX === 'left' && startX - (coordLX.x ?? 0) <= 0) || (directionX === 'right' && startX - (coordLX.x ?? 0) >= 0)) {\n      coordLX.x = startX;\n      startXBypassElement = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionX, coordLX.x, lineCurve);\n    }\n\n    let lineByPassBlock: IPoints[] = [];\n    let { endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, lineByPassBlock, undefined, coordLX.x);\n\n    if (MoCanvasConnectNavigationNewElementUtil.START_MODE === 'bottom-left' && elementBlockRoad.x + elementBlockRoad.width / 2 === endPosition.x && Math.abs(endPosition.y - elementBlockRoad.y) <= 20) {\n      // check xem khối chắn có phải là khối đích hay không?\n      lineByPassBlock = [];\n      const data = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSideNewMode(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineByPassBlock, undefined, coordLX.x);\n\n      endPath = data.endPath;\n    }\n    separatedPoints.push(...lineByPassBlock);\n    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '15' });\n    const dataEndPath = this.checkAndAvoidBlocksLeft(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, obstacleRect, separatedPoints);\n\n    return dataEndPath;\n  }\n\n  // kiểm tra hướng sang phải là tránh khối\n  static checkAndAvoidBlocks(startX: number, startY: number, lineCurve: number, endPosition: { x: number; y: number }, obstacleRect: IRect[], separatedPoints: Array<IPoints>, pathPre?: string): { path: string; endPath: IPoint } {\n    const coordLX: IPoint = { x: endPosition.x - 30, y: startY };\n    const elementBlockRoad = this.checkLinePassBlockHorizontal(startX, endPosition.x, startY, 'x', obstacleRect) as IRect;\n\n    if (!elementBlockRoad) {\n      const elementBlockRoadStraightLineY = this.checkBlocksElementStraightY((coordLX.x ?? 0) + 10, coordLX.y ?? 0, endPosition, obstacleRect); // tính điểm end_x dự kiến theo trường hợp đẹp nhất xem nó có chắn bởi khối nào khi kéo xuống không\n\n      if (elementBlockRoadStraightLineY && (elementBlockRoadStraightLineY.x ?? 0) > startX) {\n        let toX = (elementBlockRoadStraightLineY.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;\n\n        if ((elementBlockRoadStraightLineY?.x ?? 0) - startX < MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT) {\n          toX = (elementBlockRoadStraightLineY.x ?? 0) - ((elementBlockRoadStraightLineY?.x ?? 0) - startX) / 2;\n        }\n        coordLX.x = toX;\n      }\n\n      separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'end' });\n\n      return {\n        path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,\n        endPath: coordLX,\n      };\n    }\n    const directionX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(startX, endPosition.x, 'x');\n\n    coordLX.x = (elementBlockRoad.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;\n\n    let separatedPointsByPassElementOnRightSide: Array<IPoints> = [];\n\n    const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(\n      coordLX.x,\n      coordLX.y ?? 0,\n      endPosition.y,\n      lineCurve,\n      elementBlockRoad,\n      directionX,\n      separatedPointsByPassElementOnRightSide,\n      'checkAndAvoidBlocks',\n      coordLX.x\n    );\n    let line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;\n\n    // tính trước trường hợp sau để lùi line\n    const elementBlockRoadPre = this.checkLinePassBlockHorizontal(endPath.x ?? 0, endPosition.x, endPath.y ?? 0, 'x', obstacleRect) as IRect;\n\n    if (!elementBlockRoadPre) {\n      const elementBlockRoadStraightLineY = this.checkBlocksElementStraightY((endPosition.x ?? 0) + 10, endPath.y ?? 0, endPosition, obstacleRect);\n\n      if (elementBlockRoadStraightLineY) {\n        const XNew = (elementBlockRoadStraightLineY.x ?? 0) - MoCanvasConnectNavigationNewElementUtil.ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT / 2 - lineCurve / 2;\n\n        if (XNew < (endPath.x ?? 0)) {\n          separatedPointsByPassElementOnRightSide = [];\n          separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'u' });\n\n          line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`;\n\n          return {\n            path: line,\n            endPath: coordLX,\n          };\n        }\n      }\n    }\n    separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsByPassElementOnRightSide);\n    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'checkAndAvoidBlocks', name: 'p' });\n    const data = this.checkAndAvoidBlocks(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, obstacleRect, separatedPoints, `${line}`);\n\n    return {\n      path: data.path,\n      endPath: data.endPath,\n    };\n  }\n\n  // kiểm tra hướng thẳng và tránh khối\n  static checkAndAvoidBlocksY(startX: number, startY: number, lineCurve: number, endPosition: { x: number; y: number }, directionY: string, obstacleRect: IRect[], separatedPoints: Array<IPoints>, pathPre?: string): { path: string; endPath: IPoint } {\n    const coordLX: IPoint = { x: startX, y: endPosition.y };\n    const elementBlockRoad = this.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect) as IRect;\n\n    if ((directionY === 'under' && startY > endPosition.y) || (directionY === 'above' && startY < endPosition.y)) {\n      separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'k' });\n\n      return {\n        path: pathPre ?? '',\n        endPath: { x: startX, y: startY },\n      };\n    }\n    if (!elementBlockRoad) {\n      separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'r' });\n\n      return {\n        path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,\n        endPath: coordLX,\n      };\n    }\n\n    const y = directionY === 'above' ? (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0) : (elementBlockRoad.y ?? 0);\n\n    coordLX.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, y, lineCurve * 2);\n\n    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: 'ra' });\n    const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnTopBottomSide(coordLX.x ?? 0, coordLX.y ?? 0, endPosition.x, lineCurve, elementBlockRoad, directionY, separatedPoints);\n\n    // sau khi đã tránh thì tiếp tục kéo dài cho tời điểm end x, lại kiểm tra xem có khối nào chắn không?\n    const line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;\n    const data = this.checkAndAvoidBlocksY(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, `${line}`);\n\n    return {\n      path: data.path,\n      endPath: data.endPath,\n    };\n  }\n\n  // kiểm tra hướng thẳng và tránh khối\n  static checkAndAvoidBlocksYLeft(startX: number, startY: number, lineCurve: number, endPosition: IPositionXY, directionY: string, obstacleRect: IRect[], separatedPoints: Array<IPoints>, pathPre?: string): { path: string; endPath: IPositionXY } {\n    const key = 'checkAndAvoidBlocksYLeft';\n\n    const coordLX: IPositionXY = { x: startX, y: endPosition.y };\n    const elementBlockRoad = MoCanvasCalculatorDirectionElementUtil.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect) as IRect;\n\n    if (!elementBlockRoad) {\n      const elementBlockRoadStraightLineX = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementX(coordLX.x ?? 0, coordLX.y ?? 0, endPosition, obstacleRect);\n\n      if (elementBlockRoadStraightLineX) {\n        const topElementBlockRoad = elementBlockRoadStraightLineX.y ?? 0;\n        const bottomElementBlockRoad = (elementBlockRoadStraightLineX.y ?? 0) + (elementBlockRoadStraightLineX.height ?? 0);\n\n        let toY = directionY === 'under' ? topElementBlockRoad : bottomElementBlockRoad;\n\n        toY = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, toY, lineCurve * 2);\n\n        if (toY > startY && MoCanvasConnectNavigationNewElementUtil.START_MODE !== 'bottom-left') {\n          coordLX.y = toY;\n        }\n      }\n\n      separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: key, name: 'a' });\n\n      return {\n        path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,\n        endPath: coordLX,\n      };\n    }\n\n    const y = directionY === 'above' ? (elementBlockRoad.y ?? 0) + (elementBlockRoad.height ?? 0) : (elementBlockRoad.y ?? 0);\n    const elementBlockRoadStraightLineX = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementX(coordLX.x ?? 0, coordLX.y ?? 0, endPosition, obstacleRect);\n    let ignoreBypassElement = false;\n\n    if (elementBlockRoadStraightLineX && elementBlockRoadStraightLineX.id === elementBlockRoad.id) {\n      ignoreBypassElement = true;\n    }\n    coordLX.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, y, lineCurve * 2);\n\n    let separatedPointsByPassElementOnRightSide: Array<IPoints> = [];\n\n    const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnTopBottomSide(coordLX.x ?? 0, coordLX.y ?? 0, endPosition.x, lineCurve, elementBlockRoad, directionY, separatedPointsByPassElementOnRightSide, key);\n    let end = coordLX;\n    let line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`;\n\n    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: key, name: 'b' });\n\n    if (ignoreBypassElement) {\n      separatedPointsByPassElementOnRightSide = [];\n      separatedPoints.push({ start: coordLX, end, mode: 'horizontal', id: key, name: 'c' });\n\n      return {\n        path: line,\n        endPath: end,\n      };\n    }\n\n    end = endPath;\n    line += ` ${pathByPassQ}`;\n    separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsByPassElementOnRightSide);\n    const data = this.checkAndAvoidBlocksYLeft(end.x ?? 0, end.y ?? 0, lineCurve, endPosition, directionY, obstacleRect, separatedPoints, `${line}`);\n\n    return {\n      path: data.path,\n      endPath: data.endPath,\n    };\n  }\n\n  static byPassElementOnRightSideNewMode(startX: number, startY: number, endY: number, separatedPoints: Array<IPoints>, key?: string, coordLX?: number) {\n    const start = { x: coordLX ?? startX, y: startY };\n    const end = { x: (start.x ?? 0) - 20, y: endY };\n\n    separatedPoints.push({ start: start, end: end, mode: 'horizontal', id: key, name: 'q2r' });\n\n    return {\n      pathByPassQ: ``,\n      endPath: end,\n    };\n  }\n}\n"]}