@libs-ui/components-drag-drop 0.1.1-1

package/esm2022/drag-drop.service.mjs

@@ -0,0 +1,96 @@
+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.14", ngImport: i0, type: MoLibsSharedDragDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MoLibsSharedDragDropService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", 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,134 @@
+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 {
+    // #region PROPERTY
+    onDestroy = new Subject();
+    // #region OUTPUT
+    outDragEndContainer = output();
+    // #region INJECT
+    dragDropService = inject(MoLibsSharedDragDropService);
+    ngAfterViewInit() {
+        const addClass = () => {
+            document.body.classList.remove('!select-none');
+            document.body.classList.remove('!cursor-move');
+        };
+        const removeClass = () => {
+            document.body.classList.add('!select-none');
+            document.body.classList.add('!cursor-move');
+        };
+        this.dragDropService.OnDragEnd.pipe(takeUntil(this.onDestroy)).subscribe((e) => {
+            this.outDragEndContainer.emit(e);
+        });
+        this.dragDropService.OnDragItemInContainerVirtualScroll.pipe(takeUntil(this.onDestroy)).subscribe((dragItemInContainerVirtualScrollEvent) => {
+            addClass();
+            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);
+                dragItemInContainerVirtualScrollEvent.elementDrag.remove();
+                removeClass();
+            }));
+            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.14", ngImport: i0, type: LibsUiDragItemInContainerVirtualScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: LibsUiDragItemInContainerVirtualScrollDirective, isStandalone: true, selector: "[LibsUiDragItemInContainerVirtualScrollDirective]", outputs: { outDragEndContainer: "outDragEndContainer" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", 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":"AAAA,OAAO,EAAiB,SAAS,EAAa,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEpF,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;;AAQlE,MAAM,OAAO,+CAA+C;IAC1D,mBAAmB;IACT,SAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;IAE1C,iBAAiB;IACR,mBAAmB,GAAG,MAAM,EAAY,CAAC;IAElD,iBAAiB;IACP,eAAe,GAAG,MAAM,CAAC,2BAA2B,CAAC,CAAC;IAEhE,eAAe;QACb,MAAM,QAAQ,GAAG,GAAG,EAAE;YACpB,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;YAC/C,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACjD,CAAC,CAAC;QACF,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YAC5C,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC9C,CAAC,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7E,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,kCAAkC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,qCAAqC,EAAE,EAAE;YAC1I,QAAQ,EAAE,CAAC;YACX,MAAM,cAAc,GAAG,CAAC,UAAsB,EAAE,EAAE;gBAChD,IAAI,CAAC,qCAAqC,CAAC,eAAe,EAAE,CAAC;oBAC3D,UAAU,CAAC,cAAc,EAAE,CAAC;oBAC5B,UAAU,CAAC,eAAe,EAAE,CAAC;gBAC/B,CAAC;YACH,CAAC,CAAC;YACF,MAAM,eAAe,GAAG,SAAS,CAAa,QAAQ,EAAE,SAAS,CAAC,CAAC,IAAI,CACrE,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE;gBACnB,IAAI,CAAC,mCAAmC,CAAC,MAAM,CAAC,CAAC;gBACjD,cAAc,CAAC,YAAY,CAAC,CAAC;gBAC7B,MAAM,aAAa,GAAG,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;gBAEvF,IAAI,qCAAqC,CAAC,YAAY,IAAI,qCAAqC,CAAC,qCAAqC,EAAE,CAAC;oBACtI,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CACnC,qCAAqC,CAAC,WAAW,EACjD,aAAa,EACb,qCAAqC,CAAC,gCAAgC,EACtE,qCAAqC,CAAC,+BAA+B,EACrE,qCAAqC,CAAC,YAAY,EAClD,qCAAqC,CAAC,gBAAgB,CACvD,CAAC;oBAEF,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;oBACvC,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;gBACzC,CAAC;gBACD,MAAM,YAAY,GAAG,EAAE,aAAa,EAAE,WAAW,EAAE,qCAAqC,CAAC,WAAW,EAAE,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;gBAExJ,IAAI,CAAC,eAAe,CAAC,YAAY,GAAG,SAAS,CAAC;gBAC9C,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAClD,qCAAqC,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;gBAC3D,WAAW,EAAE,CAAC;YAChB,CAAC,CAAC,CACH,CAAC;YAEF,SAAS,CAAa,QAAQ,EAAE,WAAW,CAAC;iBACzC,IAAI,CACH,GAAG,CAAC,CAAC,cAAc,EAAE,EAAE;gBACrB,cAAc,CAAC,cAAc,CAAC,CAAC;gBAC/B,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC;gBAC5C,MAAM,aAAa,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;gBAE3C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CACnC,qCAAqC,CAAC,WAAW,EACjD,aAAa,EACb,qCAAqC,CAAC,gCAAgC,EACtE,qCAAqC,CAAC,+BAA+B,EACrE,qCAAqC,CAAC,YAAY,EAClD,qCAAqC,CAAC,gBAAgB,CACvD,CAAC;gBACF,MAAM,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;gBACzD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,GAAG,qCAAqC,CAAC,gCAAgC,CAAC;gBACrG,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,GAAG,qCAAqC,CAAC,+BAA+B,CAAC;gBAEnG,IAAI,qCAAqC,CAAC,YAAY,IAAI,qCAAqC,CAAC,qCAAqC,EAAE,CAAC;oBACtI,IAAI,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;wBACnC,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;oBAC/C,CAAC;oBACD,IAAI,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;wBACpC,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;oBAChD,CAAC;oBACD,IAAI,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;wBAClC,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;oBAC9C,CAAC;oBACD,IAAI,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;wBACrC,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;oBACjD,CAAC;gBACH,CAAC;gBACD,qCAAqC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,IAAI,IAAI,CAAC;gBAC3E,qCAAqC,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;gBAEzE,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,WAAW,EAAE,qCAAqC,CAAC,WAAW,EAAE,oBAAoB,EAAE,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC,CAAC;YACjM,CAAC,CAAC,EACF,SAAS,CAAC,eAAe,CAAC,EAC1B,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;iBACA,SAAS,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,eAAe;IAEL,iBAAiB,CACzB,OAAoB,EACpB,aAAmD,EACnD,gCAAwC,EACxC,+BAAuC,EACvC,YAAsB,EACtB,gBAA8B;QAE9B,IAAI,QAAQ,GAAG,WAAW,EAAyB,CAAC;QACpD,MAAM,WAAW,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;QACpD,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;QAClG,MAAM,aAAa,GAAG,gBAAgB,IAAI,aAAa,EAAE,aAAa,IAAI,aAAa,EAAE,OAAO,IAAI,QAAQ,CAAC,IAAI,CAAC;QAClH,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,aAAa,CAAC;QAEzC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC;QAClB,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC;QACjB,IAAI,YAAY,EAAE,CAAC;YACjB,QAAQ,GAAG,wBAAwB,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAC,CAAC;YAC3E,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC;YACjD,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC;QAClD,CAAC;QACD,IAAI,oBAAoB,GAAG,KAAK,CAAC;QAEjC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,KAAK,IAAI,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,IAAI,IAAI,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACnH,oBAAoB,GAAG,IAAI,CAAC;QAC9B,CAAC;QAED,IAAI,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,GAAG,gCAAgC,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;YACtF,OAAO,IAAI,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,GAAG,gCAAgC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;QAC/F,CAAC;QACD,IAAI,OAAO,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,+BAA+B,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;YACvF,OAAO,IAAI,OAAO,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,+BAA+B,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC;QAChG,CAAC;QACD,IAAI,OAAO,GAAG,gCAAgC,GAAG,CAAC,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrG,OAAO,GAAG,CAAC,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,gCAAgC,CAAC;QACnG,CAAC;QACD,IAAI,OAAO,GAAG,+BAA+B,GAAG,CAAC,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACnG,OAAO,GAAG,CAAC,YAAY,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,+BAA+B,CAAC;QACjG,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,CAAC;IAC9D,CAAC;IAES,mCAAmC,CAAC,aAA8B;QAC1E,MAAM,MAAM,GAAG,QAAQ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QAEvD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,GAAG,aAAa,CAAC;QAChD,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC5B,CAAC;wGAnKU,+CAA+C;4FAA/C,+CAA+C;;4FAA/C,+CAA+C;kBAL3D,SAAS;mBAAC;oBACT,8DAA8D;oBAC9D,QAAQ,EAAE,mDAAmD;oBAC7D,UAAU,EAAE,IAAI;iBACjB","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})\nexport class LibsUiDragItemInContainerVirtualScrollDirective implements AfterViewInit, OnDestroy {\n  // #region PROPERTY\n  protected onDestroy = new Subject<void>();\n\n  // #region OUTPUT\n  readonly outDragEndContainer = output<IDragEnd>();\n\n  // #region INJECT\n  protected dragDropService = inject(MoLibsSharedDragDropService);\n\n  ngAfterViewInit(): void {\n    const addClass = () => {\n      document.body.classList.remove('!select-none');\n      document.body.classList.remove('!cursor-move');\n    };\n    const removeClass = () => {\n      document.body.classList.add('!select-none');\n      document.body.classList.add('!cursor-move');\n    };\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      addClass();\n      const stopEventMouse = (mouseEvent: MouseEvent) => {\n        if (!dragItemInContainerVirtualScrollEvent.ignoreStopEvent) {\n          mouseEvent.preventDefault();\n          mouseEvent.stopPropagation();\n        }\n      };\n      const documentMouseUp = fromEvent<MouseEvent>(document, 'mouseup').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(\n              dragItemInContainerVirtualScrollEvent.elementDrag,\n              mousePosition,\n              dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft,\n              dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop,\n              dragItemInContainerVirtualScrollEvent.dragBoundary,\n              dragItemInContainerVirtualScrollEvent.elementContainer\n            );\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          dragItemInContainerVirtualScrollEvent.elementDrag.remove();\n          removeClass();\n        })\n      );\n\n      fromEvent<MouseEvent>(document, 'mousemove')\n        .pipe(\n          tap((eventMousemove) => {\n            stopEventMouse(eventMousemove);\n            const { clientX, clientY } = eventMousemove;\n            const mousePosition = { clientX, clientY };\n\n            const result = this.getClientPosition(\n              dragItemInContainerVirtualScrollEvent.elementDrag,\n              mousePosition,\n              dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseLeft,\n              dragItemInContainerVirtualScrollEvent.distanceStartElementAndMouseTop,\n              dragItemInContainerVirtualScrollEvent.dragBoundary,\n              dragItemInContainerVirtualScrollEvent.elementContainer\n            );\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          }),\n          takeUntil(documentMouseUp),\n          takeUntil(this.onDestroy)\n        )\n        .subscribe();\n    });\n  }\n\n  /* FUNCTIONS */\n\n  protected getClientPosition(\n    element: HTMLElement,\n    mousePosition: { clientX: number; clientY: number },\n    distanceStartElementAndMouseLeft: number,\n    distanceStartElementAndMouseTop: number,\n    dragBoundary?: boolean,\n    elementContainer?: HTMLElement\n  ): { 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}\n"]}

package/esm2022/drag-item.directive.mjs

@@ -0,0 +1,267 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Directive, ElementRef, effect, inject, input, output, signal } from '@angular/core';
+import { checkMouseOverInContainer, checkViewInScreen, get, getDragEventByElement, getViewport } from '@libs-ui/utils';
+import { fromEvent, 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 {
+    // #region PROPERTY
+    isDragOver = signal(false);
+    isDragging = signal(false);
+    // #region 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();
+    dragBoundary = input();
+    dragBoundaryAcceptMouseLeaveContainer = input();
+    elementContainer = input();
+    zIndex = input(1300, { transform: (value) => value ?? 1300 });
+    disable = input();
+    // #region OUTPUT
+    outDragStart = output();
+    outDragOver = output();
+    outDragLeave = output();
+    outDragEnd = output();
+    outDropped = output();
+    // #region 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.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+/gi, '')).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();
+        let ignoreMousedown = false;
+        getDragEventByElement({
+            elementMouseDown: element,
+            functionMouseDown: (event) => {
+                this.dragDropService.ItemClick = element;
+                contextMenu = false;
+                this.updateMouseEventsWhenMoveOverIframe('none');
+                if ((this.disable() || element.getAttribute('disableDragContainer') || !this.isDragging() || this.itemInContainerVirtualScroll()) && !this.onlyMouseDownStopEvent()) {
+                    return;
+                }
+                stopEventMouse(event);
+            },
+            functionMouseMove: (event) => {
+                stopEventMouse(event);
+            },
+            functionMouseUp: (event) => {
+                this.updateMouseEventsWhenMoveOverIframe('auto');
+                this.dragDropService.resetItemClick();
+                stopEventMouse(event);
+                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: event.clientX, clientY: event.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);
+                nodeClone.classList.remove('libs-ui-drag-drop-item-dragging');
+                styleTag.remove();
+                updatePositionElementRootAndRemoveNodeClone();
+            },
+            onDestroy: this.onDestroy,
+        })
+            .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;
+            }
+        }))
+            .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.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.14", ngImport: i0, type: LibsUiDragItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", 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 }, 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.14", 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, getDragEventByElement, getViewport } from '@libs-ui/utils';\nimport { fromEvent, 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  // #region PROPERTY\n  private isDragOver = signal<boolean>(false);\n  private isDragging = signal<boolean>(false);\n\n  // #region 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 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  // #region 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  // #region 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.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 (\n          eventDragging.elementKeepContainer ||\n          !this.dragDropService.checkElementOverAcceptElementDrag(containerById.element.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('groupName'), eventDragging.elementDrag.getAttribute('dropToGroupName'))\n        ) {\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+/gi, '')).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')\n      .pipe(\n        tap(() => {\n          if (this.isDragging()) {\n            updatePositionElementRootAndRemoveNodeClone();\n          }\n          contextMenu = true;\n        }),\n        takeUntil(this.onDestroy)\n      )\n      .subscribe();\n\n    let ignoreMousedown = false;\n\n    getDragEventByElement({\n      elementMouseDown: element,\n      functionMouseDown: (event: MouseEvent) => {\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(event);\n      },\n      functionMouseMove: (event: MouseEvent) => {\n        stopEventMouse(event);\n      },\n      functionMouseUp: (event: MouseEvent) => {\n        this.updateMouseEventsWhenMoveOverIframe('auto');\n        this.dragDropService.resetItemClick();\n        stopEventMouse(event);\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: event.clientX, clientY: event.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        nodeClone.classList.remove('libs-ui-drag-drop-item-dragging');\n        styleTag.remove();\n\n        updatePositionElementRootAndRemoveNodeClone();\n      },\n      onDestroy: this.onDestroy,\n    })\n      .pipe(\n        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            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        })\n      )\n      .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.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}\n"]}