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

package/esm2022/diagram-draw.service.mjs

@@ -0,0 +1,711 @@
+import { Injectable, signal } from '@angular/core';
+import { setStylesElement } from '@libs-ui/utils';
+import { MoLibDiagramCalculatorCoordinatesUtil } from './utils/calculator-element.util';
+import { applyElementStyle, setAttributeSvgAndAppend } from './utils/diagram.util';
+import { MoLibDiagramHorizontalCalculatorCoordinatesUtil } from './utils/horizontal/calculator-coordinates.util';
+import * as i0 from "@angular/core";
+const canvasConfig = signal({
+    ELEMENT_WIDTH_DEFAULT_BRANCH_WHEN_NOT_ELEMENT: 60,
+    ELEMENT_MARGIN_DEFAULT: 60,
+    ELEMENT_MARGIN_DEFAULT_BRANCH: 16,
+    ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT: 60,
+    DEFAULT_BRANCH_WHEN_NO_ELEMENT: 100,
+    ELEMENT_HEIGHT_CURVE: 10,
+    ELEMENT_SVG_STROKE_COLOR: '9ca2ad',
+    ELEMENT_SVG_STROKE_WIDTH: '1',
+    ELEMENT_MARGIN_DEFAULT_BRANCH_TO_ELEMENT_FIRST: 78,
+    DISTANCE_TO_WAIT: 30,
+    WAIT_TO_ELEMENT: 50,
+    ELEMENT_WAIT_DEFAULT: 28,
+    DISTANCE_WAIT_TO_NEXT_LINE: 4,
+    TYPE_ELEMENT_EXIT: 'EXIT',
+    TYPE_ELEMENT_WORKFLOW: 'WORKFLOW',
+    WIDTH_ELEMENT_DEFAULT: 165,
+    HEIGHT_ELEMENT_DEFAULT: 48,
+    ADD_ICON_DIAMETER: 24,
+});
+export const canvasConfigReadonly = canvasConfig.asReadonly();
+export const storeDataDefault = {
+    positionMaxLeft: 0,
+    positionMaxTop: 0,
+    widthHeightSvgCanvas: { heightSvg: window.innerHeight, widthSvg: window.innerWidth },
+};
+export class LibsUiDiagramDrawService {
+    configCanvas = signal(undefined);
+    orientation = signal('vertical');
+    elementSvg = signal(undefined);
+    attributeSvgD = signal('');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    componentRefs = signal([]);
+    // Virtualization Tracking
+    virtualViewport;
+    virtualFlatElements = [];
+    virtualFlatBranches = [];
+    virtualNodesMap = new Map();
+    updateViewport(vp) {
+        this.virtualViewport = vp;
+        if (this.configCanvas()?.useVirtualizationTemplate) {
+            this.applyVirtualizationDiff();
+        }
+    }
+    set setConfig(config) {
+        this.configCanvas.set(config);
+    }
+    set setConfigCanvas(config) {
+        if (!config) {
+            return;
+        }
+        canvasConfig.update((current) => ({ ...current, ...config }));
+    }
+    configXYElements(elements, updateSVG, positionX) {
+        const storeData = this.configCanvas()?.storeDataDefine ?? storeDataDefault;
+        const maxLeftOrigin = storeData.positionMaxLeft;
+        const maxTopOrigin = storeData.positionMaxTop ?? 0;
+        if (this.orientation() === 'horizontal') {
+            MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(elements, storeData, positionX);
+        }
+        else {
+            MoLibDiagramCalculatorCoordinatesUtil.setXYElements(elements, storeData, positionX);
+        }
+        const maxLeftNew = storeData.positionMaxLeft;
+        const maxTopNew = storeData.positionMaxTop ?? 0;
+        if (!this.elementSvg()) {
+            this.elementSvg.set(document.createElementNS('http://www.w3.org/2000/svg', 'path'));
+        }
+        if (!updateSVG && this.configCanvas()?.svgContainer && this.elementSvg()) {
+            setAttributeSvgAndAppend(this.configCanvas()?.svgContainer, this.elementSvg(), '');
+        }
+        if (this.orientation() === 'horizontal' && maxTopOrigin !== maxTopNew) {
+            this.updatePositionElements(maxTopNew, elements, storeData);
+            return;
+        }
+        if (this.orientation() === 'vertical' && maxLeftOrigin !== maxLeftNew) {
+            this.updatePositionElements(maxLeftNew, elements, storeData);
+            return;
+        }
+        if (this.elementSvg()) {
+            this.attributeSvgD.set('');
+            this.buildSvgElement(elements);
+            this.elementSvg()?.setAttribute('d', this.attributeSvgD());
+        }
+    }
+    updatePositionElements(positionOffset, elements, config) {
+        if (positionOffset && positionOffset < 0) {
+            positionOffset = positionOffset * -1 + 200; // 100 là khoảng cách cách biên
+        }
+        if (this.orientation() === 'horizontal') {
+            MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(elements, { ...config, updateSVG: true }, positionOffset);
+        }
+        else {
+            MoLibDiagramCalculatorCoordinatesUtil.setXYElements(elements, { ...config, updateSVG: true }, positionOffset);
+        }
+        if (!this.elementSvg()) {
+            this.elementSvg.set(document.createElementNS('http://www.w3.org/2000/svg', 'path'));
+        }
+        if (this.elementSvg()) {
+            this.attributeSvgD.set('');
+            this.buildSvgElement(elements);
+            this.elementSvg()?.setAttribute('d', this.attributeSvgD());
+        }
+    }
+    buildSvgElement(elements) {
+        elements.forEach((currentElement) => {
+            if (currentElement.attributeSvgD) {
+                this.attributeSvgD.update((prev) => `${prev ?? ''} ${currentElement.attributeSvgD}`);
+            }
+            if (currentElement.nodeOtherConfig?.attributeSvgD) {
+                this.attributeSvgD.update((prev) => `${prev ?? ''} ${currentElement.nodeOtherConfig?.attributeSvgD}`);
+            }
+            if (!currentElement.branches || !currentElement.branches.length) {
+                return;
+            }
+            currentElement.branches.forEach((branch) => {
+                if (branch.attributeSvgD) {
+                    this.attributeSvgD.update((prev) => `${prev ?? ''} ${branch.attributeSvgD}`);
+                }
+                if (branch.nodeOtherConfig?.attributeSvgD) {
+                    this.attributeSvgD.update((prev) => `${prev ?? ''} ${branch.nodeOtherConfig?.attributeSvgD}`);
+                }
+                if (!branch.elements.length) {
+                    return;
+                }
+                this.buildSvgElement(branch.elements);
+            });
+        });
+    }
+    /**
+     * Render tất cả nodes từ elements array
+     */
+    renderNodes(elements) {
+        if (this.configCanvas()?.useVirtualizationTemplate) {
+            this.extractVirtualElements(elements);
+            this.applyVirtualizationDiff();
+            return;
+        }
+        this.clearNodes();
+        this.renderElementsRecursively(elements, true, undefined);
+        this.renderBranchLabels(elements);
+    }
+    extractVirtualElements(elements) {
+        this.virtualFlatElements = [];
+        this.virtualFlatBranches = [];
+        const scan = (list, branch, isFirstLevel = true) => {
+            list.forEach((el, index) => {
+                const shouldShowArrow = !(isFirstLevel && index === 0);
+                this.virtualFlatElements.push({ element: el, branch, isOtherConfig: false, shouldShowArrow, parentId: el.id });
+                if (el.nodeOtherConfig)
+                    this.virtualFlatElements.push({ element: el.nodeOtherConfig, branch, isOtherConfig: true, shouldShowArrow: false, parentId: el.id });
+                if (el.branches) {
+                    el.branches.forEach((b, bIndex) => {
+                        if (!b.label)
+                            b.label = `Nhánh ${bIndex + 1}`;
+                        this.virtualFlatBranches.push(b);
+                        if (b.elements)
+                            scan(b.elements, b, false);
+                        if (b.nodeOtherConfig)
+                            this.virtualFlatElements.push({ element: b.nodeOtherConfig, branch: b, isOtherConfig: true, shouldShowArrow: false, parentId: 'branch_' + bIndex + '_' + el.id });
+                    });
+                }
+            });
+        };
+        scan(elements, undefined, true);
+    }
+    applyVirtualizationDiff() {
+        const vp = this.virtualViewport;
+        if (!vp)
+            return;
+        const config = this.configCanvas();
+        const container = config?.nodesContainer?.nativeElement;
+        if (!container || !config)
+            return;
+        const buffer = 300;
+        const visibleIds = new Set();
+        this.virtualFlatElements.forEach((item) => {
+            const el = item.element;
+            if (el.translateX === undefined || el.translateY === undefined)
+                return;
+            if (el.translateX + (el.specific_width || 165) < vp.x - buffer || el.translateX > vp.x + vp.width + buffer || el.translateY + (el.specific_height || 48) < vp.y - buffer || el.translateY > vp.y + vp.height + buffer)
+                return;
+            const id = String(item.parentId) + (item.isOtherConfig ? '_other' : '');
+            visibleIds.add(id);
+            if (!this.virtualNodesMap.has(id)) {
+                const componentType = item.isOtherConfig ? config.nodeOtherConfigComponentType : config.nodeComponentType;
+                if (componentType && config.viewContainerRef) {
+                    const ref = config.viewContainerRef.createComponent(componentType);
+                    ref.setInput('element', el);
+                    if (item.branch)
+                        ref.setInput('branch', item.branch);
+                    ref.setInput('orientation', this.orientation());
+                    const domEl = ref.location.nativeElement;
+                    domEl.classList.add('diagram-node-dynamic');
+                    applyElementStyle(domEl, el);
+                    container.appendChild(domEl);
+                    let arrow;
+                    if (item.shouldShowArrow && !item.isOtherConfig) {
+                        arrow = this.createArrowIndicator(el, container);
+                    }
+                    this.virtualNodesMap.set(id, { component: ref, arrow });
+                }
+            }
+            else {
+                const cache = this.virtualNodesMap.get(id);
+                if (cache) {
+                    if (cache.component)
+                        applyElementStyle(cache.component.location.nativeElement, el);
+                    if (cache.arrow) {
+                        const arrowSize = 16;
+                        const nodeWidth = el.specific_width ?? 165;
+                        const nodeHeight = el.specific_height ?? 48;
+                        if (this.orientation() === 'horizontal') {
+                            cache.arrow.innerHTML = `
+                 <svg width="${arrowSize}" height="${arrowSize}" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+                   <path d="M8 4L16 8L8 12Z" fill="#9ca3af"/>
+                 </svg>
+               `;
+                            cache.arrow.style.left = `${el.translateX - arrowSize}px`;
+                            cache.arrow.style.top = `${el.translateY + nodeHeight / 2 - arrowSize / 2}px`;
+                        }
+                        else {
+                            cache.arrow.innerHTML = `
+                 <svg width="${arrowSize}" height="${arrowSize}" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+                   <path d="M8 16L4 12H12L8 16Z" fill="#9ca3af"/>
+                 </svg>
+               `;
+                            cache.arrow.style.left = `${el.translateX + nodeWidth / 2 - arrowSize / 2}px`;
+                            cache.arrow.style.top = `${el.translateY - arrowSize}px`;
+                        }
+                    }
+                }
+            }
+        });
+        this.virtualFlatBranches.forEach((branch, index) => {
+            const x = branch.specific_start_branch_x;
+            const y = branch.specific_start_branch_y;
+            if (x === undefined || y === undefined)
+                return;
+            if (x < vp.x - buffer || x > vp.x + vp.width + buffer || y < vp.y - buffer || y > vp.y + vp.height + buffer)
+                return;
+            const id = 'branch_' + index + '_' + Math.round(x) + '_' + Math.round(y);
+            visibleIds.add(id);
+            if (!this.virtualNodesMap.has(id)) {
+                const labelDiv = this.createBranchLabel(branch);
+                if (labelDiv)
+                    this.virtualNodesMap.set(id, { label: labelDiv });
+            }
+            else {
+                const cache = this.virtualNodesMap.get(id);
+                if (cache?.label) {
+                    const labelDiv = cache.label;
+                    const labelRect = labelDiv.getBoundingClientRect();
+                    const labelW = labelRect.width || labelDiv.offsetWidth;
+                    const labelH = labelRect.height || labelDiv.offsetHeight;
+                    if (this.orientation() === 'vertical') {
+                        labelDiv.style.left = `${x - labelW / 2 - 4}px`;
+                        labelDiv.style.top = `${y - labelH / 2 + 4}px`;
+                    }
+                    else {
+                        labelDiv.style.left = `${x + 4}px`;
+                        labelDiv.style.top = `${y - labelH / 2}px`; // center over wire
+                    }
+                }
+            }
+        });
+        Array.from(this.virtualNodesMap.entries()).forEach(([id, cache]) => {
+            if (!visibleIds.has(id)) {
+                cache.component?.destroy();
+                cache.arrow?.remove();
+                cache.label?.remove();
+                this.virtualNodesMap.delete(id);
+            }
+        });
+    }
+    /**
+     * Render elements và branches một cách đệ quy
+     */
+    renderElementsRecursively(elements, isFirstLevel = true, branch) {
+        elements.forEach((element, index) => {
+            if (element.translateX !== undefined && element.translateY !== undefined) {
+                // Main node: có arrow nếu không phải element đầu tiên của level đầu
+                const shouldShowArrow = !(isFirstLevel && index === 0);
+                this.createNode(element, branch, shouldShowArrow, false);
+            }
+            // Render nodeOtherConfig nếu có (nodes phụ) - KHÔNG có arrow
+            if (element.nodeOtherConfig && element.nodeOtherConfig.translateX !== undefined && element.nodeOtherConfig.translateY !== undefined) {
+                this.createNode(element.nodeOtherConfig, branch, false, true);
+            }
+            // Render branches nếu có
+            if (element.branches && element.branches.length > 0) {
+                element.branches.forEach((branch) => {
+                    if (branch.elements && branch.elements.length > 0) {
+                        this.renderElementsRecursively(branch.elements, false, branch);
+                    }
+                    if (branch.nodeOtherConfig && branch.nodeOtherConfig.translateX !== undefined && branch.nodeOtherConfig.translateY !== undefined) {
+                        this.createNode(branch.nodeOtherConfig, branch, false, true);
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Tạo một node component động
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createNode(element, branch, shouldShowArrow, isNodeOtherConfig) {
+        const config = this.configCanvas();
+        if (!config?.viewContainerRef) {
+            return;
+        }
+        if (config.useVirtualizationTemplate) {
+            if (config.nodesContainer?.nativeElement) {
+                if (shouldShowArrow && !isNodeOtherConfig) {
+                    this.createArrowIndicator(element, config.nodesContainer.nativeElement);
+                }
+            }
+            return;
+        }
+        const componentType = isNodeOtherConfig ? config.nodeOtherConfigComponentType : config.nodeComponentType;
+        if (!componentType) {
+            return;
+        }
+        const componentRef = config.viewContainerRef.createComponent(componentType);
+        const el = componentRef.location.nativeElement;
+        componentRef.setInput('element', element);
+        if (branch) {
+            componentRef.setInput('branch', branch);
+        }
+        componentRef.setInput('orientation', this.orientation());
+        el.classList.add('diagram-node-dynamic');
+        applyElementStyle(el, element);
+        if (config.nodesContainer?.nativeElement) {
+            config.nodesContainer.nativeElement.appendChild(el);
+            if (shouldShowArrow && !isNodeOtherConfig) {
+                this.createArrowIndicator(element, config.nodesContainer.nativeElement);
+            }
+        }
+        this.componentRefs.update((refs) => [...refs, componentRef]); // Lưu reference để cleanup sau
+        return componentRef;
+    }
+    /**
+     * Clear tất cả nodes đã tạo
+     */
+    clearNodes() {
+        this.componentRefs().forEach((ref) => {
+            ref.destroy();
+        });
+        this.componentRefs.set([]);
+        Array.from(this.virtualNodesMap.values()).forEach((cache) => {
+            cache.component?.destroy();
+            cache.arrow?.remove();
+            cache.label?.remove();
+        });
+        this.virtualNodesMap.clear();
+        const config = this.configCanvas();
+        const nodesContainer = config?.nodesContainer?.nativeElement;
+        if (nodesContainer) {
+            if (!config?.useVirtualizationTemplate) {
+                const dynamicNodes = nodesContainer.querySelectorAll('.diagram-node-dynamic');
+                dynamicNodes.forEach((node) => node.remove());
+            }
+            const labels = nodesContainer.querySelectorAll('.branch-label');
+            labels.forEach((label) => label.remove());
+            const arrows = nodesContainer.querySelectorAll('.node-arrow-indicator');
+            arrows.forEach((arrow) => arrow.remove());
+        }
+    }
+    /**
+     * Tạo mũi tên indicator chỉ hướng vào node.
+     * - vertical:   mũi tên ▼ phía TRÊN node  (luồng trên → xuống)
+     * - horizontal: mũi tên ► phía TRÁI node  (luồng trái → phải)
+     */
+    createArrowIndicator(element, container) {
+        if (element.translateX === undefined || element.translateY === undefined) {
+            return undefined;
+        }
+        const arrow = document.createElement('div');
+        arrow.className = 'node-arrow-indicator';
+        arrow.style.position = 'absolute';
+        arrow.style.zIndex = '1';
+        arrow.style.pointerEvents = 'none';
+        const arrowSize = 16;
+        const nodeWidth = element.specific_width ?? 0;
+        const nodeHeight = element.specific_height ?? 0;
+        if (this.orientation() === 'horizontal') {
+            // Mũi tên ► ở bên TRÁI node, căn giữa theo chiều cao
+            arrow.innerHTML = `
+        <svg width="${arrowSize}" height="${arrowSize}" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+          <path d="M8 4L16 8L8 12Z" fill="#9ca3af"/>
+        </svg>
+      `;
+            arrow.style.left = `${element.translateX - arrowSize}px`;
+            arrow.style.top = `${element.translateY + nodeHeight / 2 - arrowSize / 2}px`;
+        }
+        else {
+            // Mũi tên ▼ ở phía TRÊN node, căn giữa theo chiều rộng
+            arrow.innerHTML = `
+        <svg width="${arrowSize}" height="${arrowSize}" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+          <path d="M8 16L4 12H12L8 16Z" fill="#9ca3af"/>
+        </svg>
+      `;
+            arrow.style.left = `${element.translateX + nodeWidth / 2 - arrowSize / 2}px`;
+            arrow.style.top = `${element.translateY - arrowSize}px`;
+        }
+        container.appendChild(arrow);
+        return arrow;
+    }
+    /**
+     * Render branch labels (text annotations on branches)
+     */
+    renderBranchLabels(elements) {
+        const svgContainer = this.configCanvas()?.svgContainer?.nativeElement;
+        if (!svgContainer) {
+            return;
+        }
+        elements.forEach((element) => {
+            if (element.branches && element.branches.length > 0) {
+                element.branches.forEach((branch, index) => {
+                    if (branch.specific_start_branch_x !== undefined && branch.specific_start_branch_y !== undefined) {
+                        if (!branch.label) {
+                            branch.label = `Nhánh ${index + 1}`;
+                        }
+                        this.createBranchLabel(branch);
+                    }
+                    if (branch.elements && branch.elements.length > 0) {
+                        this.renderBranchLabels(branch.elements);
+                    }
+                });
+            }
+        });
+    }
+    createBranchLabel(branch) {
+        const config = this.configCanvas();
+        const container = config?.nodesContainer?.nativeElement;
+        if (!container) {
+            return undefined;
+        }
+        const labelDiv = document.createElement('div');
+        labelDiv.className = 'branch-label';
+        labelDiv.textContent = branch.label || '';
+        labelDiv.style.position = 'absolute';
+        labelDiv.style.padding = '2px 7px';
+        labelDiv.style.borderRadius = '10px';
+        labelDiv.style.backgroundColor = branch.labelBgColor || '#f3f4f6';
+        labelDiv.style.fontSize = '11px';
+        labelDiv.style.fontFamily = 'system-ui, -apple-system, sans-serif';
+        labelDiv.style.color = '#374151';
+        labelDiv.style.whiteSpace = 'nowrap';
+        labelDiv.style.zIndex = '2';
+        labelDiv.style.pointerEvents = 'none';
+        container.appendChild(labelDiv);
+        const startX = branch.specific_start_branch_x ?? 0;
+        const startY = branch.specific_start_branch_y ?? 0;
+        const labelW = labelDiv.offsetWidth;
+        const labelH = labelDiv.offsetHeight || 18;
+        if (this.orientation() === 'horizontal') {
+            /**
+             * Horizontal: label nằm TRÊN đường line nằm ngang.
+             * specific_start_branch = điểm bắt đầu đoạn thẳng ngang đến element.
+             * Đặt label tịnh tiến sang phải 8px từ ngoặt nhánh, và căn giữa dây.
+             */
+            labelDiv.style.left = `${startX + 4}px`;
+            labelDiv.style.top = `${startY - labelH / 2}px`;
+        }
+        else {
+            /**
+             * Vertical: label nằm BÊN TRÁI đường ngang, căn giữa theo Y.
+             * specific_start_branch = điểm đầu đoạn thẳng đến element (sau curve).
+             */
+            labelDiv.style.left = `${startX - labelW / 2 - 4}px`;
+            labelDiv.style.top = `${startY - labelH / 2 + 4}px`;
+        }
+        return labelDiv;
+    }
+    /**
+     * Render dấu "+" tại mỗi vị trí có thể thả element từ sidebar.
+     * Service tự tạo DOM elements và inject vào nodesContainer.
+     * @param flatElements Danh sách flat elements đã tính toán vị trí
+     * @param onDrop Callback khi người dùng thả element vào một "+"
+     * @param canDropFn (tùy chọn) Function kiểm tra điều kiện hiển thị drop zone.
+     * ```
+     */
+    renderDropZones(flatElements, onDrop, canDropFn, ruleConnectableElements) {
+        this.clearDropZones();
+        const container = this.configCanvas()?.nodesContainer?.nativeElement;
+        if (!container)
+            return;
+        flatElements.forEach((el) => {
+            if (el.code === canvasConfigReadonly().TYPE_ELEMENT_EXIT)
+                return;
+            if (el.element_type === canvasConfigReadonly().TYPE_ELEMENT_WORKFLOW) {
+                el.branches?.forEach((branch) => {
+                    if (canDropFn(undefined, el, branch, ruleConnectableElements))
+                        return;
+                    const top = this.orientation() === 'horizontal' ? this.calcDropZoneTopBranchH(el, branch) : this.calcDropZoneTopBranch(el, branch);
+                    const left = this.orientation() === 'horizontal' ? this.calcDropZoneLeftBranchH(el, branch) : this.calcDropZoneLeftBranch(el, branch);
+                    this.createDropZoneEl(container, top, left, el, branch, onDrop);
+                });
+            }
+            else {
+                if (!canDropFn(undefined, el, undefined, ruleConnectableElements))
+                    return;
+                const top = this.orientation() === 'horizontal' ? this.calcDropZoneTopNodeH(el) : this.calcDropZoneTopNode(el);
+                const left = this.orientation() === 'horizontal' ? this.calcDropZoneLeftNodeH(el) : this.calcDropZoneLeftNode(el);
+                this.createDropZoneEl(container, top, left, el, undefined, onDrop);
+            }
+        });
+    }
+    /** Xóa tất cả drop zone "+" khỏi DOM */
+    clearDropZones() {
+        const container = this.configCanvas()?.nodesContainer?.nativeElement;
+        if (!container)
+            return;
+        container.querySelectorAll('.diagram-drop-zone').forEach((el) => el.remove());
+    }
+    createDropZoneEl(container, top, left, element, branch, onDrop) {
+        const indicatorStyle = this.configCanvas()?.dropZoneStyle;
+        const RECT_W = element.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT;
+        const RECT_H = element.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT;
+        // Tâm của nút tròn
+        const centerX = left + canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+        const centerY = top + canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+        // Hit zone vô hình: rộng hơn rectangle một khoản padding để bắt drag sớm hơn
+        const HIT_PAD = 20;
+        const HIT_W = RECT_W + HIT_PAD * 2;
+        const HIT_H = RECT_H + HIT_PAD * 2;
+        const hitLeft = centerX - HIT_W / 2;
+        const hitTop = centerY - HIT_H / 2;
+        // ── Hit zone (wrapper vô hình, vùng nhận drag rộng) ─────────────────
+        const hitZone = document.createElement('div');
+        hitZone.className = 'diagram-drop-zone';
+        hitZone.style.cssText = `
+      position: absolute;
+      top: ${hitTop}px;
+      left: ${hitLeft}px;
+      z-index: 9;
+      width: ${HIT_W}px;
+      height: ${HIT_H}px;
+      cursor: pointer;
+    `;
+        // ── Indicator (con bên trong, phần hiển thị) ─────────────────────────
+        const indicator = document.createElement('div');
+        indicator.style.pointerEvents = 'none'; // tránh tranh chấp event với hitZone
+        // Vị trí dot trong hitZone (căn giữa hitZone)
+        const dotOffsetLeft = HIT_W / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+        const dotOffsetTop = HIT_H / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+        // Vị trí rectangle trong hitZone (căn giữa hitZone)
+        const rectOffsetLeft = HIT_PAD;
+        const rectOffsetTop = HIT_H / 2 - RECT_H / 2;
+        const applyDotStyle = () => {
+            const s = indicatorStyle;
+            const size = canvasConfigReadonly().ADD_ICON_DIAMETER;
+            const bg = s?.backgroundColor ?? '#3b82f6';
+            const iconColor = s?.iconColor ?? '#ffffff';
+            const opacity = s?.opacity ?? 0.95;
+            const borderRadius = s?.borderRadius ?? '50%';
+            setStylesElement(indicator, {
+                position: 'absolute',
+                top: `${dotOffsetTop}px`,
+                left: `${dotOffsetLeft}px`,
+                width: `${size}px`,
+                height: `${size}px`,
+                pointerEvents: 'none',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                transition: 'opacity 0.15s ease',
+                border: 'none',
+            });
+            if (s?.renderIndicator) {
+                indicator.innerHTML = s.renderIndicator(size);
+            }
+            else {
+                indicator.innerHTML = `
+          <div style="
+            width: ${size}px;
+            height: ${size}px;
+            background-color: ${bg};
+            border-radius: ${borderRadius};
+            opacity: ${opacity};
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            pointer-events: none;
+          "><i class="libs-ui-icon-add before:text-[${iconColor}]"></i></div>
+        `;
+            }
+        };
+        const applyRectStyle = () => {
+            const s = indicatorStyle;
+            const hoverBg = s?.hoverBackgroundColor ?? '#eef4ff';
+            const hoverBorder = s?.hoverBorderColor ?? 'rgba(59, 130, 246, 0.7)';
+            const hoverBorderStyle = s?.hoverBorderStyle ?? 'dashed';
+            const hoverRadius = s?.hoverBorderRadius ?? 10;
+            setStylesElement(indicator, {
+                top: `${rectOffsetTop}px`,
+                left: `${rectOffsetLeft}px`,
+                width: `${RECT_W}px`,
+                height: `${RECT_H}px`,
+                borderRadius: `${hoverRadius}px`,
+                backgroundColor: hoverBg,
+                border: `2px ${hoverBorderStyle} ${hoverBorder}`,
+                transition: 'all 0.2s cubic-bezier(0.4, 0, 0.2, 1)',
+            });
+            // Nếu có hàm render động cho trạng thái hover — gọi nó
+            indicator.innerHTML = s?.renderHoverIndicator ? s.renderHoverIndicator() : '';
+        };
+        applyDotStyle();
+        hitZone.appendChild(indicator);
+        hitZone.addEventListener('dragenter', (e) => {
+            e.preventDefault();
+            applyRectStyle();
+        });
+        hitZone.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            if (e.dataTransfer)
+                e.dataTransfer.dropEffect = 'copy';
+        });
+        hitZone.addEventListener('dragleave', (e) => {
+            if (!hitZone.contains(e.relatedTarget)) {
+                applyDotStyle();
+            }
+        });
+        hitZone.addEventListener('drop', (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            const raw = e.dataTransfer?.getData('application/json') ?? '';
+            onDrop(element, branch, raw);
+        });
+        container.appendChild(hitZone);
+    }
+    // ── Vertical drop zone helpers (existing) ───────────────────────────────────
+    calcDropZoneTopBranch(el, branch) {
+        const oc = branch.nodeOtherConfig;
+        if (oc)
+            return (oc.specific_y ?? 0) + (oc.specific_height ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + 10;
+        return (branch.specific_start_branch_y ?? 0) + 30;
+    }
+    calcDropZoneLeftBranch(el, branch) {
+        const firstEl = branch.elements?.[0];
+        if (firstEl?.translateX !== undefined)
+            return firstEl.translateX + (firstEl.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+        return (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+    }
+    calcDropZoneTopNode(el) {
+        const oc = el.nodeOtherConfig;
+        if (oc)
+            return (oc.specific_y ?? 0) + (oc.specific_height ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + 10;
+        return (el.translateY ?? 0) + (el.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT) + 10;
+    }
+    calcDropZoneLeftNode(el) {
+        return (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;
+    }
+    // ── Horizontal drop zone helpers ─────────────────────────────────────────────
+    /**
+     * Horizontal node: "+" nằm giữa đường line nối 2 node — căn giữa Y của element.
+     */
+    calcDropZoneTopNodeH(el) {
+        const D = canvasConfigReadonly().ADD_ICON_DIAMETER;
+        const centerY = (el.translateY ?? 0) + (el.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT) / 2;
+        return centerY - D / 2;
+    }
+    calcDropZoneLeftNodeH(el) {
+        const D = canvasConfigReadonly().ADD_ICON_DIAMETER;
+        const M = canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT;
+        const oc = el.nodeOtherConfig;
+        if (oc) {
+            const right = (oc.specific_x ?? 0) + (oc.specific_width ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT);
+            return right + M / 2 - D / 2;
+        }
+        const right = (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT);
+        // Midpoint của khoảng trống giữa node và node tiếp theo (gap = ELEMENT_MARGIN_DEFAULT)
+        return right + M / 2 - D / 2;
+    }
+    /**
+     * Horizontal branch: "+" nằm căn giữa Y của branch line, sau phần tử cuối trong nhánh.
+     */
+    calcDropZoneTopBranchH(el, branch) {
+        const D = canvasConfigReadonly().ADD_ICON_DIAMETER;
+        // specific_start_branch_y = tâm Y của đường nhánh
+        const centerY = branch.specific_start_branch_y ?? 0;
+        return centerY - D / 2;
+    }
+    calcDropZoneLeftBranchH(el, branch) {
+        const D = canvasConfigReadonly().ADD_ICON_DIAMETER;
+        const M = canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT;
+        // Sau nodeOtherConfig của nhánh (cổ nhánh)
+        const oc = branch.nodeOtherConfig;
+        if (oc?.specific_x !== undefined) {
+            return (oc.specific_x ?? 0) + (oc.specific_width ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + M / 2 - D / 2;
+        }
+        // Nếu nhánh không có nodeOtherConfig: đặt sau điểm rẽ nhánh
+        return (branch.specific_start_branch_x ?? 0) + M / 2 - D / 2;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiDiagramDrawService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiDiagramDrawService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiDiagramDrawService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagram-draw.service.js","sourceRoot":"","sources":["../../../../../libs-ui/services/diagram-draw/src/diagram-draw.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, Injectable, signal } from '@angular/core';\nimport { setStylesElement } from '@libs-ui/utils';\nimport { IRuleConnectable, TDropZoneCanDropFn } from './interfaces/canvas.interface';\nimport { IDataDiagramConfigSvg } from './interfaces/coordinates.interface';\nimport { ICanvasConfig, IConfig, IDiagramElement, IDiagramElementBranch, IDropZoneIndicatorStyle } from './interfaces/diagram.interface';\nimport { MoLibDiagramCalculatorCoordinatesUtil } from './utils/calculator-element.util';\nimport { applyElementStyle, setAttributeSvgAndAppend } from './utils/diagram.util';\nimport { MoLibDiagramHorizontalCalculatorCoordinatesUtil } from './utils/horizontal/calculator-coordinates.util';\n\nconst canvasConfig = signal<ICanvasConfig>({\n  ELEMENT_WIDTH_DEFAULT_BRANCH_WHEN_NOT_ELEMENT: 60,\n  ELEMENT_MARGIN_DEFAULT: 60,\n  ELEMENT_MARGIN_DEFAULT_BRANCH: 16,\n  ELEMENT_MARGIN_BETWEEN_BRANCH_DEFAULT: 60,\n  DEFAULT_BRANCH_WHEN_NO_ELEMENT: 100,\n  ELEMENT_HEIGHT_CURVE: 10,\n  ELEMENT_SVG_STROKE_COLOR: '9ca2ad',\n  ELEMENT_SVG_STROKE_WIDTH: '1',\n  ELEMENT_MARGIN_DEFAULT_BRANCH_TO_ELEMENT_FIRST: 78,\n\n  DISTANCE_TO_WAIT: 30,\n  WAIT_TO_ELEMENT: 50,\n  ELEMENT_WAIT_DEFAULT: 28,\n  DISTANCE_WAIT_TO_NEXT_LINE: 4,\n\n  TYPE_ELEMENT_EXIT: 'EXIT',\n  TYPE_ELEMENT_WORKFLOW: 'WORKFLOW',\n  WIDTH_ELEMENT_DEFAULT: 165,\n  HEIGHT_ELEMENT_DEFAULT: 48,\n\n  ADD_ICON_DIAMETER: 24,\n});\n\nexport const canvasConfigReadonly = canvasConfig.asReadonly();\nexport const storeDataDefault = {\n  positionMaxLeft: 0,\n  positionMaxTop: 0,\n  widthHeightSvgCanvas: { heightSvg: window.innerHeight, widthSvg: window.innerWidth },\n};\n@Injectable({\n  providedIn: 'root',\n})\nexport class LibsUiDiagramDrawService {\n  private configCanvas = signal<IConfig | undefined>(undefined);\n  readonly orientation = signal<'vertical' | 'horizontal'>('vertical');\n  private elementSvg = signal<SVGPathElement | undefined>(undefined);\n  private attributeSvgD = signal<string>('');\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private componentRefs = signal<ComponentRef<any>[]>([]);\n\n  // Virtualization Tracking\n  private virtualViewport?: { x: number; y: number; width: number; height: number };\n  private virtualFlatElements: { element: IDiagramElement; branch?: IDiagramElementBranch; shouldShowArrow: boolean; isOtherConfig: boolean; parentId?: string | number }[] = [];\n  private virtualFlatBranches: IDiagramElementBranch[] = [];\n  private virtualNodesMap = new Map<string, { component?: ComponentRef<any>; arrow?: HTMLElement; label?: HTMLElement }>();\n\n  public updateViewport(vp: { x: number; y: number; width: number; height: number }) {\n    this.virtualViewport = vp;\n    if (this.configCanvas()?.useVirtualizationTemplate) {\n      this.applyVirtualizationDiff();\n    }\n  }\n\n  set setConfig(config: IConfig) {\n    this.configCanvas.set(config);\n  }\n\n  set setConfigCanvas(config: Partial<ICanvasConfig>) {\n    if (!config) {\n      return;\n    }\n\n    canvasConfig.update((current) => ({ ...current, ...config }));\n  }\n\n  configXYElements(elements: Array<IDiagramElement>, updateSVG?: boolean, positionX?: number) {\n    const storeData = this.configCanvas()?.storeDataDefine ?? storeDataDefault;\n    const maxLeftOrigin = storeData.positionMaxLeft;\n    const maxTopOrigin = storeData.positionMaxTop ?? 0;\n\n    if (this.orientation() === 'horizontal') {\n      MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(elements, storeData, positionX);\n    } else {\n      MoLibDiagramCalculatorCoordinatesUtil.setXYElements(elements, storeData, positionX);\n    }\n\n    const maxLeftNew = storeData.positionMaxLeft;\n    const maxTopNew = storeData.positionMaxTop ?? 0;\n\n    if (!this.elementSvg()) {\n      this.elementSvg.set(document.createElementNS('http://www.w3.org/2000/svg', 'path'));\n    }\n\n    if (!updateSVG && this.configCanvas()?.svgContainer && this.elementSvg()) {\n      setAttributeSvgAndAppend(this.configCanvas()?.svgContainer, this.elementSvg(), '');\n    }\n\n    if (this.orientation() === 'horizontal' && maxTopOrigin !== maxTopNew) {\n      this.updatePositionElements(maxTopNew, elements, storeData);\n      return;\n    }\n    if (this.orientation() === 'vertical' && maxLeftOrigin !== maxLeftNew) {\n      this.updatePositionElements(maxLeftNew, elements, storeData);\n      return;\n    }\n\n    if (this.elementSvg()) {\n      this.attributeSvgD.set('');\n      this.buildSvgElement(elements);\n      this.elementSvg()?.setAttribute('d', this.attributeSvgD());\n    }\n  }\n\n  private updatePositionElements(positionOffset: number, elements: Array<IDiagramElement>, config: IDataDiagramConfigSvg) {\n    if (positionOffset && positionOffset < 0) {\n      positionOffset = positionOffset * -1 + 200; // 100 là khoảng cách cách biên\n    }\n    if (this.orientation() === 'horizontal') {\n      MoLibDiagramHorizontalCalculatorCoordinatesUtil.setXYElements(elements, { ...config, updateSVG: true }, positionOffset);\n    } else {\n      MoLibDiagramCalculatorCoordinatesUtil.setXYElements(elements, { ...config, updateSVG: true }, positionOffset);\n    }\n    if (!this.elementSvg()) {\n      this.elementSvg.set(document.createElementNS('http://www.w3.org/2000/svg', 'path'));\n    }\n    if (this.elementSvg()) {\n      this.attributeSvgD.set('');\n      this.buildSvgElement(elements);\n      this.elementSvg()?.setAttribute('d', this.attributeSvgD());\n    }\n  }\n\n  private buildSvgElement(elements: Array<IDiagramElement>) {\n    elements.forEach((currentElement) => {\n      if (currentElement.attributeSvgD) {\n        this.attributeSvgD.update((prev) => `${prev ?? ''} ${currentElement.attributeSvgD}`);\n      }\n      if (currentElement.nodeOtherConfig?.attributeSvgD) {\n        this.attributeSvgD.update((prev) => `${prev ?? ''} ${currentElement.nodeOtherConfig?.attributeSvgD}`);\n      }\n      if (!currentElement.branches || !currentElement.branches.length) {\n        return;\n      }\n\n      currentElement.branches.forEach((branch) => {\n        if (branch.attributeSvgD) {\n          this.attributeSvgD.update((prev) => `${prev ?? ''} ${branch.attributeSvgD}`);\n        }\n        if (branch.nodeOtherConfig?.attributeSvgD) {\n          this.attributeSvgD.update((prev) => `${prev ?? ''} ${branch.nodeOtherConfig?.attributeSvgD}`);\n        }\n\n        if (!branch.elements.length) {\n          return;\n        }\n\n        this.buildSvgElement(branch.elements);\n      });\n    });\n  }\n\n  /**\n   * Render tất cả nodes từ elements array\n   */\n  renderNodes(elements: Array<IDiagramElement>) {\n    if (this.configCanvas()?.useVirtualizationTemplate) {\n      this.extractVirtualElements(elements);\n      this.applyVirtualizationDiff();\n      return;\n    }\n\n    this.clearNodes();\n    this.renderElementsRecursively(elements, true, undefined);\n    this.renderBranchLabels(elements);\n  }\n\n  private extractVirtualElements(elements: IDiagramElement[]) {\n    this.virtualFlatElements = [];\n    this.virtualFlatBranches = [];\n    const scan = (list: IDiagramElement[], branch?: IDiagramElementBranch, isFirstLevel = true) => {\n      list.forEach((el, index) => {\n        const shouldShowArrow = !(isFirstLevel && index === 0);\n        this.virtualFlatElements.push({ element: el, branch, isOtherConfig: false, shouldShowArrow, parentId: el.id });\n        if (el.nodeOtherConfig) this.virtualFlatElements.push({ element: el.nodeOtherConfig, branch, isOtherConfig: true, shouldShowArrow: false, parentId: el.id });\n        if (el.branches) {\n          el.branches.forEach((b, bIndex) => {\n            if (!b.label) b.label = `Nhánh ${bIndex + 1}`;\n            this.virtualFlatBranches.push(b);\n            if (b.elements) scan(b.elements as IDiagramElement[], b, false);\n            if (b.nodeOtherConfig) this.virtualFlatElements.push({ element: b.nodeOtherConfig, branch: b, isOtherConfig: true, shouldShowArrow: false, parentId: 'branch_' + bIndex + '_' + el.id });\n          });\n        }\n      });\n    };\n    scan(elements, undefined, true);\n  }\n\n  private applyVirtualizationDiff() {\n    const vp = this.virtualViewport;\n    if (!vp) return;\n    const config = this.configCanvas();\n    const container = config?.nodesContainer?.nativeElement;\n    if (!container || !config) return;\n\n    const buffer = 300;\n    const visibleIds = new Set<string>();\n\n    this.virtualFlatElements.forEach((item) => {\n      const el = item.element;\n      if (el.translateX === undefined || el.translateY === undefined) return;\n      if (el.translateX + (el.specific_width || 165) < vp.x - buffer || el.translateX > vp.x + vp.width + buffer || el.translateY + (el.specific_height || 48) < vp.y - buffer || el.translateY > vp.y + vp.height + buffer) return;\n\n      const id = String(item.parentId) + (item.isOtherConfig ? '_other' : '');\n      visibleIds.add(id);\n\n      if (!this.virtualNodesMap.has(id)) {\n        const componentType = item.isOtherConfig ? config.nodeOtherConfigComponentType : config.nodeComponentType;\n        if (componentType && config.viewContainerRef) {\n          const ref = config.viewContainerRef.createComponent(componentType);\n          ref.setInput('element', el);\n          if (item.branch) ref.setInput('branch', item.branch);\n          ref.setInput('orientation', this.orientation());\n\n          const domEl = ref.location.nativeElement as HTMLElement;\n          domEl.classList.add('diagram-node-dynamic');\n          applyElementStyle(domEl, el);\n          container.appendChild(domEl);\n\n          let arrow: HTMLElement | undefined;\n          if (item.shouldShowArrow && !item.isOtherConfig) {\n            arrow = this.createArrowIndicator(el, container);\n          }\n          this.virtualNodesMap.set(id, { component: ref, arrow });\n        }\n      } else {\n        const cache = this.virtualNodesMap.get(id);\n        if (cache) {\n          if (cache.component) applyElementStyle(cache.component.location.nativeElement, el);\n          if (cache.arrow) {\n            const arrowSize = 16;\n            const nodeWidth = el.specific_width ?? 165;\n            const nodeHeight = el.specific_height ?? 48;\n            if (this.orientation() === 'horizontal') {\n              cache.arrow.innerHTML = `\n                 <svg width=\"${arrowSize}\" height=\"${arrowSize}\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n                   <path d=\"M8 4L16 8L8 12Z\" fill=\"#9ca3af\"/>\n                 </svg>\n               `;\n              cache.arrow.style.left = `${el.translateX - arrowSize}px`;\n              cache.arrow.style.top = `${el.translateY + nodeHeight / 2 - arrowSize / 2}px`;\n            } else {\n              cache.arrow.innerHTML = `\n                 <svg width=\"${arrowSize}\" height=\"${arrowSize}\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n                   <path d=\"M8 16L4 12H12L8 16Z\" fill=\"#9ca3af\"/>\n                 </svg>\n               `;\n              cache.arrow.style.left = `${el.translateX + nodeWidth / 2 - arrowSize / 2}px`;\n              cache.arrow.style.top = `${el.translateY - arrowSize}px`;\n            }\n          }\n        }\n      }\n    });\n\n    this.virtualFlatBranches.forEach((branch, index) => {\n      const x = branch.specific_start_branch_x;\n      const y = branch.specific_start_branch_y;\n      if (x === undefined || y === undefined) return;\n      if (x < vp.x - buffer || x > vp.x + vp.width + buffer || y < vp.y - buffer || y > vp.y + vp.height + buffer) return;\n\n      const id = 'branch_' + index + '_' + Math.round(x) + '_' + Math.round(y);\n      visibleIds.add(id);\n\n      if (!this.virtualNodesMap.has(id)) {\n        const labelDiv = this.createBranchLabel(branch);\n        if (labelDiv) this.virtualNodesMap.set(id, { label: labelDiv });\n      } else {\n        const cache = this.virtualNodesMap.get(id);\n        if (cache?.label) {\n          const labelDiv = cache.label;\n          const labelRect = labelDiv.getBoundingClientRect();\n          const labelW = labelRect.width || labelDiv.offsetWidth;\n          const labelH = labelRect.height || labelDiv.offsetHeight;\n          if (this.orientation() === 'vertical') {\n            labelDiv.style.left = `${x - labelW / 2 - 4}px`;\n            labelDiv.style.top = `${y - labelH / 2 + 4}px`;\n          } else {\n            labelDiv.style.left = `${x + 4}px`;\n            labelDiv.style.top = `${y - labelH / 2}px`; // center over wire\n          }\n        }\n      }\n    });\n\n    Array.from(this.virtualNodesMap.entries()).forEach(([id, cache]) => {\n      if (!visibleIds.has(id)) {\n        cache.component?.destroy();\n        cache.arrow?.remove();\n        cache.label?.remove();\n        this.virtualNodesMap.delete(id);\n      }\n    });\n  }\n\n  /**\n   * Render elements và branches một cách đệ quy\n   */\n  private renderElementsRecursively(elements: Array<IDiagramElement>, isFirstLevel = true, branch?: IDiagramElementBranch) {\n    elements.forEach((element, index) => {\n      if (element.translateX !== undefined && element.translateY !== undefined) {\n        // Main node: có arrow nếu không phải element đầu tiên của level đầu\n        const shouldShowArrow = !(isFirstLevel && index === 0);\n        this.createNode(element, branch, shouldShowArrow, false);\n      }\n\n      // Render nodeOtherConfig nếu có (nodes phụ) - KHÔNG có arrow\n      if (element.nodeOtherConfig && element.nodeOtherConfig.translateX !== undefined && element.nodeOtherConfig.translateY !== undefined) {\n        this.createNode(element.nodeOtherConfig, branch, false, true);\n      }\n\n      // Render branches nếu có\n      if (element.branches && element.branches.length > 0) {\n        element.branches.forEach((branch) => {\n          if (branch.elements && branch.elements.length > 0) {\n            this.renderElementsRecursively(branch.elements, false, branch);\n          }\n          if (branch.nodeOtherConfig && branch.nodeOtherConfig.translateX !== undefined && branch.nodeOtherConfig.translateY !== undefined) {\n            this.createNode(branch.nodeOtherConfig, branch, false, true);\n          }\n        });\n      }\n    });\n  }\n\n  /**\n   * Tạo một node component động\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private createNode(element: IDiagramElement, branch: IDiagramElementBranch | undefined, shouldShowArrow: boolean, isNodeOtherConfig: boolean): ComponentRef<any> | undefined {\n    const config = this.configCanvas();\n    if (!config?.viewContainerRef) {\n      return;\n    }\n\n    if (config.useVirtualizationTemplate) {\n      if (config.nodesContainer?.nativeElement) {\n        if (shouldShowArrow && !isNodeOtherConfig) {\n          this.createArrowIndicator(element, config.nodesContainer.nativeElement);\n        }\n      }\n      return;\n    }\n\n    const componentType = isNodeOtherConfig ? config.nodeOtherConfigComponentType : config.nodeComponentType;\n\n    if (!componentType) {\n      return;\n    }\n\n    const componentRef = config.viewContainerRef.createComponent(componentType);\n    const el = componentRef.location.nativeElement as HTMLElement;\n\n    componentRef.setInput('element', element);\n    if (branch) {\n      componentRef.setInput('branch', branch);\n    }\n    componentRef.setInput('orientation', this.orientation());\n    el.classList.add('diagram-node-dynamic');\n\n    applyElementStyle(el, element);\n\n    if (config.nodesContainer?.nativeElement) {\n      config.nodesContainer.nativeElement.appendChild(el);\n\n      if (shouldShowArrow && !isNodeOtherConfig) {\n        this.createArrowIndicator(element, config.nodesContainer.nativeElement);\n      }\n    }\n\n    this.componentRefs.update((refs) => [...refs, componentRef]); // Lưu reference để cleanup sau\n\n    return componentRef;\n  }\n\n  /**\n   * Clear tất cả nodes đã tạo\n   */\n  clearNodes() {\n    this.componentRefs().forEach((ref) => {\n      ref.destroy();\n    });\n    this.componentRefs.set([]);\n\n    Array.from(this.virtualNodesMap.values()).forEach((cache) => {\n      cache.component?.destroy();\n      cache.arrow?.remove();\n      cache.label?.remove();\n    });\n    this.virtualNodesMap.clear();\n\n    const config = this.configCanvas();\n    const nodesContainer = config?.nodesContainer?.nativeElement;\n    if (nodesContainer) {\n      if (!config?.useVirtualizationTemplate) {\n        const dynamicNodes = nodesContainer.querySelectorAll('.diagram-node-dynamic');\n        dynamicNodes.forEach((node: Element) => node.remove());\n      }\n      const labels = nodesContainer.querySelectorAll('.branch-label');\n      labels.forEach((label: Element) => label.remove());\n      const arrows = nodesContainer.querySelectorAll('.node-arrow-indicator');\n      arrows.forEach((arrow: Element) => arrow.remove());\n    }\n  }\n\n  /**\n   * Tạo mũi tên indicator chỉ hướng vào node.\n   * - vertical:   mũi tên ▼ phía TRÊN node  (luồng trên → xuống)\n   * - horizontal: mũi tên ► phía TRÁI node  (luồng trái → phải)\n   */\n  private createArrowIndicator(element: IDiagramElement, container: HTMLElement, ): HTMLElement | undefined {\n    if (element.translateX === undefined || element.translateY === undefined) {\n      return undefined;\n    }\n\n    const arrow = document.createElement('div');\n    arrow.className = 'node-arrow-indicator';\n    arrow.style.position = 'absolute';\n    arrow.style.zIndex = '1';\n    arrow.style.pointerEvents = 'none';\n\n    const arrowSize = 16;\n    const nodeWidth = element.specific_width ?? 0;\n    const nodeHeight = element.specific_height ?? 0;\n\n    if (this.orientation() === 'horizontal') {\n      // Mũi tên ► ở bên TRÁI node, căn giữa theo chiều cao\n      arrow.innerHTML = `\n        <svg width=\"${arrowSize}\" height=\"${arrowSize}\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <path d=\"M8 4L16 8L8 12Z\" fill=\"#9ca3af\"/>\n        </svg>\n      `;\n      arrow.style.left = `${element.translateX - arrowSize}px`;\n      arrow.style.top = `${element.translateY + nodeHeight / 2 - arrowSize / 2}px`;\n    } else {\n      // Mũi tên ▼ ở phía TRÊN node, căn giữa theo chiều rộng\n      arrow.innerHTML = `\n        <svg width=\"${arrowSize}\" height=\"${arrowSize}\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <path d=\"M8 16L4 12H12L8 16Z\" fill=\"#9ca3af\"/>\n        </svg>\n      `;\n      arrow.style.left = `${element.translateX + nodeWidth / 2 - arrowSize / 2}px`;\n      arrow.style.top = `${element.translateY - arrowSize}px`;\n    }\n\n    container.appendChild(arrow);\n    return arrow;\n  }\n\n  /**\n   * Render branch labels (text annotations on branches)\n   */\n  private renderBranchLabels(elements: Array<IDiagramElement>, ) {\n    const svgContainer = this.configCanvas()?.svgContainer?.nativeElement;\n    if (!svgContainer) {\n      return;\n    }\n\n    elements.forEach((element) => {\n      if (element.branches && element.branches.length > 0) {\n        element.branches.forEach((branch, index) => {\n          if (branch.specific_start_branch_x !== undefined && branch.specific_start_branch_y !== undefined) {\n            if (!branch.label) {\n              branch.label = `Nhánh ${index + 1}`;\n            }\n            this.createBranchLabel(branch);\n          }\n\n          if (branch.elements && branch.elements.length > 0) {\n            this.renderBranchLabels(branch.elements);\n          }\n        });\n      }\n    });\n  }\n\n  private createBranchLabel(branch: IDiagramElementBranch, ): HTMLElement | undefined {\n    const config = this.configCanvas();\n    const container = config?.nodesContainer?.nativeElement;\n    if (!container) {\n      return undefined;\n    }\n\n    const labelDiv = document.createElement('div');\n    labelDiv.className = 'branch-label';\n    labelDiv.textContent = branch.label || '';\n\n    labelDiv.style.position = 'absolute';\n    labelDiv.style.padding = '2px 7px';\n    labelDiv.style.borderRadius = '10px';\n    labelDiv.style.backgroundColor = branch.labelBgColor || '#f3f4f6';\n    labelDiv.style.fontSize = '11px';\n    labelDiv.style.fontFamily = 'system-ui, -apple-system, sans-serif';\n    labelDiv.style.color = '#374151';\n    labelDiv.style.whiteSpace = 'nowrap';\n    labelDiv.style.zIndex = '2';\n    labelDiv.style.pointerEvents = 'none';\n\n    container.appendChild(labelDiv);\n\n    const startX = branch.specific_start_branch_x ?? 0;\n    const startY = branch.specific_start_branch_y ?? 0;\n    const labelW = labelDiv.offsetWidth;\n    const labelH = labelDiv.offsetHeight || 18;\n\n    if (this.orientation() === 'horizontal') {\n      /**\n       * Horizontal: label nằm TRÊN đường line nằm ngang.\n       * specific_start_branch = điểm bắt đầu đoạn thẳng ngang đến element.\n       * Đặt label tịnh tiến sang phải 8px từ ngoặt nhánh, và căn giữa dây.\n       */\n      labelDiv.style.left = `${startX + 4}px`;\n      labelDiv.style.top = `${startY - labelH / 2}px`;\n    } else {\n      /**\n       * Vertical: label nằm BÊN TRÁI đường ngang, căn giữa theo Y.\n       * specific_start_branch = điểm đầu đoạn thẳng đến element (sau curve).\n       */\n      labelDiv.style.left = `${startX - labelW / 2 - 4}px`;\n      labelDiv.style.top = `${startY - labelH / 2 + 4}px`;\n    }\n    return labelDiv;\n  }\n\n  /**\n   * Render dấu \"+\" tại mỗi vị trí có thể thả element từ sidebar.\n   * Service tự tạo DOM elements và inject vào nodesContainer.\n   * @param flatElements Danh sách flat elements đã tính toán vị trí\n   * @param onDrop Callback khi người dùng thả element vào một \"+\"\n   * @param canDropFn (tùy chọn) Function kiểm tra điều kiện hiển thị drop zone.\n   * ```\n   */\n  renderDropZones(\n    flatElements: IDiagramElement[],\n    onDrop: (element: IDiagramElement, branch: IDiagramElementBranch | undefined, dragData: string) => void,\n    canDropFn: TDropZoneCanDropFn,\n    ruleConnectableElements: Array<IRuleConnectable>\n  ): void {\n    this.clearDropZones();\n    const container = this.configCanvas()?.nodesContainer?.nativeElement as HTMLElement | undefined;\n    if (!container) return;\n\n    flatElements.forEach((el) => {\n      if (el.code === canvasConfigReadonly().TYPE_ELEMENT_EXIT) return;\n\n      if (el.element_type === canvasConfigReadonly().TYPE_ELEMENT_WORKFLOW) {\n        el.branches?.forEach((branch) => {\n          if (canDropFn(undefined, el, branch, ruleConnectableElements)) return;\n\n          const top = this.orientation() === 'horizontal' ? this.calcDropZoneTopBranchH(el, branch) : this.calcDropZoneTopBranch(el, branch);\n          const left = this.orientation() === 'horizontal' ? this.calcDropZoneLeftBranchH(el, branch) : this.calcDropZoneLeftBranch(el, branch);\n          this.createDropZoneEl(container, top, left, el, branch, onDrop);\n        });\n      } else {\n        if (!canDropFn(undefined, el, undefined, ruleConnectableElements)) return;\n\n        const top = this.orientation() === 'horizontal' ? this.calcDropZoneTopNodeH(el) : this.calcDropZoneTopNode(el);\n        const left = this.orientation() === 'horizontal' ? this.calcDropZoneLeftNodeH(el) : this.calcDropZoneLeftNode(el);\n        this.createDropZoneEl(container, top, left, el, undefined, onDrop);\n      }\n    });\n  }\n\n  /** Xóa tất cả drop zone \"+\" khỏi DOM */\n  clearDropZones(): void {\n    const container = this.configCanvas()?.nodesContainer?.nativeElement as HTMLElement | undefined;\n    if (!container) return;\n    container.querySelectorAll('.diagram-drop-zone').forEach((el) => el.remove());\n  }\n\n  private createDropZoneEl(\n    container: HTMLElement,\n    top: number,\n    left: number,\n    element: IDiagramElement,\n    branch: IDiagramElementBranch | undefined,\n    onDrop: (element: IDiagramElement, branch: IDiagramElementBranch | undefined, dragData: string) => void\n  ): void {\n    const indicatorStyle: IDropZoneIndicatorStyle | undefined = this.configCanvas()?.dropZoneStyle;\n    const RECT_W = element.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT;\n    const RECT_H = element.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT;\n\n    // Tâm của nút tròn\n    const centerX = left + canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n    const centerY = top + canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n\n    // Hit zone vô hình: rộng hơn rectangle một khoản padding để bắt drag sớm hơn\n    const HIT_PAD = 20;\n    const HIT_W = RECT_W + HIT_PAD * 2;\n    const HIT_H = RECT_H + HIT_PAD * 2;\n    const hitLeft = centerX - HIT_W / 2;\n    const hitTop = centerY - HIT_H / 2;\n\n    // ── Hit zone (wrapper vô hình, vùng nhận drag rộng) ─────────────────\n    const hitZone = document.createElement('div');\n    hitZone.className = 'diagram-drop-zone';\n    hitZone.style.cssText = `\n      position: absolute;\n      top: ${hitTop}px;\n      left: ${hitLeft}px;\n      z-index: 9;\n      width: ${HIT_W}px;\n      height: ${HIT_H}px;\n      cursor: pointer;\n    `;\n\n    // ── Indicator (con bên trong, phần hiển thị) ─────────────────────────\n    const indicator = document.createElement('div');\n    indicator.style.pointerEvents = 'none'; // tránh tranh chấp event với hitZone\n\n    // Vị trí dot trong hitZone (căn giữa hitZone)\n    const dotOffsetLeft = HIT_W / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n    const dotOffsetTop = HIT_H / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n\n    // Vị trí rectangle trong hitZone (căn giữa hitZone)\n    const rectOffsetLeft = HIT_PAD;\n    const rectOffsetTop = HIT_H / 2 - RECT_H / 2;\n\n    const applyDotStyle = () => {\n      const s = indicatorStyle;\n      const size = canvasConfigReadonly().ADD_ICON_DIAMETER;\n      const bg = s?.backgroundColor ?? '#3b82f6';\n      const iconColor = s?.iconColor ?? '#ffffff';\n      const opacity = s?.opacity ?? 0.95;\n      const borderRadius = s?.borderRadius ?? '50%';\n\n      setStylesElement(indicator, {\n        position: 'absolute',\n        top: `${dotOffsetTop}px`,\n        left: `${dotOffsetLeft}px`,\n        width: `${size}px`,\n        height: `${size}px`,\n        pointerEvents: 'none',\n        display: 'flex',\n        alignItems: 'center',\n        justifyContent: 'center',\n        transition: 'opacity 0.15s ease',\n        border: 'none',\n      });\n\n      if (s?.renderIndicator) {\n        indicator.innerHTML = s.renderIndicator(size);\n      } else {\n        indicator.innerHTML = `\n          <div style=\"\n            width: ${size}px;\n            height: ${size}px;\n            background-color: ${bg};\n            border-radius: ${borderRadius};\n            opacity: ${opacity};\n            display: flex;\n            align-items: center;\n            justify-content: center;\n            pointer-events: none;\n          \"><i class=\"libs-ui-icon-add before:text-[${iconColor}]\"></i></div>\n        `;\n      }\n    };\n\n    const applyRectStyle = () => {\n      const s = indicatorStyle;\n      const hoverBg = s?.hoverBackgroundColor ?? '#eef4ff';\n      const hoverBorder = s?.hoverBorderColor ?? 'rgba(59, 130, 246, 0.7)';\n      const hoverBorderStyle = s?.hoverBorderStyle ?? 'dashed';\n      const hoverRadius = s?.hoverBorderRadius ?? 10;\n\n      setStylesElement(indicator, {\n        top: `${rectOffsetTop}px`,\n        left: `${rectOffsetLeft}px`,\n        width: `${RECT_W}px`,\n        height: `${RECT_H}px`,\n        borderRadius: `${hoverRadius}px`,\n        backgroundColor: hoverBg,\n        border: `2px ${hoverBorderStyle} ${hoverBorder}`,\n        transition: 'all 0.2s cubic-bezier(0.4, 0, 0.2, 1)',\n      });\n\n      // Nếu có hàm render động cho trạng thái hover — gọi nó\n      indicator.innerHTML = s?.renderHoverIndicator ? s.renderHoverIndicator() : '';\n    };\n\n    applyDotStyle();\n    hitZone.appendChild(indicator);\n\n    hitZone.addEventListener('dragenter', (e: DragEvent) => {\n      e.preventDefault();\n      applyRectStyle();\n    });\n\n    hitZone.addEventListener('dragover', (e: DragEvent) => {\n      e.preventDefault();\n      if (e.dataTransfer) e.dataTransfer.dropEffect = 'copy';\n    });\n\n    hitZone.addEventListener('dragleave', (e: DragEvent) => {\n      if (!hitZone.contains(e.relatedTarget as Node)) {\n        applyDotStyle();\n      }\n    });\n\n    hitZone.addEventListener('drop', (e: DragEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n      const raw = e.dataTransfer?.getData('application/json') ?? '';\n      onDrop(element, branch, raw);\n    });\n\n    container.appendChild(hitZone);\n  }\n\n  // ── Vertical drop zone helpers (existing) ───────────────────────────────────\n  private calcDropZoneTopBranch(el: IDiagramElement, branch: IDiagramElementBranch): number {\n    const oc = branch.nodeOtherConfig;\n    if (oc) return (oc.specific_y ?? 0) + (oc.specific_height ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + 10;\n    return (branch.specific_start_branch_y ?? 0) + 30;\n  }\n\n  private calcDropZoneLeftBranch(el: IDiagramElement, branch: IDiagramElementBranch): number {\n    const firstEl = branch.elements?.[0];\n    if (firstEl?.translateX !== undefined) return firstEl.translateX + (firstEl.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n    return (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n  }\n\n  private calcDropZoneTopNode(el: IDiagramElement): number {\n    const oc = el.nodeOtherConfig;\n    if (oc) return (oc.specific_y ?? 0) + (oc.specific_height ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + 10;\n    return (el.translateY ?? 0) + (el.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT) + 10;\n  }\n\n  private calcDropZoneLeftNode(el: IDiagramElement): number {\n    return (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT) / 2 - canvasConfigReadonly().ADD_ICON_DIAMETER / 2;\n  }\n\n  // ── Horizontal drop zone helpers ─────────────────────────────────────────────\n  /**\n   * Horizontal node: \"+\" nằm giữa đường line nối 2 node — căn giữa Y của element.\n   */\n  private calcDropZoneTopNodeH(el: IDiagramElement): number {\n    const D = canvasConfigReadonly().ADD_ICON_DIAMETER;\n    const centerY = (el.translateY ?? 0) + (el.specific_height ?? canvasConfigReadonly().HEIGHT_ELEMENT_DEFAULT) / 2;\n    return centerY - D / 2;\n  }\n\n  private calcDropZoneLeftNodeH(el: IDiagramElement): number {\n    const D = canvasConfigReadonly().ADD_ICON_DIAMETER;\n    const M = canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT;\n    const oc = el.nodeOtherConfig;\n\n    if (oc) {\n      const right = (oc.specific_x ?? 0) + (oc.specific_width ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT);\n      return right + M / 2 - D / 2;\n    }\n\n    const right = (el.translateX ?? 0) + (el.specific_width ?? canvasConfigReadonly().WIDTH_ELEMENT_DEFAULT);\n    // Midpoint của khoảng trống giữa node và node tiếp theo (gap = ELEMENT_MARGIN_DEFAULT)\n    return right + M / 2 - D / 2;\n  }\n\n  /**\n   * Horizontal branch: \"+\" nằm căn giữa Y của branch line, sau phần tử cuối trong nhánh.\n   */\n  private calcDropZoneTopBranchH(el: IDiagramElement, branch: IDiagramElementBranch): number {\n    const D = canvasConfigReadonly().ADD_ICON_DIAMETER;\n    // specific_start_branch_y = tâm Y của đường nhánh\n    const centerY = branch.specific_start_branch_y ?? 0;\n    return centerY - D / 2;\n  }\n\n  private calcDropZoneLeftBranchH(el: IDiagramElement, branch: IDiagramElementBranch): number {\n    const D = canvasConfigReadonly().ADD_ICON_DIAMETER;\n    const M = canvasConfigReadonly().ELEMENT_MARGIN_DEFAULT;\n\n    // Sau nodeOtherConfig của nhánh (cổ nhánh)\n    const oc = branch.nodeOtherConfig;\n    if (oc?.specific_x !== undefined) {\n      return (oc.specific_x ?? 0) + (oc.specific_width ?? canvasConfigReadonly().ELEMENT_WAIT_DEFAULT) + M / 2 - D / 2;\n    }\n    // Nếu nhánh không có nodeOtherConfig: đặt sau điểm rẽ nhánh\n    return (branch.specific_start_branch_x ?? 0) + M / 2 - D / 2;\n  }\n}\n"]}