@libs-ui/components-draw-line 0.2.61

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRvci1icmFuY2gudXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMtdWkvY29tcG9uZW50cy9kcmF3LWxpbmUvc3JjL3V0aWwvY2FsY3VsYXRvci1icmFuY2gudXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sNEJBQTRCO0lBQ3ZDOzs7OztLQUtDO0lBQ0QsTUFBTSxDQUFDLHdCQUF3QixDQUFDLFNBQXdELEVBQUUsQ0FBcUIsRUFBRSxDQUFxQixFQUFFLFFBQWtCO1FBQ3hKLFFBQVEsU0FBUyxFQUFFLENBQUM7WUFDbEIsS0FBSyxNQUFNLENBQUM7WUFDWixLQUFLLE9BQU87Z0JBQ1YsSUFBSSxRQUFRLEVBQUUsQ0FBQztvQkFDYixPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUM3QixDQUFDO2dCQUVELE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFFN0IsS0FBSyxPQUFPLENBQUM7WUFDYixLQUFLLE9BQU87Z0JBQ1YsSUFBSSxRQUFRLEVBQUUsQ0FBQztvQkFDYixPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUM3QixDQUFDO2dCQUVELE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDN0I7Z0JBQ0UsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUMvQixDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIE1vQ2FudmFzQ2FsY3VsYXRvckJyYW5jaFV0aWwge1xuICAvKipcbiAqIFxuICogYWJvdmUsIGxlZnQgYSArIGI7IG9wcG9zaXRlID0gdHJ1ZSBhIC0gYjtcbiAqIFxuICogdW5kZXIsIHJpZ2h0IGEgLSBiOyBvcHBvc2l0ZSA9IHRydWUgYSArIGJcbiAqL1xuICBzdGF0aWMgbWF0aE9wZXJhdG9yc0NhbGN1bGF0aW9uKGRpcmVjdGlvbjogJ2xlZnQnIHwgJ3JpZ2h0JyB8ICdhYm92ZScgfCAndW5kZXInIHwgc3RyaW5nLCBhOiBudW1iZXIgfCB1bmRlZmluZWQsIGI6IG51bWJlciB8IHVuZGVmaW5lZCwgb3Bwb3NpdGU/OiBib29sZWFuKSB7XG4gICAgc3dpdGNoIChkaXJlY3Rpb24pIHtcbiAgICAgIGNhc2UgJ2xlZnQnOlxuICAgICAgY2FzZSAnYWJvdmUnOlxuICAgICAgICBpZiAob3Bwb3NpdGUpIHtcbiAgICAgICAgICByZXR1cm4gKGEgPz8gMCkgLSAoYiA/PyAwKTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiAoYSA/PyAwKSArIChiID8/IDApO1xuXG4gICAgICBjYXNlICdyaWdodCc6XG4gICAgICBjYXNlICd1bmRlcic6XG4gICAgICAgIGlmIChvcHBvc2l0ZSkge1xuICAgICAgICAgIHJldHVybiAoYSA/PyAwKSArIChiID8/IDApO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIChhID8/IDApIC0gKGIgPz8gMCk7XG4gICAgICBkZWZhdWx0OlxuICAgICAgICByZXR1cm4gKGEgPz8gMCkgLSAoYiA/PyAwKTtcbiAgICB9XG4gIH1cbn0iXX0=

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

@@ -0,0 +1,339 @@
+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 ((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 ?? 0 }, mode: 'horizontal', id: key, name: 'lr' });
+        separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y ?? 0 }, 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, pathPre) {
+        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 {
+                path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,
+                endPath: 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);
+        }
+        const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, separatedPoints, undefined, coordLX.x);
+        const line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;
+        separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '15' });
+        const data = this.checkAndAvoidBlocksLeft(endPath.x ?? 0, endPath.y ?? 0, lineCurve, endPosition, obstacleRect, separatedPoints, `${line}`);
+        return {
+            path: data.path,
+            endPath: data.endPath
+        };
+    }
+    // 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: 'w' });
+            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) {
+                    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
+        };
+    }
+}
+//# 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 { x: number, y: number }\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\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    if ((directionY === 'under' && bottomElementBlockRoad - (Q1.y ?? 0) <= 0)\n      || (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    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 ?? 0 }, mode: 'horizontal', id: key, name: 'lr' });\n    separatedPoints.push({ start: { x: L1.x ?? 0, y: L1.y ?? 0 }, 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    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>, pathPre?: string): { path: string, endPath: 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 {\n        path: pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y}` : `L ${coordLX.x} ${coordLX.y}`,\n        endPath: coordLX\n      };\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    const { pathByPassQ, endPath } = MoCanvasCalculatorDirectionElementUtil.byPassElementOnRightSide(startXBypassElement ?? 0, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, separatedPoints, undefined, coordLX.x);\n\n    const line = pathPre ? `${pathPre} L ${coordLX.x} ${coordLX.y} ${pathByPassQ}` : `L ${coordLX.x} ${coordLX.y} ${pathByPassQ}`;\n\n    separatedPoints.push({ start: { x: startX, y: startY }, end: coordLX, mode: 'horizontal', id: '15' });\n    const data = this.checkAndAvoidBlocksLeft(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 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: 'w' });\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(coordLX.x, coordLX.y ?? 0, endPosition.y, lineCurve, elementBlockRoad, directionX, separatedPointsByPassElementOnRightSide, 'checkAndAvoidBlocks', coordLX.x);\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    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    const coordLX: IPositionXY = { x: startX, y: endPosition.y };\n    const elementBlockRoad = MoCanvasCalculatorDirectionElementUtil.checkLinePassBlockHorizontal(startY, endPosition.y, startX, 'y', obstacleRect) as IRect;\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        if (toY > startY) {\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}"]}