@libs-ui/components-drag-drop 0.2.10-6.2

package/esm2022/drag-drop.service.mjs

@@ -0,0 +1,92 @@
+import { Injectable, signal } from "@angular/core";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export class MoLibsSharedDragDropService {
+    itemsClick = new Array();
+    onDragItemInContainerVirtualScroll = new Subject();
+    itemDragInfo;
+    container = signal(new Map());
+    targetItemDragFlag = 'item-drag-target';
+    classContainerDefine = 'libs-ui-drag-drop-container';
+    classItemDefine = 'libs-ui-drag-drop-item';
+    onDragging = new Subject();
+    onDragStart = new Subject();
+    onDragEnd = new Subject();
+    onDragOver = new Subject();
+    onDragLeave = new Subject();
+    onDrop = new Subject();
+    onDropContainer = new Subject();
+    onItemInit = new Subject();
+    get OnDragItemInContainerVirtualScroll() {
+        return this.onDragItemInContainerVirtualScroll;
+    }
+    set ItemDragInfo(data) {
+        this.itemDragInfo = data;
+    }
+    get ItemDragInfo() {
+        return this.itemDragInfo;
+    }
+    get Container() {
+        return this.container;
+    }
+    get TargetItemDragFlag() {
+        return this.targetItemDragFlag;
+    }
+    get ClassContainerDefine() {
+        return this.classContainerDefine;
+    }
+    get ClassItemDefine() {
+        return this.classItemDefine;
+    }
+    get OnDragging() {
+        return this.onDragging;
+    }
+    get OnDragOver() {
+        return this.onDragOver;
+    }
+    get OnDragLeave() {
+        return this.onDragLeave;
+    }
+    get OnDragStart() {
+        return this.onDragStart;
+    }
+    get OnDragEnd() {
+        return this.onDragEnd;
+    }
+    get OnDropContainer() {
+        return this.onDropContainer;
+    }
+    get OnDrop() {
+        return this.onDrop;
+    }
+    get OnItemInit() {
+        return this.onItemInit;
+    }
+    get ItemClick() {
+        return [...this.itemsClick];
+    }
+    set ItemClick(item) {
+        this.itemsClick.push(item);
+    }
+    resetItemClick() {
+        this.itemsClick.length = 0;
+    }
+    checkElementOverAcceptElementDrag(groupNameOfContainer, groupNameOfElementDrag, groupNameOfDropTo) {
+        if (groupNameOfContainer !== groupNameOfElementDrag && !groupNameOfDropTo) {
+            return false;
+        }
+        if (groupNameOfDropTo !== null && !groupNameOfDropTo.toString().split(';').includes(groupNameOfContainer || 'undefinedName')) {
+            return false;
+        }
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MoLibsSharedDragDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MoLibsSharedDragDropService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MoLibsSharedDragDropService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/drag-item-in-container-virtual-scroll.directive.mjs

@@ -0,0 +1,124 @@
+import { Directive, inject, output } from "@angular/core";
+import { cloneIBoundingClientRect, getViewport } from "@libs-ui/utils";
+import { Subject, fromEvent, takeUntil, tap } from "rxjs";
+import { MoLibsSharedDragDropService } from "./drag-drop.service";
+import * as i0 from "@angular/core";
+export class LibsUiDragItemInContainerVirtualScrollDirective {
+    /* PROPERTY */
+    onDestroy = new Subject();
+    /* OUTPUT */
+    outDragEndContainer = output();
+    /* INJECT */
+    dragDropService = inject(MoLibsSharedDragDropService);
+    ngAfterViewInit() {
+        this.dragDropService.OnDragEnd.pipe(takeUntil(this.onDestroy)).subscribe(e => {
+            this.outDragEndContainer.emit(e);
+        });
+        this.dragDropService.OnDragItemInContainerVirtualScroll.pipe(takeUntil(this.onDestroy)).subscribe(dragItemInContainerVirtualScrollEvent => {
+            const stopEventMouse = (mouseEvent) => {
+                if (!dragItemInContainerVirtualScrollEvent.ignoreStopEvent) {
+                    mouseEvent.preventDefault();
+                    mouseEvent.stopPropagation();
+                }
+            };
+            const documentMouseUp = fromEvent(document, 'mouseup')
+                .pipe(tap((eventMouseUp) => {
+                this.updateMouseEventsWhenMoveOverIframe('auto');
+                stopEventMouse(eventMouseUp);
+                const mousePosition = { clientX: eventMouseUp.clientX, clientY: eventMouseUp.clientY };
+                if (dragItemInContainerVirtualScrollEvent.dragBoundary && dragItemInContainerVirtualScrollEvent.dragBoundaryAcceptMouseLeaveContainer) {
+                    const result = this.getClientPosition(dragItemInContainerVirtualScrollEvent.elementDrag, mousePosition, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop, dragItemInContainerVirtualScrollEvent.dragBoundary, dragItemInContainerVirtualScrollEvent.elementContainer);
+                    mousePosition.clientX = result.clientX;
+                    mousePosition.clientY = result.clientY;
+                }
+                const dragEndEvent = { mousePosition, elementDrag: dragItemInContainerVirtualScrollEvent.elementDrag, itemDragInfo: this.dragDropService.ItemDragInfo };
+                this.dragDropService.ItemDragInfo = undefined;
+                this.dragDropService.OnDragEnd.next(dragEndEvent);
+                document.body.classList.remove('select-none');
+                dragItemInContainerVirtualScrollEvent.elementDrag.remove();
+            }), takeUntil(this.onDestroy));
+            fromEvent(document, 'mousemove').pipe(tap((eventMousemove) => {
+                stopEventMouse(eventMousemove);
+                const { clientX, clientY } = eventMousemove;
+                const mousePosition = { clientX, clientY };
+                const result = this.getClientPosition(dragItemInContainerVirtualScrollEvent.elementDrag, mousePosition, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop, dragItemInContainerVirtualScrollEvent.dragBoundary, dragItemInContainerVirtualScrollEvent.elementContainer);
+                const elementKeepContainer = result.elementKeepContainer;
+                const left = result.clientX - dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft;
+                const top = result.clientY - dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop;
+                if (dragItemInContainerVirtualScrollEvent.dragBoundary && dragItemInContainerVirtualScrollEvent.dragBoundaryAcceptMouseLeaveContainer) {
+                    if (clientX < result.viewport.left) {
+                        mousePosition.clientX = result.viewport.left;
+                    }
+                    if (clientX > result.viewport.width) {
+                        mousePosition.clientX = result.viewport.width;
+                    }
+                    if (clientY < result.viewport.top) {
+                        mousePosition.clientY = result.viewport.top;
+                    }
+                    if (clientY > result.viewport.height) {
+                        mousePosition.clientY = result.viewport.height;
+                    }
+                }
+                dragItemInContainerVirtualScrollEvent.elementDrag.style.left = `${left}px`;
+                dragItemInContainerVirtualScrollEvent.elementDrag.style.top = `${top}px`;
+                this.dragDropService.OnDragging.next({ mousePosition, elementDrag: dragItemInContainerVirtualScrollEvent.elementDrag, elementKeepContainer, itemDragInfo: this.dragDropService.ItemDragInfo });
+            }), takeUntil((documentMouseUp)), takeUntil(this.onDestroy)).subscribe();
+        });
+    }
+    /* FUNCTIONS */
+    getClientPosition(element, mousePosition, distanceStartElementAndMouseLeft, distanceStartElementAndMouseTop, dragBoundary, elementContainer) {
+        let viewport = getViewport();
+        const rectElement = element.getBoundingClientRect();
+        const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');
+        const containerItem = elementContainer || containerById?.elementScroll || containerById?.element || document.body;
+        let { clientX, clientY } = mousePosition;
+        viewport.left = 0;
+        viewport.top = 0;
+        if (dragBoundary) {
+            viewport = cloneIBoundingClientRect(containerItem.getBoundingClientRect());
+            viewport.height = viewport.top + viewport.height;
+            viewport.width = viewport.left + viewport.width;
+        }
+        let elementKeepContainer = false;
+        if (clientX > viewport.width && clientY > viewport.height || clientX < viewport.left && clientY < viewport.top) {
+            elementKeepContainer = true;
+        }
+        if ((clientX + (rectElement.width - distanceStartElementAndMouseLeft)) > viewport.width) {
+            clientX -= (clientX + (rectElement.width - distanceStartElementAndMouseLeft) - viewport.width);
+        }
+        if ((clientY + (rectElement.height - distanceStartElementAndMouseTop)) > viewport.height) {
+            clientY -= (clientY + (rectElement.height - distanceStartElementAndMouseTop) - viewport.height);
+        }
+        if ((clientX - distanceStartElementAndMouseLeft) < (dragBoundary && containerItem ? viewport.left : 0)) {
+            clientX = (dragBoundary && containerItem ? viewport.left : 0) + distanceStartElementAndMouseLeft;
+        }
+        if ((clientY - distanceStartElementAndMouseTop) < (dragBoundary && containerItem ? viewport.top : 0)) {
+            clientY = (dragBoundary && containerItem ? viewport.top : 0) + distanceStartElementAndMouseTop;
+        }
+        return { clientX, clientY, elementKeepContainer, viewport };
+    }
+    updateMouseEventsWhenMoveOverIframe(pointerEvents) {
+        const frames = document.getElementsByTagName("iframe");
+        if (!frames?.length) {
+            return;
+        }
+        for (let i = 0; i < frames.length; ++i) {
+            frames[i].style.pointerEvents = pointerEvents;
+        }
+    }
+    ngOnDestroy() {
+        this.onDestroy.next();
+        this.onDestroy.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiDragItemInContainerVirtualScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LibsUiDragItemInContainerVirtualScrollDirective, isStandalone: true, selector: "[LibsUiDragItemInContainerVirtualScrollDirective]", outputs: { outDragEndContainer: "outDragEndContainer" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiDragItemInContainerVirtualScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: "[LibsUiDragItemInContainerVirtualScrollDirective]",
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-item-in-container-virtual-scroll.directive.js","sourceRoot":"","sources":["../../../../../libs-ui/components/drag-drop/src/drag-item-in-container-virtual-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, OnDestroy, inject, output } from \"@angular/core\";\nimport { IBoundingClientRect } from \"@libs-ui/interfaces-types\";\nimport { cloneIBoundingClientRect, getViewport } from \"@libs-ui/utils\";\nimport { Subject, fromEvent, takeUntil, tap } from \"rxjs\";\nimport { MoLibsSharedDragDropService } from \"./drag-drop.service\";\nimport { IDragEnd } from \"./interfaces/event.interface\";\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: \"[LibsUiDragItemInContainerVirtualScrollDirective]\",\n  standalone: true,\n\n})\nexport class LibsUiDragItemInContainerVirtualScrollDirective implements AfterViewInit, OnDestroy {\n  /* PROPERTY */\n  protected onDestroy = new Subject<void>();\n\n  /* OUTPUT */\n  readonly outDragEndContainer = output<IDragEnd>();\n\n  /* INJECT */\n  protected dragDropService = inject(MoLibsSharedDragDropService);\n\n  ngAfterViewInit(): void {\n    this.dragDropService.OnDragEnd.pipe(takeUntil(this.onDestroy)).subscribe(e => {\n      this.outDragEndContainer.emit(e);\n    });\n    this.dragDropService.OnDragItemInContainerVirtualScroll.pipe(takeUntil(this.onDestroy)).subscribe(dragItemInContainerVirtualScrollEvent => {\n      const stopEventMouse = (mouseEvent: MouseEvent) => {\n        if (!dragItemInContainerVirtualScrollEvent.ignoreStopEvent) {\n          mouseEvent.preventDefault();\n          mouseEvent.stopPropagation();\n        }\n      };\n      const documentMouseUp = fromEvent<MouseEvent>(document, 'mouseup')\n        .pipe(\n          tap((eventMouseUp) => {\n            this.updateMouseEventsWhenMoveOverIframe('auto');\n            stopEventMouse(eventMouseUp);\n            const mousePosition = { clientX: eventMouseUp.clientX, clientY: eventMouseUp.clientY };\n\n            if (dragItemInContainerVirtualScrollEvent.dragBoundary && dragItemInContainerVirtualScrollEvent.dragBoundaryAcceptMouseLeaveContainer) {\n              const result = this.getClientPosition(dragItemInContainerVirtualScrollEvent.elementDrag, mousePosition, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop, dragItemInContainerVirtualScrollEvent.dragBoundary, dragItemInContainerVirtualScrollEvent.elementContainer);\n\n              mousePosition.clientX = result.clientX;\n              mousePosition.clientY = result.clientY;\n            }\n            const dragEndEvent = { mousePosition, elementDrag: dragItemInContainerVirtualScrollEvent.elementDrag, itemDragInfo: this.dragDropService.ItemDragInfo };\n\n            this.dragDropService.ItemDragInfo = undefined;\n            this.dragDropService.OnDragEnd.next(dragEndEvent);\n            document.body.classList.remove('select-none');\n            dragItemInContainerVirtualScrollEvent.elementDrag.remove();\n          }),\n          takeUntil(this.onDestroy)\n        );\n\n      fromEvent<MouseEvent>(document, 'mousemove').pipe(tap((eventMousemove) => {\n        stopEventMouse(eventMousemove);\n        const { clientX, clientY } = eventMousemove;\n        const mousePosition = { clientX, clientY };\n\n        const result = this.getClientPosition(dragItemInContainerVirtualScrollEvent.elementDrag, mousePosition, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft, dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop, dragItemInContainerVirtualScrollEvent.dragBoundary, dragItemInContainerVirtualScrollEvent.elementContainer);\n        const elementKeepContainer = result.elementKeepContainer;\n        const left = result.clientX - dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft;\n        const top = result.clientY - dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop;\n\n        if (dragItemInContainerVirtualScrollEvent.dragBoundary && dragItemInContainerVirtualScrollEvent.dragBoundaryAcceptMouseLeaveContainer) {\n          if (clientX < result.viewport.left) {\n            mousePosition.clientX = result.viewport.left;\n          }\n          if (clientX > result.viewport.width) {\n            mousePosition.clientX = result.viewport.width;\n          }\n          if (clientY < result.viewport.top) {\n            mousePosition.clientY = result.viewport.top;\n          }\n          if (clientY > result.viewport.height) {\n            mousePosition.clientY = result.viewport.height;\n          }\n        }\n        dragItemInContainerVirtualScrollEvent.elementDrag.style.left = `${left}px`;\n        dragItemInContainerVirtualScrollEvent.elementDrag.style.top = `${top}px`;\n\n        this.dragDropService.OnDragging.next({ mousePosition, elementDrag: dragItemInContainerVirtualScrollEvent.elementDrag, elementKeepContainer, itemDragInfo: this.dragDropService.ItemDragInfo });\n      }), takeUntil((documentMouseUp)), takeUntil(this.onDestroy)).subscribe();\n\n    });\n  }\n\n  /* FUNCTIONS */\n\n  protected getClientPosition(element: HTMLElement, mousePosition: { clientX: number; clientY: number; }, distanceStartElementAndMouseLeft: number, distanceStartElementAndMouseTop: number, dragBoundary?: boolean, elementContainer?: HTMLElement): { clientX: number; clientY: number; elementKeepContainer: boolean; viewport: IBoundingClientRect } {\n    let viewport = getViewport() as IBoundingClientRect;\n    const rectElement = element.getBoundingClientRect();\n    const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');\n    const containerItem = elementContainer || containerById?.elementScroll || containerById?.element || document.body;\n    let { clientX, clientY } = mousePosition;\n\n    viewport.left = 0;\n    viewport.top = 0;\n    if (dragBoundary) {\n      viewport = cloneIBoundingClientRect(containerItem.getBoundingClientRect());\n      viewport.height = viewport.top + viewport.height;\n      viewport.width = viewport.left + viewport.width;\n    }\n    let elementKeepContainer = false;\n\n    if (clientX > viewport.width && clientY > viewport.height || clientX < viewport.left && clientY < viewport.top) {\n      elementKeepContainer = true;\n    }\n\n    if ((clientX + (rectElement.width - distanceStartElementAndMouseLeft)) > viewport.width) {\n      clientX -= (clientX + (rectElement.width - distanceStartElementAndMouseLeft) - viewport.width);\n    }\n    if ((clientY + (rectElement.height - distanceStartElementAndMouseTop)) > viewport.height) {\n      clientY -= (clientY + (rectElement.height - distanceStartElementAndMouseTop) - viewport.height);\n    }\n    if ((clientX - distanceStartElementAndMouseLeft) < (dragBoundary && containerItem ? viewport.left : 0)) {\n      clientX = (dragBoundary && containerItem ? viewport.left : 0) + distanceStartElementAndMouseLeft;\n    }\n    if ((clientY - distanceStartElementAndMouseTop) < (dragBoundary && containerItem ? viewport.top : 0)) {\n      clientY = (dragBoundary && containerItem ? viewport.top : 0) + distanceStartElementAndMouseTop;\n    }\n\n    return { clientX, clientY, elementKeepContainer, viewport };\n  }\n\n  protected updateMouseEventsWhenMoveOverIframe(pointerEvents: 'none' | 'auto') {\n    const frames = document.getElementsByTagName(\"iframe\");\n\n    if (!frames?.length) {\n      return;\n    }\n\n    for (let i = 0; i < frames.length; ++i) {\n      frames[i].style.pointerEvents = pointerEvents;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.onDestroy.next();\n    this.onDestroy.complete();\n  }\n}"]}

package/esm2022/drag-item.directive.mjs

@@ -0,0 +1,263 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Directive, ElementRef, effect, inject, input, output, signal } from "@angular/core";
+import { checkMouseOverInContainer, checkViewInScreen, get, getViewport } from "@libs-ui/utils";
+import { fromEvent, mergeMap, startWith, takeUntil, tap, throttleTime } from "rxjs";
+import { LibsUiDragItemInContainerVirtualScrollDirective } from "./drag-item-in-container-virtual-scroll.directive";
+import * as i0 from "@angular/core";
+export class LibsUiDragItemDirective extends LibsUiDragItemInContainerVirtualScrollDirective {
+    /* PROPERTY */
+    isDragOver = signal(false);
+    isDragging = signal(false);
+    /* INPUT */
+    //setup 3 field phía dưới nếu đang sử dụng item trong virtual-scroll 
+    fieldId = input('');
+    item = input(undefined);
+    itemInContainerVirtualScroll = input();
+    //----------------------------------
+    throttleTimeHandlerDraggingEvent = input(0, { transform: value => value || 0 });
+    ignoreStopEvent = input();
+    onlyMouseDownStopEvent = input();
+    dragRootElement = input();
+    groupName = input('groupDragAndDropDefault', { transform: value => value ?? 'groupDragAndDropDefault' });
+    dragBoundary = input();
+    dragBoundaryAcceptMouseLeaveContainer = input();
+    elementContainer = input();
+    zIndex = input(1300, { transform: value => value ?? 1300 });
+    disable = input();
+    /* OUTPUT */
+    outDragStart = output();
+    outDragOver = output();
+    outDragLeave = output();
+    outDragEnd = output();
+    outDropped = output();
+    /* INJECT */
+    elementRef = inject(ElementRef);
+    constructor() {
+        super();
+        effect(() => {
+            if (!this.elementRef?.nativeElement) {
+                return;
+            }
+            const element = this.elementRef.nativeElement;
+            element.classList.remove(`${this.dragDropService.ClassItemDefine}-disable`);
+            if (this.disable() && !element.classList.contains(`${this.dragDropService.ClassItemDefine}-disable`)) {
+                element.classList.add(`${this.dragDropService.ClassItemDefine}-disable`);
+            }
+        });
+    }
+    ngAfterViewInit() {
+        const element = this.elementRef.nativeElement;
+        if (this.fieldId()) {
+            element.setAttribute('field_id', this.fieldId());
+            if (this.item()) {
+                element.setAttribute('item_id', get(this.item(), this.fieldId()));
+            }
+        }
+        element.setAttribute('groupName', this.groupName());
+        element.classList.add(this.dragDropService.ClassItemDefine);
+        this.dragDropService.OnDragging.pipe(throttleTime(this.throttleTimeHandlerDraggingEvent()), takeUntil(this.onDestroy)).subscribe((eventDragging) => {
+            if (this.disable() || element.getAttribute('disableDragContainer') || (this.fieldId() && this.item() && eventDragging.elementDrag.getAttribute('item_id') === get(this.item(), this.fieldId()))) {
+                return;
+            }
+            const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');
+            if (containerById) {
+                if (eventDragging.elementKeepContainer || !this.dragDropService.checkElementOverAcceptElementDrag(containerById.element.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('dropToGroupName'))) {
+                    return;
+                }
+            }
+            if (checkMouseOverInContainer(eventDragging.mousePosition, element) && element !== eventDragging.elementDrag && containerById && checkViewInScreen(containerById.element, element, containerById.elementScroll)) {
+                if (this.isDragOver()) {
+                    return;
+                }
+                const eventDragOver = { ...eventDragging, elementDragOver: element };
+                this.dragDropService.OnDragOver.next(eventDragOver);
+                this.outDragOver.emit(eventDragOver);
+                this.isDragOver.set(true);
+                return;
+            }
+            if (this.isDragOver()) {
+                const eventDragLeave = { ...eventDragging, elementDragLeave: element };
+                this.isDragOver.set(false);
+                this.dragDropService.OnDragLeave.next(eventDragLeave);
+                this.outDragLeave.emit(eventDragLeave);
+            }
+        });
+        this.dragDropService.OnDropContainer.pipe(takeUntil(this.onDestroy)).subscribe((eventDrop) => {
+            if (eventDrop.elementDrop !== element) {
+                return;
+            }
+            const dropEvent = { elementDrag: eventDrop.elementDrag, elementDrop: element, itemDragInfo: eventDrop.itemDragInfo };
+            this.outDropped.emit(dropEvent);
+        });
+        const styleTag = document.createElement("style");
+        styleTag.textContent = `.libs-ui-drag-drop-item-dragging{cursor:move}`;
+        let nodeClone = element;
+        let distanceStartElementAndMouseLeft = -1;
+        let distanceStartElementAndMouseTop = -1;
+        let contextMenu = false;
+        const stopEventMouse = (mouseEvent) => {
+            if (!this.ignoreStopEvent()) {
+                mouseEvent.preventDefault();
+                mouseEvent.stopPropagation();
+            }
+        };
+        const updatePositionElementRootAndRemoveNodeClone = () => {
+            if (this.dragRootElement()) {
+                const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');
+                const containerItem = this.elementContainer() || containerById?.elementScroll || containerById?.element || document.body;
+                const rectContainer = containerItem.getBoundingClientRect();
+                const rectNodeClone = nodeClone.getBoundingClientRect();
+                const numberSub = Number((getComputedStyle(containerItem).border.match(/\d+px/gi) || ['0'])[0].replace(/\D+/ig, '')).valueOf();
+                element.style.left = (rectNodeClone.left - rectContainer.left - numberSub) + 'px';
+                element.style.top = (rectNodeClone.top - rectContainer.top - numberSub) + 'px';
+                element.classList.remove('opacity-0');
+            }
+            distanceStartElementAndMouseLeft = -1;
+            distanceStartElementAndMouseTop = -1;
+            nodeClone.remove();
+        };
+        fromEvent(document, 'contextmenu').pipe(tap(() => {
+            if (this.isDragging()) {
+                updatePositionElementRootAndRemoveNodeClone();
+            }
+            contextMenu = true;
+        }), takeUntil(this.onDestroy)).subscribe();
+        const documentMouseUp = fromEvent(document, 'mouseup')
+            .pipe(tap((eventMouseup) => {
+            this.updateMouseEventsWhenMoveOverIframe('auto');
+            this.dragDropService.resetItemClick();
+            stopEventMouse(eventMouseup);
+            if (this.disable() || element.getAttribute('disableDragContainer') || contextMenu || !this.isDragging()) {
+                contextMenu = false;
+                return;
+            }
+            contextMenu = false;
+            this.isDragging.set(false);
+            element.removeAttribute(this.dragDropService.TargetItemDragFlag);
+            if (this.itemInContainerVirtualScroll()) {
+                return;
+            }
+            const mousePosition = { clientX: eventMouseup.clientX, clientY: eventMouseup.clientY };
+            if (this.dragBoundary() && this.dragBoundaryAcceptMouseLeaveContainer()) {
+                const result = this.getClientPosition(element, mousePosition, distanceStartElementAndMouseLeft, distanceStartElementAndMouseTop, this.dragBoundary(), this.elementContainer());
+                mousePosition.clientX = result.clientX;
+                mousePosition.clientY = result.clientY;
+            }
+            const dragEndEvent = { mousePosition, elementDrag: element, itemDragInfo: this.dragDropService.ItemDragInfo };
+            this.dragDropService.ItemDragInfo = undefined;
+            this.dragDropService.OnDragEnd.next(dragEndEvent);
+            this.outDragEnd.emit(dragEndEvent);
+            document.body.classList.remove('!select-none');
+            nodeClone.classList.remove('libs-ui-drag-drop-item-dragging');
+            styleTag.remove();
+            updatePositionElementRootAndRemoveNodeClone();
+        }), takeUntil(this.onDestroy));
+        const elementMouseDown = fromEvent(element, 'mousedown').pipe(tap(eventMousedown => {
+            this.dragDropService.ItemClick = element;
+            contextMenu = false;
+            this.updateMouseEventsWhenMoveOverIframe('none');
+            if ((this.disable() || element.getAttribute('disableDragContainer') || !this.isDragging() || this.itemInContainerVirtualScroll()) && !this.onlyMouseDownStopEvent()) {
+                return;
+            }
+            stopEventMouse(eventMousedown);
+        }), takeUntil(this.onDestroy));
+        const documentMouseMove = fromEvent(document, 'mousemove').pipe(tap((eventMousemove) => stopEventMouse(eventMousemove)), takeUntil((documentMouseUp)), takeUntil(this.onDestroy));
+        const drag = elementMouseDown.pipe(mergeMap((mouseEvent) => documentMouseMove.pipe(startWith((mouseEvent)))));
+        let ignoreMousedown = false;
+        drag.pipe(tap((dragMouseEvent) => {
+            const rectElement = element.getBoundingClientRect();
+            const viewport = getViewport();
+            if (this.disable() || element.getAttribute('disableDragContainer') || !dragMouseEvent.clientX || (!ignoreMousedown && dragMouseEvent.type === 'mousedown' && rectElement.height + rectElement.top >= viewport.height)) {
+                return;
+            }
+            const { clientX, clientY } = dragMouseEvent;
+            if (distanceStartElementAndMouseLeft === -1) {
+                distanceStartElementAndMouseLeft = clientX - rectElement.left;
+            }
+            if (distanceStartElementAndMouseTop === -1) {
+                distanceStartElementAndMouseTop = clientY - rectElement.top;
+            }
+        }), takeUntil(this.onDestroy)).subscribe(dragMouseEvent => {
+            if (this.dragDropService.ItemClick.filter(item => item !== element).some(item => element.contains(item))) {
+                return;
+            }
+            if (this.disable() || element.getAttribute('disableDragContainer') || !dragMouseEvent.clientX || dragMouseEvent.type === 'mousedown' || contextMenu || (this.itemInContainerVirtualScroll() && this.isDragging())) {
+                return;
+            }
+            ignoreMousedown = true;
+            const { clientX, clientY } = dragMouseEvent;
+            const mousePosition = { clientX, clientY };
+            const rectElement = element.getBoundingClientRect();
+            if (!this.isDragging()) {
+                this.isDragging.set(true);
+                const eventDragStart = { mousePosition, elementDrag: element, itemDragInfo: this.dragDropService.ItemDragInfo };
+                element.setAttribute(this.dragDropService.TargetItemDragFlag, 'true');
+                this.dragDropService.OnDragStart.next(eventDragStart);
+                eventDragStart.itemDragInfo = this.dragDropService.ItemDragInfo;
+                this.outDragStart.emit(eventDragStart);
+                nodeClone = element.cloneNode(true);
+                nodeClone.style.zIndex = `${this.zIndex()}`;
+                nodeClone.classList.add('!fixed');
+                nodeClone.classList.remove('libs-ui-drag-drop-item-origin-placeholder');
+                nodeClone.classList.remove('libs-ui-drag-drop-item-placeholder');
+                nodeClone.appendChild(styleTag);
+                nodeClone.classList.add('libs-ui-drag-drop-item-dragging');
+                nodeClone.style.width = `${rectElement.width}px`;
+                nodeClone.style.height = `${rectElement.height}px`;
+                nodeClone.style.left = `${-999}px`;
+                nodeClone.style.top = `${-999}px`;
+                document.body.classList.add('!select-none');
+                document.body.append(nodeClone);
+                if (this.dragRootElement()) {
+                    element.classList.add('opacity-0');
+                }
+                if (this.itemInContainerVirtualScroll()) {
+                    this.dragDropService.OnDragItemInContainerVirtualScroll.next({
+                        itemDragInfo: this.dragDropService.ItemDragInfo,
+                        elementDrag: nodeClone,
+                        distanceStartElementAndMouseTop,
+                        distanceStartElementAndMouseLeft,
+                        elementContainer: this.elementContainer(),
+                        dragBoundary: this.dragBoundary(),
+                        dragBoundaryAcceptMouseLeaveContainer: this.dragBoundaryAcceptMouseLeaveContainer(),
+                        ignoreStopEvent: this.ignoreStopEvent()
+                    });
+                    return;
+                }
+            }
+            const result = this.getClientPosition(nodeClone, mousePosition, distanceStartElementAndMouseLeft, distanceStartElementAndMouseTop, this.dragBoundary(), this.elementContainer());
+            const elementKeepContainer = result.elementKeepContainer;
+            const left = result.clientX - distanceStartElementAndMouseLeft;
+            const top = result.clientY - distanceStartElementAndMouseTop;
+            if (this.dragBoundary() && this.dragBoundaryAcceptMouseLeaveContainer()) {
+                if (clientX < result.viewport.left) {
+                    mousePosition.clientX = result.viewport.left;
+                }
+                if (clientX > result.viewport.width) {
+                    mousePosition.clientX = result.viewport.width;
+                }
+                if (clientY < result.viewport.top) {
+                    mousePosition.clientY = result.viewport.top;
+                }
+                if (clientY > result.viewport.height) {
+                    mousePosition.clientY = result.viewport.height;
+                }
+            }
+            nodeClone.style.left = `${left}px`;
+            nodeClone.style.top = `${top}px`;
+            const eventDragging = { mousePosition, elementDrag: nodeClone, elementKeepContainer, itemDragInfo: this.dragDropService.ItemDragInfo };
+            this.dragDropService.OnDragging.next(eventDragging);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiDragItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: LibsUiDragItemDirective, isStandalone: true, selector: "[LibsUiDragItemDirective]", inputs: { fieldId: { classPropertyName: "fieldId", publicName: "fieldId", isSignal: true, isRequired: false, transformFunction: null }, item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: false, transformFunction: null }, itemInContainerVirtualScroll: { classPropertyName: "itemInContainerVirtualScroll", publicName: "itemInContainerVirtualScroll", isSignal: true, isRequired: false, transformFunction: null }, throttleTimeHandlerDraggingEvent: { classPropertyName: "throttleTimeHandlerDraggingEvent", publicName: "throttleTimeHandlerDraggingEvent", isSignal: true, isRequired: false, transformFunction: null }, ignoreStopEvent: { classPropertyName: "ignoreStopEvent", publicName: "ignoreStopEvent", isSignal: true, isRequired: false, transformFunction: null }, onlyMouseDownStopEvent: { classPropertyName: "onlyMouseDownStopEvent", publicName: "onlyMouseDownStopEvent", isSignal: true, isRequired: false, transformFunction: null }, dragRootElement: { classPropertyName: "dragRootElement", publicName: "dragRootElement", isSignal: true, isRequired: false, transformFunction: null }, groupName: { classPropertyName: "groupName", publicName: "groupName", isSignal: true, isRequired: false, transformFunction: null }, dragBoundary: { classPropertyName: "dragBoundary", publicName: "dragBoundary", isSignal: true, isRequired: false, transformFunction: null }, dragBoundaryAcceptMouseLeaveContainer: { classPropertyName: "dragBoundaryAcceptMouseLeaveContainer", publicName: "dragBoundaryAcceptMouseLeaveContainer", isSignal: true, isRequired: false, transformFunction: null }, elementContainer: { classPropertyName: "elementContainer", publicName: "elementContainer", isSignal: true, isRequired: false, transformFunction: null }, zIndex: { classPropertyName: "zIndex", publicName: "zIndex", isSignal: true, isRequired: false, transformFunction: null }, disable: { classPropertyName: "disable", publicName: "disable", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outDragStart: "outDragStart", outDragOver: "outDragOver", outDragLeave: "outDragLeave", outDragEnd: "outDragEnd", outDropped: "outDropped" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibsUiDragItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: "[LibsUiDragItemDirective]",
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-item.directive.js","sourceRoot":"","sources":["../../../../../libs-ui/components/drag-drop/src/drag-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { AfterViewInit, Directive, ElementRef, OnDestroy, effect, inject, input, output, signal } from \"@angular/core\";\nimport { IBoundingClientRect } from \"@libs-ui/interfaces-types\";\nimport { checkMouseOverInContainer, checkViewInScreen, get, getViewport } from \"@libs-ui/utils\";\nimport { Observable, fromEvent, mergeMap, startWith, takeUntil, tap, throttleTime } from \"rxjs\";\nimport { LibsUiDragItemInContainerVirtualScrollDirective } from \"./drag-item-in-container-virtual-scroll.directive\";\nimport { IDragEnd, IDragLeave, IDragOver, IDragStart, IDrop } from \"./interfaces/event.interface\";\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: \"[LibsUiDragItemDirective]\",\n  standalone: true\n})\nexport class LibsUiDragItemDirective extends LibsUiDragItemInContainerVirtualScrollDirective implements AfterViewInit, OnDestroy {\n  /* PROPERTY */\n  private isDragOver = signal<boolean>(false);\n  private isDragging = signal<boolean>(false);\n\n  /* INPUT */\n  //setup 3 field phía dưới nếu đang sử dụng item trong virtual-scroll \n  readonly fieldId = input<string>('');\n  readonly item = input<any>(undefined);\n  readonly itemInContainerVirtualScroll = input<boolean>();\n  //----------------------------------\n  readonly throttleTimeHandlerDraggingEvent = input<number, number | undefined>(0, { transform: value => value || 0 });\n  readonly ignoreStopEvent = input<boolean>();\n  readonly onlyMouseDownStopEvent = input<boolean>();\n  readonly dragRootElement = input<boolean>();\n  readonly groupName = input<string, string | undefined>('groupDragAndDropDefault', { transform: value => value ?? 'groupDragAndDropDefault' });\n  readonly dragBoundary = input<boolean>();\n  readonly dragBoundaryAcceptMouseLeaveContainer = input<boolean>();\n  readonly elementContainer = input<HTMLElement>();\n  readonly zIndex = input<number, number | undefined>(1300, { transform: value => value ?? 1300 });\n  readonly disable = input<boolean>();\n\n  /* OUTPUT */\n  readonly outDragStart = output<IDragStart>();\n  readonly outDragOver = output<IDragOver>();\n  readonly outDragLeave = output<IDragLeave>();\n  readonly outDragEnd = output<IDragEnd>();\n  readonly outDropped = output<IDrop>();\n\n  /* INJECT */\n  private elementRef = inject(ElementRef);\n\n  constructor() {\n    super();\n    effect(() => {\n      if (!this.elementRef?.nativeElement) {\n        return;\n      }\n      const element = this.elementRef.nativeElement as HTMLElement;\n\n      element.classList.remove(`${this.dragDropService.ClassItemDefine}-disable`);\n      if (this.disable() && !element.classList.contains(`${this.dragDropService.ClassItemDefine}-disable`)) {\n        element.classList.add(`${this.dragDropService.ClassItemDefine}-disable`);\n      }\n    });\n  }\n\n  override ngAfterViewInit() {\n    const element = this.elementRef.nativeElement as HTMLElement;\n    if (this.fieldId()) {\n      element.setAttribute('field_id', this.fieldId());\n      if (this.item()) {\n        element.setAttribute('item_id', get(this.item(), this.fieldId()));\n      }\n    }\n    element.setAttribute('groupName', this.groupName());\n    element.classList.add(this.dragDropService.ClassItemDefine);\n    this.dragDropService.OnDragging.pipe(throttleTime(this.throttleTimeHandlerDraggingEvent()), takeUntil(this.onDestroy)).subscribe((eventDragging) => {\n      if (this.disable() || element.getAttribute('disableDragContainer') || (this.fieldId() && this.item() && eventDragging.elementDrag.getAttribute('item_id') === get(this.item(), this.fieldId()))) {\n        return;\n      }\n      const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');\n\n      if (containerById) {\n        if (eventDragging.elementKeepContainer || !this.dragDropService.checkElementOverAcceptElementDrag(containerById.element.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('dropToGroupName'))) {\n          return;\n        }\n      }\n      if (checkMouseOverInContainer(eventDragging.mousePosition, element) && element !== eventDragging.elementDrag && containerById && checkViewInScreen(containerById.element, element, containerById.elementScroll)) {\n        if (this.isDragOver()) {\n          return;\n        }\n        const eventDragOver = { ...eventDragging, elementDragOver: element };\n\n        this.dragDropService.OnDragOver.next(eventDragOver);\n        this.outDragOver.emit(eventDragOver);\n        this.isDragOver.set(true);\n\n        return;\n      }\n\n      if (this.isDragOver()) {\n        const eventDragLeave = { ...eventDragging, elementDragLeave: element };\n        this.isDragOver.set(false);\n        this.dragDropService.OnDragLeave.next(eventDragLeave);\n        this.outDragLeave.emit(eventDragLeave);\n      }\n    });\n\n    this.dragDropService.OnDropContainer.pipe(takeUntil(this.onDestroy)).subscribe((eventDrop) => {\n      if (eventDrop.elementDrop !== element) {\n        return;\n      }\n      const dropEvent = { elementDrag: eventDrop.elementDrag, elementDrop: element, itemDragInfo: eventDrop.itemDragInfo };\n\n      this.outDropped.emit(dropEvent);\n    });\n    const styleTag = document.createElement(\"style\");\n\n    styleTag.textContent = `.libs-ui-drag-drop-item-dragging{cursor:move}`;\n    let nodeClone = element;\n    let distanceStartElementAndMouseLeft = -1;\n    let distanceStartElementAndMouseTop = -1;\n    let contextMenu = false;\n    const stopEventMouse = (mouseEvent: MouseEvent) => {\n      if (!this.ignoreStopEvent()) {\n        mouseEvent.preventDefault();\n        mouseEvent.stopPropagation();\n      }\n    };\n    const updatePositionElementRootAndRemoveNodeClone = () => {\n      if (this.dragRootElement()) {\n        const containerById = this.dragDropService.Container().get(element.getAttribute('groupID') || '');\n\n        const containerItem = this.elementContainer() || containerById?.elementScroll || containerById?.element || document.body;\n        const rectContainer = containerItem.getBoundingClientRect();\n        const rectNodeClone = nodeClone.getBoundingClientRect();\n        const numberSub = Number((getComputedStyle(containerItem).border.match(/\\d+px/gi) || ['0'])[0].replace(/\\D+/ig, '')).valueOf();\n\n        element.style.left = (rectNodeClone.left - rectContainer.left - numberSub) + 'px';\n        element.style.top = (rectNodeClone.top - rectContainer.top - numberSub) + 'px';\n        element.classList.remove('opacity-0');\n      }\n      distanceStartElementAndMouseLeft = -1;\n      distanceStartElementAndMouseTop = -1;\n      nodeClone.remove();\n    };\n\n    fromEvent(document, 'contextmenu').pipe(\n      tap(() => {\n        if (this.isDragging()) {\n          updatePositionElementRootAndRemoveNodeClone();\n        }\n        contextMenu = true;\n\n      }),\n      takeUntil(this.onDestroy)\n    ).subscribe();\n\n    const documentMouseUp = fromEvent<MouseEvent>(document, 'mouseup')\n      .pipe(\n        tap((eventMouseup) => {\n          this.updateMouseEventsWhenMoveOverIframe('auto');\n          this.dragDropService.resetItemClick();\n          stopEventMouse(eventMouseup);\n          if (this.disable() || element.getAttribute('disableDragContainer') || contextMenu || !this.isDragging()) {\n            contextMenu = false;\n\n            return;\n          }\n          contextMenu = false;\n          this.isDragging.set(false);\n          element.removeAttribute(this.dragDropService.TargetItemDragFlag);\n          if (this.itemInContainerVirtualScroll()) {\n            return;\n          }\n          const mousePosition = { clientX: eventMouseup.clientX, clientY: eventMouseup.clientY };\n\n          if (this.dragBoundary() && this.dragBoundaryAcceptMouseLeaveContainer()) {\n            const result = this.getClientPosition(element, mousePosition, distanceStartElementAndMouseLeft, distanceStartElementAndMouseTop, this.dragBoundary(), this.elementContainer());\n\n            mousePosition.clientX = result.clientX;\n            mousePosition.clientY = result.clientY;\n          }\n          const dragEndEvent = { mousePosition, elementDrag: element, itemDragInfo: this.dragDropService.ItemDragInfo };\n\n          this.dragDropService.ItemDragInfo = undefined;\n          this.dragDropService.OnDragEnd.next(dragEndEvent);\n          this.outDragEnd.emit(dragEndEvent);\n\n          document.body.classList.remove('!select-none');\n          nodeClone.classList.remove('libs-ui-drag-drop-item-dragging');\n          styleTag.remove();\n\n          updatePositionElementRootAndRemoveNodeClone();\n        }),\n        takeUntil(this.onDestroy)\n      );\n\n    const elementMouseDown = fromEvent<MouseEvent>(element, 'mousedown').pipe(\n      tap(eventMousedown => {\n        this.dragDropService.ItemClick = element;\n        contextMenu = false;\n        this.updateMouseEventsWhenMoveOverIframe('none');\n        if ((this.disable() || element.getAttribute('disableDragContainer') || !this.isDragging() || this.itemInContainerVirtualScroll()) && !this.onlyMouseDownStopEvent()) {\n          return;\n        }\n        stopEventMouse(eventMousedown);\n      }),\n      takeUntil(this.onDestroy)\n    );\n    const documentMouseMove = fromEvent<MouseEvent>(document, 'mousemove').pipe(tap((eventMousemove) => stopEventMouse(eventMousemove)), takeUntil((documentMouseUp)), takeUntil(this.onDestroy));\n    const drag = elementMouseDown.pipe(mergeMap((mouseEvent: MouseEvent) => documentMouseMove.pipe(startWith((mouseEvent))))) as Observable<MouseEvent>;\n    let ignoreMousedown = false;\n\n    drag.pipe(tap((dragMouseEvent: MouseEvent) => {\n      const rectElement = element.getBoundingClientRect();\n      const viewport = getViewport() as IBoundingClientRect;\n\n      if (this.disable() || element.getAttribute('disableDragContainer') || !dragMouseEvent.clientX || (!ignoreMousedown && dragMouseEvent.type === 'mousedown' && rectElement.height + rectElement.top >= viewport.height)) {\n\n        return;\n      }\n      const { clientX, clientY } = dragMouseEvent;\n\n      if (distanceStartElementAndMouseLeft === -1) {\n        distanceStartElementAndMouseLeft = clientX - rectElement.left;\n      }\n\n      if (distanceStartElementAndMouseTop === -1) {\n        distanceStartElementAndMouseTop = clientY - rectElement.top;\n      }\n    }), takeUntil(this.onDestroy)).subscribe(dragMouseEvent => {\n      if (this.dragDropService.ItemClick.filter(item => item !== element).some(item => element.contains(item))) {\n        return;\n      }\n      if (this.disable() || element.getAttribute('disableDragContainer') || !dragMouseEvent.clientX || dragMouseEvent.type === 'mousedown' || contextMenu || (this.itemInContainerVirtualScroll() && this.isDragging())) {\n        return;\n      }\n      ignoreMousedown = true;\n      const { clientX, clientY } = dragMouseEvent;\n      const mousePosition = { clientX, clientY };\n      const rectElement = element.getBoundingClientRect();\n\n      if (!this.isDragging()) {\n        this.isDragging.set(true);\n        const eventDragStart = { mousePosition, elementDrag: element, itemDragInfo: this.dragDropService.ItemDragInfo };\n\n        element.setAttribute(this.dragDropService.TargetItemDragFlag, 'true');\n        this.dragDropService.OnDragStart.next(eventDragStart);\n        eventDragStart.itemDragInfo = this.dragDropService.ItemDragInfo;\n        this.outDragStart.emit(eventDragStart);\n\n        nodeClone = element.cloneNode(true) as HTMLElement;\n        nodeClone.style.zIndex = `${this.zIndex()}`;\n        nodeClone.classList.add('!fixed');\n        nodeClone.classList.remove('libs-ui-drag-drop-item-origin-placeholder');\n        nodeClone.classList.remove('libs-ui-drag-drop-item-placeholder');\n        nodeClone.appendChild(styleTag);\n        nodeClone.classList.add('libs-ui-drag-drop-item-dragging');\n        nodeClone.style.width = `${rectElement.width}px`;\n        nodeClone.style.height = `${rectElement.height}px`;\n        nodeClone.style.left = `${-999}px`;\n        nodeClone.style.top = `${-999}px`;\n        document.body.classList.add('!select-none');\n        document.body.append(nodeClone);\n        if (this.dragRootElement()) {\n          element.classList.add('opacity-0');\n        }\n\n        if (this.itemInContainerVirtualScroll()) {\n          this.dragDropService.OnDragItemInContainerVirtualScroll.next({\n            itemDragInfo: this.dragDropService.ItemDragInfo,\n            elementDrag: nodeClone,\n            distanceStartElementAndMouseTop,\n            distanceStartElementAndMouseLeft,\n            elementContainer: this.elementContainer(),\n            dragBoundary: this.dragBoundary(),\n            dragBoundaryAcceptMouseLeaveContainer: this.dragBoundaryAcceptMouseLeaveContainer(),\n            ignoreStopEvent: this.ignoreStopEvent()\n          });\n\n          return;\n        }\n      }\n      const result = this.getClientPosition(nodeClone, mousePosition, distanceStartElementAndMouseLeft, distanceStartElementAndMouseTop, this.dragBoundary(), this.elementContainer());\n\n      const elementKeepContainer = result.elementKeepContainer;\n      const left = result.clientX - distanceStartElementAndMouseLeft;\n      const top = result.clientY - distanceStartElementAndMouseTop;\n\n      if (this.dragBoundary() && this.dragBoundaryAcceptMouseLeaveContainer()) {\n        if (clientX < result.viewport.left) {\n          mousePosition.clientX = result.viewport.left;\n        }\n        if (clientX > result.viewport.width) {\n          mousePosition.clientX = result.viewport.width;\n        }\n        if (clientY < result.viewport.top) {\n          mousePosition.clientY = result.viewport.top;\n        }\n        if (clientY > result.viewport.height) {\n          mousePosition.clientY = result.viewport.height;\n        }\n      }\n      nodeClone.style.left = `${left}px`;\n      nodeClone.style.top = `${top}px`;\n\n      const eventDragging = { mousePosition, elementDrag: nodeClone, elementKeepContainer, itemDragInfo: this.dragDropService.ItemDragInfo };\n\n      this.dragDropService.OnDragging.next(eventDragging);\n    });\n  }\n}"]}