@libs-ui/services-diagram-draw 0.2.356-37

package/esm2022/utils/diagram.util.mjs

@@ -0,0 +1,54 @@
+import { canvasConfigReadonly } from '../diagram-draw.service';
+export const buildFlatElement = (elements, flatElementsContainer) => {
+    elements.forEach((element) => {
+        flatElementsContainer.push(element);
+        if (!element.branches || !element.branches.length) {
+            return;
+        }
+        flatElementHasBranch(element, flatElementsContainer);
+    });
+};
+const flatElementHasBranch = (element, flatElementsContainer) => {
+    if (!element.branches || !element.branches.length) {
+        return;
+    }
+    element.branches.forEach((branch) => {
+        if (!branch.elements || !branch.elements.length) {
+            return;
+        }
+        buildFlatElement(branch.elements, flatElementsContainer);
+    });
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const setAttributeSvgAndAppend = (svgElement, elementSvg, svgAttributePathD, color) => {
+    elementSvg?.setAttribute('d', svgAttributePathD);
+    elementSvg?.setAttribute('stroke', `#${color ?? canvasConfigReadonly().ELEMENT_SVG_STROKE_COLOR}`);
+    elementSvg?.setAttribute('fill', 'none');
+    elementSvg?.setAttribute('stroke-width', canvasConfigReadonly().ELEMENT_SVG_STROKE_WIDTH);
+    svgElement?.nativeElement.appendChild(elementSvg);
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const canvasRemoveChildInSvg = (svgElement) => {
+    if (!svgElement) {
+        return;
+    }
+    const children = Array.from(svgElement?.nativeElement.children);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    children.forEach((child) => {
+        if (child.tagName !== 'path') {
+            return;
+        }
+        child.remove();
+    });
+};
+export const applyElementStyle = (el, element) => {
+    el.style.position = 'absolute';
+    el.style.top = '0';
+    el.style.left = '0';
+    el.style.transform = `translate(${element.translateX}px, ${element.translateY}px)`;
+    el.style.width = `${element.specific_width}px`;
+    el.style.height = `${element.specific_height}px`;
+    el.style.zIndex = '1';
+    el.style.willChange = 'transform';
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/direction.util.mjs

@@ -0,0 +1,103 @@
+import { cloneDeep } from '@libs-ui/utils';
+import { canvasConfigReadonly } from '../diagram-draw.service';
+import { buildFlatElement } from './diagram.util';
+export const buildElementDirectionTo = (element, flatElements, checkRule, branch) => {
+    let elementsFlat = cloneDeep(flatElements) ?? [];
+    if (element.element_type === canvasConfigReadonly().TYPE_ELEMENT_WORKFLOW) {
+        if (!branch) {
+            return undefined;
+        }
+        getAllItemPreOfElement(element, elementsFlat);
+        getAllItemNextOfBranch(branch, elementsFlat);
+        elementsFlat = elementsFlat.filter((item) => item.id !== element.id && item.code !== canvasConfigReadonly().TYPE_ELEMENT_EXIT);
+        if (element.pre_other_id?.length) {
+            elementsFlat = elementsFlat.filter((item) => !element.pre_other_id?.includes(item.id ?? ''));
+        }
+        elementsFlat = elementsFlat.filter((item) => {
+            return checkRule(element, item);
+        });
+        return elementsFlat;
+    }
+    getAllItemPreOfElement(element, elementsFlat);
+    getAllItemNextOfElement(element, elementsFlat);
+    elementsFlat = elementsFlat.filter((item) => item.id !== element.id && item.code !== canvasConfigReadonly().TYPE_ELEMENT_EXIT);
+    if (element.pre_other_id?.length) {
+        elementsFlat = elementsFlat.filter((item) => !element.pre_other_id?.includes(item.id ?? ''));
+    }
+    elementsFlat = elementsFlat.filter((item) => {
+        return checkRule(element, item);
+    });
+    return elementsFlat;
+};
+export const getAllItemPreOfElement = (element, flatElements) => {
+    const pre_id = [];
+    if (element.pre_id) {
+        pre_id.push(element.pre_id);
+    }
+    if (element.pre_other_id) {
+        pre_id.push(...element.pre_other_id);
+    }
+    if (!pre_id.length) {
+        return;
+    }
+    pre_id.forEach((preId) => {
+        const elementPre = flatElements.find((item) => item.id === preId);
+        if (!elementPre) {
+            return;
+        }
+        const itemIndex = flatElements.findIndex((item) => item.id === preId);
+        flatElements.splice(itemIndex, 1);
+        getAllItemPreOfElement(elementPre, flatElements);
+    });
+};
+export const getAllItemNextOfElement = (element, flatElements) => {
+    if (!element.next_id) {
+        if (!element.branches || !element.branches.length) {
+            return;
+        }
+        const flatElementInElementCurrent = [];
+        buildFlatElement([element], flatElementInElementCurrent);
+        flatElementInElementCurrent.forEach((el) => {
+            const itemIndex = flatElements.findIndex((item) => item.id === el.id);
+            if (itemIndex === -1) {
+                return;
+            }
+            flatElements.splice(itemIndex, 1);
+        });
+        return;
+    }
+    const elementNextIndex = flatElements.findIndex((item) => item.id === element.next_id);
+    if (elementNextIndex === -1) {
+        return;
+    }
+    const nextElement = flatElements[elementNextIndex];
+    flatElements.splice(elementNextIndex, 1);
+    getAllItemNextOfElement(nextElement, flatElements);
+};
+export const getAllItemNextOfBranch = (branch, flatElements) => {
+    const flatElementInElementCurrent = [];
+    buildFlatElement(branch.elements, flatElementInElementCurrent);
+    flatElementInElementCurrent.forEach((el) => {
+        const itemIndex = flatElements.findIndex((item) => item.id === el.id);
+        if (itemIndex === -1) {
+            return;
+        }
+        flatElements.splice(itemIndex, 1);
+    });
+};
+export const collectNextChainElements = (element, flatContainerElement, listElementDelete) => {
+    const elementNext = flatContainerElement.find((item) => item.id === element.next_id);
+    if (!elementNext) {
+        return;
+    }
+    const flatElementInElementCurrent = [];
+    buildFlatElement([elementNext], flatElementInElementCurrent);
+    flatElementInElementCurrent.forEach((el) => {
+        const itemInNext = flatContainerElement.find((item) => item.id === el.id);
+        if (itemInNext) {
+            listElementDelete.push(itemInNext);
+        }
+    });
+    collectNextChainElements(elementNext, flatContainerElement, listElementDelete);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"direction.util.js","sourceRoot":"","sources":["../../../../../../libs-ui/services/diagram-draw/src/utils/direction.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloneDeep } from '@libs-ui/utils';\nimport { canvasConfigReadonly } from '../diagram-draw.service';\nimport { IDiagramElement, IDiagramElementBranch } from '../interfaces/diagram.interface';\nimport { buildFlatElement } from './diagram.util';\n\nexport const buildElementDirectionTo = (element: IDiagramElement, flatElements: IDiagramElement[], checkRule: (element: IDiagramElement, item: IDiagramElement) => boolean, branch?: IDiagramElementBranch) => {\n  let elementsFlat: IDiagramElement[] = cloneDeep(flatElements) ?? [];\n\n  if (element.element_type === canvasConfigReadonly().TYPE_ELEMENT_WORKFLOW) {\n    if (!branch) {\n      return undefined;\n    }\n\n    getAllItemPreOfElement(element, elementsFlat);\n    getAllItemNextOfBranch(branch, elementsFlat);\n    elementsFlat = elementsFlat.filter((item) => item.id !== element.id && item.code !== canvasConfigReadonly().TYPE_ELEMENT_EXIT);\n    if (element.pre_other_id?.length) {\n      elementsFlat = elementsFlat.filter((item) => !element.pre_other_id?.includes(item.id ?? ''));\n    }\n    elementsFlat = elementsFlat.filter((item) => {\n      return checkRule(element, item);\n    });\n\n    return elementsFlat;\n  }\n\n  getAllItemPreOfElement(element, elementsFlat);\n  getAllItemNextOfElement(element, elementsFlat);\n  elementsFlat = elementsFlat.filter((item) => item.id !== element.id && item.code !== canvasConfigReadonly().TYPE_ELEMENT_EXIT);\n\n  if (element.pre_other_id?.length) {\n    elementsFlat = elementsFlat.filter((item) => !element.pre_other_id?.includes(item.id ?? ''));\n  }\n\n  elementsFlat = elementsFlat.filter((item) => {\n    return checkRule(element, item);\n  });\n\n  return elementsFlat;\n};\n\nexport const getAllItemPreOfElement = (element: IDiagramElement, flatElements: IDiagramElement[]) => {\n  const pre_id = [];\n\n  if (element.pre_id) {\n    pre_id.push(element.pre_id);\n  }\n  if (element.pre_other_id) {\n    pre_id.push(...element.pre_other_id);\n  }\n  if (!pre_id.length) {\n    return;\n  }\n  pre_id.forEach((preId) => {\n    const elementPre = flatElements.find((item) => item.id === preId);\n\n    if (!elementPre) {\n      return;\n    }\n    const itemIndex = flatElements.findIndex((item) => item.id === preId);\n\n    flatElements.splice(itemIndex, 1);\n    getAllItemPreOfElement(elementPre, flatElements);\n  });\n};\n\nexport const getAllItemNextOfElement = (element: IDiagramElement, flatElements: IDiagramElement[]) => {\n  if (!element.next_id) {\n    if (!element.branches || !element.branches.length) {\n      return;\n    }\n\n    const flatElementInElementCurrent: IDiagramElement[] = [];\n\n    buildFlatElement([element], flatElementInElementCurrent);\n    flatElementInElementCurrent.forEach((el) => {\n      const itemIndex = flatElements.findIndex((item) => item.id === el.id);\n\n      if (itemIndex === -1) {\n        return;\n      }\n\n      flatElements.splice(itemIndex, 1);\n    });\n\n    return;\n  }\n  const elementNextIndex = flatElements.findIndex((item) => item.id === element.next_id);\n\n  if (elementNextIndex === -1) {\n    return;\n  }\n  const nextElement = flatElements[elementNextIndex];\n\n  flatElements.splice(elementNextIndex, 1);\n  getAllItemNextOfElement(nextElement, flatElements);\n};\n\nexport const getAllItemNextOfBranch = (branch: IDiagramElementBranch, flatElements: IDiagramElement[]) => {\n  const flatElementInElementCurrent: IDiagramElement[] = [];\n\n  buildFlatElement(branch.elements, flatElementInElementCurrent);\n  flatElementInElementCurrent.forEach((el) => {\n    const itemIndex = flatElements.findIndex((item) => item.id === el.id);\n\n    if (itemIndex === -1) {\n      return;\n    }\n\n    flatElements.splice(itemIndex, 1);\n  });\n};\n\nexport const collectNextChainElements = (element: IDiagramElement, flatContainerElement: IDiagramElement[], listElementDelete: IDiagramElement[]) => {\n  const elementNext = flatContainerElement.find((item) => item.id === element.next_id);\n\n  if (!elementNext) {\n    return;\n  }\n  const flatElementInElementCurrent: IDiagramElement[] = [];\n\n  buildFlatElement([elementNext], flatElementInElementCurrent);\n  flatElementInElementCurrent.forEach((el) => {\n    const itemInNext = flatContainerElement.find((item) => item.id === el.id);\n\n    if (itemInNext) {\n      listElementDelete.push(itemInNext);\n    }\n  });\n  collectNextChainElements(elementNext, flatContainerElement, listElementDelete);\n};\n"]}

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

@@ -0,0 +1,243 @@
+import { canvasConfigReadonly } from '../../diagram-draw.service';
+import { checkMaxTop } from '../calculator-element.util';
+import { getHeightWaitConfig } from '../calculator-element.util';
+import { MoLibDiagramHorizontalCalculatorCoordinatesUtil } from './calculator-coordinates.util';
+/**
+ * Horizontal branch calculator.
+ * Flow direction: LEFT → RIGHT (trái sang phải).
+ * Branches spread:  above = UP (y giảm),  under = DOWN (y tăng).
+ *
+ * Mapping từ trục dọc sang ngang:
+ *   vertical "left"  branch (x giảm) ↔ horizontal "above" branch (y giảm)
+ *   vertical "right" branch (x tăng) ↔ horizontal "under" branch  (y tăng)
+ *
+ * Ký hiệu trong ICoordinatesDiagramSvg:
+ *   (mx,my) = điểm bắt đầu Q curve
+ *   (x1,y1) = control point
+ *   (x,y)   = end point của Q curve
+ *   (lx,ly) = điểm cuối của L sau Q
+ */
+export class MoLibDiagramHorizontalCalculatorBranchUtil {
+    static getHorizontalDistanceToFirstBlock(branch) {
+        if (branch.nodeOtherConfig) {
+            const distToWait = 110; // increase statically since branch label is always assigned later
+            return distToWait + getHeightWaitConfig(branch.nodeOtherConfig) + canvasConfigReadonly().WAIT_TO_ELEMENT;
+        }
+        return canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT_BRANCH_TO_ELEMENT_FIRST;
+    }
+    // ─────────────────────────────────────────────────────────────────── public ──
+    /** Nhánh giữa (center): kéo thẳng sang phải */
+    static drawStraightLine(top, // Y tâm của element cha
+    lineFormElementToBranching, // width element + margin đến điểm rẽ
+    left, // X trái của element cha
+    branch, maxWidthBranch, config) {
+        branch.onTheSide = 'center';
+        const startDraw = left + lineFormElementToBranching;
+        let Lx = startDraw;
+        Lx += canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;
+        Lx += this.getHorizontalDistanceToFirstBlock(branch);
+        if (!branch.elements || !branch.elements.length) {
+            Lx += maxWidthBranch + 20;
+        }
+        const coord1 = { mx: left, my: top, lx: Lx, ly: top };
+        branch.attributeSvgD = `M ${coord1.mx} ${coord1.my} L ${coord1.lx} ${coord1.ly}`;
+        if (branch.nodeOtherConfig) {
+            const distToWait = 110;
+            const endXToWait = startDraw + canvasConfigReadonly().ELEMENT_HEIGHT_CURVE + distToWait;
+            branch.attributeSvgD = `M ${coord1.mx} ${coord1.my} L ${endXToWait} ${coord1.my}`;
+            const waitWidth = getHeightWaitConfig(branch.nodeOtherConfig);
+            const leftLine2 = endXToWait + waitWidth;
+            delete branch.nodeOtherConfig.attributeSvgD;
+            if (branch.elements && branch.elements.length) {
+                branch.nodeOtherConfig.attributeSvgD = `M ${leftLine2} ${coord1.my} L ${coord1.lx} ${coord1.my}`;
+            }
+            branch.nodeOtherConfig.specific_x = endXToWait;
+            branch.nodeOtherConfig.specific_y = coord1.my;
+            // Đảm bảo có kích thước để setTranslatePositions tính offset đúng
+            if (!branch.nodeOtherConfig.specific_height) {
+                branch.nodeOtherConfig.specific_height = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;
+            }
+            if (!branch.nodeOtherConfig.specific_width) {
+                branch.nodeOtherConfig.specific_width = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;
+            }
+        }
+        branch.specific_start_branch_x = left + lineFormElementToBranching + canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;
+        branch.specific_start_branch_y = top;
+        if (!branch.elements || !branch.elements.length)
+            return;
+        const widthToElement = canvasConfigReadonly().ELEMENT_HEIGHT_CURVE + this.getHorizontalDistanceToFirstBlock(branch);
+        branch.elements.forEach((el) => {
+            el.specific_x = left + lineFormElementToBranching + widthToElement;
+            el.specific_y = top - (el.specific_height ?? 0) / 2;
+        });
+        MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(branch.elements, config);
+    }
+    /** Nhánh phía trên (above): rẽ lên, rồi bẻ phải đến element */
+    static aboveLine(top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, element, config) {
+        branch.onTheSide = 'above';
+        const { coordQL2, isCheckAllElementConnectToExit } = this.drawAboveUnderLine(top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, 'above', config);
+        branch.specific_start_branch_x = coordQL2.x;
+        branch.specific_start_branch_y = coordQL2.y;
+        if (!branch.elements || !branch.elements.length)
+            return;
+        this.drawElementInBranchLine(branch, coordQL2, config);
+        if (isCheckAllElementConnectToExit)
+            return;
+    }
+    /** Nhánh phía dưới (under): rẽ xuống, rồi bẻ phải đến element */
+    static underLine(top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, element, config) {
+        branch.onTheSide = 'under';
+        const { coordQL1, coordQL2, isCheckAllElementConnectToExit } = this.drawAboveUnderLine(top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, 'under', config);
+        branch.specific_start_branch_x = coordQL2.x;
+        branch.specific_start_branch_y = coordQL2.y;
+        // Mở rộng widthSvg nếu nhánh xuống vượt
+        const maxY = (coordQL1.y ?? 0) + 200;
+        const configSvg = config.widthHeightSvgCanvas;
+        configSvg.heightSvg = maxY > configSvg.heightSvg ? maxY : configSvg.heightSvg;
+        if (!branch.elements || !branch.elements.length)
+            return;
+        this.drawElementInBranchLine(branch, coordQL2, config);
+        if (isCheckAllElementConnectToExit)
+            return;
+    }
+    // ────────────────────────────────────────────────────────────────── private ──
+    /** Đặt element đầu tiên trong nhánh dựa theo tọa độ cuối của QL2 */
+    static drawElementInBranchLine(branch, coordQL2, config) {
+        const elementFirst = branch.elements[0];
+        // lx = X bắt đầu của element; ly = Y tâm nhánh → specific_y = tâm - half height
+        elementFirst.specific_x = coordQL2.lx;
+        elementFirst.specific_y = (coordQL2.ly ?? 0) - (elementFirst.specific_height ?? 0) / 2;
+        MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(branch.elements, config);
+    }
+    /**
+     * Vẽ đường rẽ nhánh kiểu horizontal:
+     *
+     *   M left top          → bắt đầu tại tâm Y của element cha
+     *   L Lx   top          → kéo NGANG sang phải đến điểm rẽ  (Lx = left + lineFormElementToBranching - CURVE)
+     *
+     *   QL1: bẻ từ hướng → sang hướng ↑ (above) hoặc ↓ (under)
+     *     M (Lx, top)
+     *     Q (Lx+C, top)  →  (Lx+C, top±C)       control đi thẳng phải, điểm kết bắt đầu đi dọc
+     *     L  Lx+C, top±C±straight               kéo thẳng dọc (lên/xuống)
+     *
+     *   QL2: bẻ ngược lại → hướng ngang để tới element
+     *     Q (Lx+C, top±C±straight±C)  →  (Lx+2C, top±C±straight±C)
+     *                                   control đi tiếp dọc, điểm kết đi ngang (phải)
+     *     L  Lx+2C+distToFirst, same_Y   kéo ngang đến vị trí element đầu tiên
+     *
+     *   Sau QL2:
+     *     coordQL2.lx  = X bắt đầu của element đầu tiên
+     *     coordQL2.ly  = Y tâm của nhánh
+     */
+    static drawAboveUnderLine(top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, direction, config) {
+        const CURVE = canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;
+        const M = `M ${left} ${top}`;
+        const Lx = left + lineFormElementToBranching - CURVE;
+        const L = `L ${Lx} ${top}`;
+        const straight = lineBetweenBranch - CURVE * 2; // đoạn thẳng dọc (bỏ 2 cong đầu-cuối)
+        // ── QL1: curve từ hướng ngang → hướng dọc (lên/xuống), rồi thẳng dọc ────
+        const coordQL1 = {
+            mx: Lx,
+            my: top,
+            x1: Lx + CURVE, // control: đi thẳng phải thêm CURVE
+            y1: top, // control: cùng Y
+            x: Lx + CURVE, // end X: giữ nguyên (= Lx+CURVE)
+            y: this.mathOp(direction, top, CURVE, true),
+            //   'above': top - CURVE  (bắt đầu đi lên)
+            //   'under': top + CURVE  (bắt đầu đi xuống)
+        };
+        // Đoạn L sau QL1: giữ nguyên X, tiếp tục đi dọc
+        coordQL1.lx = coordQL1.x; // X không đổi
+        coordQL1.ly = this.mathOp(direction, coordQL1.y, straight, true); // tiếp tục lên/xuống
+        const QL1 = `M ${coordQL1.mx},${coordQL1.my} Q ${coordQL1.x1},${coordQL1.y1} ${coordQL1.x},${coordQL1.y} L ${coordQL1.lx} ${coordQL1.ly}`;
+        // ── QL2: curve từ hướng dọc → hướng ngang (phải), rồi thẳng ngang đến element ──
+        const coordQL2 = {
+            // control: tiếp tục đi dọc thêm CURVE từ điểm cuối QL1
+            x1: coordQL1.lx,
+            y1: this.mathOp(direction, coordQL1.ly, CURVE, true),
+            // end: rẽ ngang sang phải thêm CURVE, giữ nguyên Y tại y1
+            y: this.mathOp(direction, coordQL1.ly, CURVE, true),
+            x: (coordQL1.lx ?? 0) + CURVE,
+        };
+        // Đoạn L sau QL2: đi ngang (phải) đến vị trí element đầu tiên trong nhánh
+        const distToFirst = this.getHorizontalDistanceToFirstBlock(branch);
+        if (!branch.elements || !branch.elements.length) {
+            coordQL2.lx = (coordQL2.x ?? 0) + distToFirst + maxWidthBranch;
+        }
+        else {
+            coordQL2.lx = (coordQL2.x ?? 0) + distToFirst;
+        }
+        coordQL2.ly = coordQL2.y; // Y không đổi → tâm Y của nhánh
+        // Xử lý nodeOtherConfig (wait block) trên nhánh
+        let QL2 = `Q ${coordQL2.x1},${coordQL2.y1} ${coordQL2.x},${coordQL2.y} L ${coordQL2.lx} ${coordQL2.ly}`;
+        if (branch.nodeOtherConfig) {
+            const distToWait = 110;
+            const endXToWait = (coordQL2.x ?? 0) + distToWait;
+            const waitWidth = getHeightWaitConfig(branch.nodeOtherConfig);
+            const leftLine2 = endXToWait + waitWidth;
+            delete branch.nodeOtherConfig.attributeSvgD;
+            QL2 = `Q ${coordQL2.x1},${coordQL2.y1} ${coordQL2.x},${coordQL2.y} M ${coordQL2.x},${coordQL2.y} L ${endXToWait},${coordQL2.y}`;
+            if (branch.elements && branch.elements.length) {
+                branch.nodeOtherConfig.attributeSvgD = `M ${leftLine2} ${coordQL2.y} L ${coordQL2.lx} ${coordQL2.ly}`;
+            }
+            branch.nodeOtherConfig.specific_x = endXToWait;
+            // specific_y = tâm Y của nhánh — setTranslatePositions sẽ trừ height/2 khi set translateY
+            branch.nodeOtherConfig.specific_y = coordQL2.y ?? 0;
+            // Đảm bảo có kích thước để setTranslatePositions tính offset đúng
+            if (!branch.nodeOtherConfig.specific_height) {
+                branch.nodeOtherConfig.specific_height = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;
+            }
+            if (!branch.nodeOtherConfig.specific_width) {
+                branch.nodeOtherConfig.specific_width = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;
+            }
+        }
+        branch.attributeSvgD = `${M} ${L} ${QL1} ${QL2}`;
+        const isCheckAllElementConnectToExit = this.checkChildrenConnectToExit(branch.elements);
+        branch.positionMaxTop = coordQL2.y;
+        checkMaxTop(config, branch.nodeOtherConfig?.specific_y, branch.positionMaxTop);
+        return { coordQL1, coordQL2, isCheckAllElementConnectToExit };
+    }
+    static checkChildrenConnectToExit(elements) {
+        let toExit = false;
+        if (elements.length &&
+            (elements[elements.length - 1].subCodeOfElement || elements[elements.length - 1].code) === canvasConfigReadonly().TYPE_ELEMENT_EXIT) {
+            return true;
+        }
+        elements.forEach((element) => {
+            if (!element.branches || !element.branches.length)
+                return;
+            let branchConnectToExit = 0;
+            element.branches.forEach((branch) => {
+                if (this.checkChildrenConnectToExit(branch.elements))
+                    branchConnectToExit++;
+            });
+            if (branchConnectToExit === element.branches.length)
+                toExit = true;
+        });
+        return toExit;
+    }
+    /**
+     * Quy ước:
+     *   above + opposite=true → a - b  (đi lên, y giảm)
+     *   above + opposite=false → a + b
+     *   under + opposite=true → a + b  (đi xuống, y tăng)
+     *   under + opposite=false → a - b
+     */
+    static mathOp(direction, a, b, opposite) {
+        const av = a ?? 0;
+        const bv = b ?? 0;
+        switch (direction) {
+            case 'above':
+                return opposite ? av - bv : av + bv;
+            case 'under':
+                return opposite ? av + bv : av - bv;
+            default:
+                return av - bv;
+        }
+    }
+    /** Alias để tương thích với code cũ gọi mathOperatorsCalculation */
+    static mathOperatorsCalculation(direction, a, b, opposite) {
+        return this.mathOp(direction, a, b, opposite);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculator-branch.util.js","sourceRoot":"","sources":["../../../../../../../libs-ui/services/diagram-draw/src/utils/horizontal/calculator-branch.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { canvasConfigReadonly } from '../../diagram-draw.service';\nimport { ICoordinatesDiagramSvg, IDataDiagramConfigSvg } from '../../interfaces/coordinates.interface';\nimport { checkMaxTop } from '../calculator-element.util';\nimport { IDiagramElement, IDiagramElementBranch } from '../../interfaces/diagram.interface';\nimport { getDistanceFromBranchToFirstBlock, getHeightWaitConfig } from '../calculator-element.util';\nimport { MoLibDiagramHorizontalCalculatorCoordinatesUtil } from './calculator-coordinates.util';\n\n/**\n * Horizontal branch calculator.\n * Flow direction: LEFT → RIGHT (trái sang phải).\n * Branches spread:  above = UP (y giảm),  under = DOWN (y tăng).\n *\n * Mapping từ trục dọc sang ngang:\n *   vertical \"left\"  branch (x giảm) ↔ horizontal \"above\" branch (y giảm)\n *   vertical \"right\" branch (x tăng) ↔ horizontal \"under\" branch  (y tăng)\n *\n * Ký hiệu trong ICoordinatesDiagramSvg:\n *   (mx,my) = điểm bắt đầu Q curve\n *   (x1,y1) = control point\n *   (x,y)   = end point của Q curve\n *   (lx,ly) = điểm cuối của L sau Q\n */\nexport class MoLibDiagramHorizontalCalculatorBranchUtil {\n  private static getHorizontalDistanceToFirstBlock(branch: IDiagramElementBranch) {\n    if (branch.nodeOtherConfig) {\n      const distToWait = 110; // increase statically since branch label is always assigned later\n      return distToWait + getHeightWaitConfig(branch.nodeOtherConfig) + canvasConfigReadonly().WAIT_TO_ELEMENT;\n    }\n    return canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT_BRANCH_TO_ELEMENT_FIRST;\n  }\n\n  // ─────────────────────────────────────────────────────────────────── public ──\n\n  /** Nhánh giữa (center): kéo thẳng sang phải */\n  static drawStraightLine(\n    top: number,                          // Y tâm của element cha\n    lineFormElementToBranching: number,   // width element + margin đến điểm rẽ\n    left: number,                         // X trái của element cha\n    branch: IDiagramElementBranch,\n    maxWidthBranch: number,\n    config: IDataDiagramConfigSvg\n  ) {\n    branch.onTheSide = 'center';\n    const startDraw = left + lineFormElementToBranching;\n    let Lx = startDraw;\n\n    Lx += canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;\n    Lx += this.getHorizontalDistanceToFirstBlock(branch);\n    if (!branch.elements || !branch.elements.length) {\n      Lx += maxWidthBranch + 20;\n    }\n\n    const coord1 = { mx: left, my: top, lx: Lx, ly: top };\n\n    branch.attributeSvgD = `M ${coord1.mx} ${coord1.my} L ${coord1.lx} ${coord1.ly}`;\n\n    if (branch.nodeOtherConfig) {\n      const distToWait = 110;\n      const endXToWait = startDraw + canvasConfigReadonly().ELEMENT_HEIGHT_CURVE + distToWait;\n\n      branch.attributeSvgD = `M ${coord1.mx} ${coord1.my} L ${endXToWait} ${coord1.my}`;\n      const waitWidth  = getHeightWaitConfig(branch.nodeOtherConfig);\n      const leftLine2  = endXToWait + waitWidth;\n\n      delete branch.nodeOtherConfig.attributeSvgD;\n      if (branch.elements && branch.elements.length) {\n        branch.nodeOtherConfig.attributeSvgD = `M ${leftLine2} ${coord1.my} L ${coord1.lx} ${coord1.my}`;\n      }\n      branch.nodeOtherConfig.specific_x = endXToWait;\n      branch.nodeOtherConfig.specific_y = coord1.my;\n      // Đảm bảo có kích thước để setTranslatePositions tính offset đúng\n      if (!branch.nodeOtherConfig.specific_height) {\n        branch.nodeOtherConfig.specific_height = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;\n      }\n      if (!branch.nodeOtherConfig.specific_width) {\n        branch.nodeOtherConfig.specific_width = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;\n      }\n    }\n\n    branch.specific_start_branch_x = left + lineFormElementToBranching + canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;\n    branch.specific_start_branch_y = top;\n\n    if (!branch.elements || !branch.elements.length) return;\n\n    const widthToElement = canvasConfigReadonly().ELEMENT_HEIGHT_CURVE + this.getHorizontalDistanceToFirstBlock(branch);\n\n    branch.elements.forEach((el) => {\n      el.specific_x = left + lineFormElementToBranching + widthToElement;\n      el.specific_y = top - (el.specific_height ?? 0) / 2;\n    });\n    MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(branch.elements, config);\n  }\n\n  /** Nhánh phía trên (above): rẽ lên, rồi bẻ phải đến element */\n  static aboveLine(\n    top: number,\n    lineFormElementToBranching: number,\n    left: number,\n    lineBetweenBranch: number,\n    branch: IDiagramElementBranch,\n    maxWidthBranch: number,\n    element: IDiagramElement,\n    config: IDataDiagramConfigSvg\n  ) {\n    branch.onTheSide = 'above';\n    const { coordQL2, isCheckAllElementConnectToExit } = this.drawAboveUnderLine(\n      top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, 'above', config\n    );\n\n    branch.specific_start_branch_x = coordQL2.x;\n    branch.specific_start_branch_y = coordQL2.y;\n\n    if (!branch.elements || !branch.elements.length) return;\n    this.drawElementInBranchLine(branch, coordQL2, config);\n    if (isCheckAllElementConnectToExit) return;\n  }\n\n  /** Nhánh phía dưới (under): rẽ xuống, rồi bẻ phải đến element */\n  static underLine(\n    top: number,\n    lineFormElementToBranching: number,\n    left: number,\n    lineBetweenBranch: number,\n    branch: IDiagramElementBranch,\n    maxWidthBranch: number,\n    element: IDiagramElement,\n    config: IDataDiagramConfigSvg\n  ) {\n    branch.onTheSide = 'under';\n    const { coordQL1, coordQL2, isCheckAllElementConnectToExit } = this.drawAboveUnderLine(\n      top, lineFormElementToBranching, left, lineBetweenBranch, branch, maxWidthBranch, 'under', config\n    );\n\n    branch.specific_start_branch_x = coordQL2.x;\n    branch.specific_start_branch_y = coordQL2.y;\n\n    // Mở rộng widthSvg nếu nhánh xuống vượt\n    const maxY = (coordQL1.y ?? 0) + 200;\n    const configSvg = config.widthHeightSvgCanvas;\n\n    configSvg.heightSvg = maxY > configSvg.heightSvg ? maxY : configSvg.heightSvg;\n\n    if (!branch.elements || !branch.elements.length) return;\n    this.drawElementInBranchLine(branch, coordQL2, config);\n    if (isCheckAllElementConnectToExit) return;\n  }\n\n  // ────────────────────────────────────────────────────────────────── private ──\n\n  /** Đặt element đầu tiên trong nhánh dựa theo tọa độ cuối của QL2 */\n  static drawElementInBranchLine(branch: IDiagramElementBranch, coordQL2: ICoordinatesDiagramSvg, config: IDataDiagramConfigSvg) {\n    const elementFirst = branch.elements[0];\n\n    // lx = X bắt đầu của element; ly = Y tâm nhánh → specific_y = tâm - half height\n    elementFirst.specific_x = coordQL2.lx;\n    elementFirst.specific_y = (coordQL2.ly ?? 0) - (elementFirst.specific_height ?? 0) / 2;\n    MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(branch.elements, config);\n  }\n\n  /**\n   * Vẽ đường rẽ nhánh kiểu horizontal:\n   *\n   *   M left top          → bắt đầu tại tâm Y của element cha\n   *   L Lx   top          → kéo NGANG sang phải đến điểm rẽ  (Lx = left + lineFormElementToBranching - CURVE)\n   *\n   *   QL1: bẻ từ hướng → sang hướng ↑ (above) hoặc ↓ (under)\n   *     M (Lx, top)\n   *     Q (Lx+C, top)  →  (Lx+C, top±C)       control đi thẳng phải, điểm kết bắt đầu đi dọc\n   *     L  Lx+C, top±C±straight               kéo thẳng dọc (lên/xuống)\n   *\n   *   QL2: bẻ ngược lại → hướng ngang để tới element\n   *     Q (Lx+C, top±C±straight±C)  →  (Lx+2C, top±C±straight±C)\n   *                                   control đi tiếp dọc, điểm kết đi ngang (phải)\n   *     L  Lx+2C+distToFirst, same_Y   kéo ngang đến vị trí element đầu tiên\n   *\n   *   Sau QL2:\n   *     coordQL2.lx  = X bắt đầu của element đầu tiên\n   *     coordQL2.ly  = Y tâm của nhánh\n   */\n  static drawAboveUnderLine(\n    top: number,\n    lineFormElementToBranching: number,\n    left: number,\n    lineBetweenBranch: number,\n    branch: IDiagramElementBranch,\n    maxWidthBranch: number,\n    direction: 'above' | 'under',\n    config: IDataDiagramConfigSvg\n  ) {\n    const CURVE  = canvasConfigReadonly().ELEMENT_HEIGHT_CURVE;\n    const M      = `M ${left} ${top}`;\n    const Lx     = left + lineFormElementToBranching - CURVE;\n    const L      = `L ${Lx} ${top}`;\n    const straight = lineBetweenBranch - CURVE * 2; // đoạn thẳng dọc (bỏ 2 cong đầu-cuối)\n\n    // ── QL1: curve từ hướng ngang → hướng dọc (lên/xuống), rồi thẳng dọc ────\n    const coordQL1: ICoordinatesDiagramSvg = {\n      mx: Lx,\n      my: top,\n      x1: Lx + CURVE,          // control: đi thẳng phải thêm CURVE\n      y1: top,                  // control: cùng Y\n      x:  Lx + CURVE,          // end X: giữ nguyên (= Lx+CURVE)\n      y:  this.mathOp(direction, top, CURVE, true),\n      //   'above': top - CURVE  (bắt đầu đi lên)\n      //   'under': top + CURVE  (bắt đầu đi xuống)\n    };\n    // Đoạn L sau QL1: giữ nguyên X, tiếp tục đi dọc\n    coordQL1.lx = coordQL1.x;                                         // X không đổi\n    coordQL1.ly = this.mathOp(direction, coordQL1.y, straight, true); // tiếp tục lên/xuống\n\n    const QL1 = `M ${coordQL1.mx},${coordQL1.my} Q ${coordQL1.x1},${coordQL1.y1} ${coordQL1.x},${coordQL1.y} L ${coordQL1.lx} ${coordQL1.ly}`;\n\n    // ── QL2: curve từ hướng dọc → hướng ngang (phải), rồi thẳng ngang đến element ──\n    const coordQL2: ICoordinatesDiagramSvg = {\n      // control: tiếp tục đi dọc thêm CURVE từ điểm cuối QL1\n      x1: coordQL1.lx,\n      y1: this.mathOp(direction, coordQL1.ly, CURVE, true),\n      // end: rẽ ngang sang phải thêm CURVE, giữ nguyên Y tại y1\n      y:  this.mathOp(direction, coordQL1.ly, CURVE, true),\n      x:  (coordQL1.lx ?? 0) + CURVE,\n    };\n\n    // Đoạn L sau QL2: đi ngang (phải) đến vị trí element đầu tiên trong nhánh\n    const distToFirst = this.getHorizontalDistanceToFirstBlock(branch);\n\n    if (!branch.elements || !branch.elements.length) {\n      coordQL2.lx = (coordQL2.x ?? 0) + distToFirst + maxWidthBranch;\n    } else {\n      coordQL2.lx = (coordQL2.x ?? 0) + distToFirst;\n    }\n    coordQL2.ly = coordQL2.y; // Y không đổi → tâm Y của nhánh\n\n    // Xử lý nodeOtherConfig (wait block) trên nhánh\n    let QL2 = `Q ${coordQL2.x1},${coordQL2.y1} ${coordQL2.x},${coordQL2.y} L ${coordQL2.lx} ${coordQL2.ly}`;\n\n    if (branch.nodeOtherConfig) {\n      const distToWait = 110;\n      const endXToWait = (coordQL2.x ?? 0) + distToWait;\n      const waitWidth  = getHeightWaitConfig(branch.nodeOtherConfig);\n      const leftLine2  = endXToWait + waitWidth;\n\n      delete branch.nodeOtherConfig.attributeSvgD;\n      QL2 = `Q ${coordQL2.x1},${coordQL2.y1} ${coordQL2.x},${coordQL2.y} M ${coordQL2.x},${coordQL2.y} L ${endXToWait},${coordQL2.y}`;\n      if (branch.elements && branch.elements.length) {\n        branch.nodeOtherConfig.attributeSvgD = `M ${leftLine2} ${coordQL2.y} L ${coordQL2.lx} ${coordQL2.ly}`;\n      }\n      branch.nodeOtherConfig.specific_x = endXToWait;\n      // specific_y = tâm Y của nhánh — setTranslatePositions sẽ trừ height/2 khi set translateY\n      branch.nodeOtherConfig.specific_y = coordQL2.y ?? 0;\n      // Đảm bảo có kích thước để setTranslatePositions tính offset đúng\n      if (!branch.nodeOtherConfig.specific_height) {\n        branch.nodeOtherConfig.specific_height = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;\n      }\n      if (!branch.nodeOtherConfig.specific_width) {\n        branch.nodeOtherConfig.specific_width = canvasConfigReadonly().ELEMENT_WAIT_DEFAULT;\n      }\n    }\n\n    branch.attributeSvgD = `${M} ${L} ${QL1} ${QL2}`;\n    const isCheckAllElementConnectToExit = this.checkChildrenConnectToExit(branch.elements);\n\n    branch.positionMaxTop = coordQL2.y;\n    checkMaxTop(config, branch.nodeOtherConfig?.specific_y, branch.positionMaxTop);\n\n    return { coordQL1, coordQL2, isCheckAllElementConnectToExit };\n  }\n\n  static checkChildrenConnectToExit(elements: IDiagramElement[]): boolean {\n    let toExit = false;\n\n    if (\n      elements.length &&\n      (elements[elements.length - 1].subCodeOfElement || elements[elements.length - 1].code) === canvasConfigReadonly().TYPE_ELEMENT_EXIT\n    ) {\n      return true;\n    }\n    elements.forEach((element) => {\n      if (!element.branches || !element.branches.length) return;\n      let branchConnectToExit = 0;\n\n      element.branches.forEach((branch) => {\n        if (this.checkChildrenConnectToExit(branch.elements)) branchConnectToExit++;\n      });\n      if (branchConnectToExit === element.branches.length) toExit = true;\n    });\n\n    return toExit;\n  }\n\n  /**\n   * Quy ước:\n   *   above + opposite=true → a - b  (đi lên, y giảm)\n   *   above + opposite=false → a + b\n   *   under + opposite=true → a + b  (đi xuống, y tăng)\n   *   under + opposite=false → a - b\n   */\n  static mathOp(direction: 'above' | 'under' | string, a: number | undefined, b: number | undefined, opposite?: boolean): number {\n    const av = a ?? 0;\n    const bv = b ?? 0;\n\n    switch (direction) {\n      case 'above':\n        return opposite ? av - bv : av + bv;\n      case 'under':\n        return opposite ? av + bv : av - bv;\n      default:\n        return av - bv;\n    }\n  }\n\n  /** Alias để tương thích với code cũ gọi mathOperatorsCalculation */\n  static mathOperatorsCalculation(direction: 'above' | 'under' | string, a: number | undefined, b: number | undefined, opposite?: boolean): number {\n    return this.mathOp(direction, a, b, opposite);\n  }\n}\n"]}