@igo2/common 18.0.0-next.9 → 18.0.0

package/drag-drop/drag-drop.module.d.ts

@@ -1,12 +1,13 @@
 import { ModuleWithProviders } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./drag-drop.directive";
+import * as i2 from "./tree-drag-drop/tree-drag-drop.directive";
 /**
  * @deprecated import the DragAndDropDirective directly
  */
 export declare class IgoDrapDropModule {
     static forRoot(): ModuleWithProviders<IgoDrapDropModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<IgoDrapDropModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoDrapDropModule, never, [typeof i1.DragAndDropDirective], [typeof i1.DragAndDropDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoDrapDropModule, never, [typeof i1.DragAndDropDirective, typeof i2.TreeDragDropDirective], [typeof i1.DragAndDropDirective, typeof i2.TreeDragDropDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<IgoDrapDropModule>;
 }

package/drag-drop/public_api.d.ts

@@ -1,2 +1,3 @@
 export * from './drag-drop.module';
 export * from './drag-drop.directive';
+export * from './tree-drag-drop';

package/drag-drop/tree-drag-drop/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tree-drag-drop.directive';
+export * from './tree-drag-drop.interface';

package/drag-drop/tree-drag-drop/tree-drag-drop.directive.d.ts

@@ -0,0 +1,85 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, QueryList, Renderer2 } from '@angular/core';
+import { MatTreeNode } from '@angular/material/tree';
+import { DropPositionType, TreeFlatNode } from './tree-drag-drop.interface';
+import * as i0 from "@angular/core";
+export interface TreeDropEvent<T = any> {
+    node: TreeFlatNode<T>;
+    ref: TreeFlatNode<T>;
+    position: DropPositionType;
+}
+interface DragNodeListeners {
+    element: HTMLElement;
+    listeners: [string, EventListenerOrEventListenerObject][];
+}
+export interface DropPermission {
+    canDrop: boolean;
+    message?: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * This directive should be use with a MatTree flatened
+ * It should add all logic to drag the MatTreeNode and connect the (onDrop) output
+ * Class added:
+ *    Tree: --dragging
+ *    Node: --drag-hover | --dragged
+ */
+export declare class TreeDragDropDirective implements AfterContentInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    draggedNode: TreeFlatNode;
+    dropNodeTarget: TreeFlatNode;
+    expandTimeout: number;
+    nodesListeners: DragNodeListeners[] | undefined;
+    dropLineTarget: HTMLElement;
+    highlightedNode: SelectionModel<TreeFlatNode<any>>;
+    treeControl: FlatTreeControl<TreeFlatNode>;
+    /** The default is 5 */
+    maxLevel: number;
+    set treeDragDropIsDisabled(disabled: boolean);
+    private isDisabled;
+    dragStart: EventEmitter<TreeFlatNode<any>>;
+    onDrop: EventEmitter<TreeDropEvent<any>>;
+    onDropError: EventEmitter<DropPermission>;
+    hostDragOver(event: Event): void;
+    hostDrop(event: DragEvent): void;
+    dragging: boolean;
+    nodes: QueryList<MatTreeNode<TreeFlatNode>>;
+    constructor(elementRef: ElementRef, renderer: Renderer2);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onDragStart(node: TreeFlatNode): void;
+    dragEnd(): void;
+    dragOver(node: TreeFlatNode, event: DragEvent): void;
+    dragLeave(): void;
+    drop(event: DragEvent): void;
+    private addNodeClass;
+    private removeNodeClass;
+    private addAllListener;
+    private addListener;
+    private removeAllListener;
+    private setHighlightedNode;
+    private addDropTargetLine;
+    private removeDropTargetLine;
+    private updateDropTargetLinePosition;
+    private handleGroupExpansion;
+    private getNodeElement;
+    private canDropNode;
+    private canDropGroup;
+    private validateMaxHierarchyLevel;
+    private isHoverDescendant;
+    private getPosition;
+    private getPositionY;
+    private getPositionType;
+    private getPositionLevel;
+    /**
+     * @param level if level is defined with go to the defined levle to find ancestor. Sinon on prend le current ancestor
+     */
+    private getNodeAncestors;
+    private getDirectDescendants;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDragDropDirective, "[igoTreeDragDrop]", never, { "treeControl": { "alias": "treeControl"; "required": true; }; "maxLevel": { "alias": "maxLevel"; "required": false; }; "treeDragDropIsDisabled": { "alias": "treeDragDropIsDisabled"; "required": false; }; }, { "dragStart": "dragStart"; "onDrop": "onDrop"; "onDropError": "onDropError"; }, ["nodes"], never, true, never>;
+    static ngAcceptInputType_treeDragDropIsDisabled: unknown;
+}
+export {};

package/drag-drop/tree-drag-drop/tree-drag-drop.interface.d.ts

@@ -0,0 +1,15 @@
+export interface TreeFlatNode<T = any> {
+    id: string;
+    isGroup: boolean;
+    disabled: boolean;
+    level: number;
+    descendantLevels?: number;
+    data: T;
+}
+export interface DropPosition {
+    x: number;
+    y: number;
+    level: number;
+    type: DropPositionType;
+}
+export type DropPositionType = 'above' | 'below' | 'inside';

package/esm2022/drag-drop/drag-drop.module.mjs

@@ -1,5 +1,6 @@
 import { NgModule } from '@angular/core';
 import { DragAndDropDirective } from './drag-drop.directive';
+import { TreeDragDropDirective } from './tree-drag-drop/tree-drag-drop.directive';
 import * as i0 from "@angular/core";
 /**
  * @deprecated import the DragAndDropDirective directly
@@ -12,14 +13,14 @@ export class IgoDrapDropModule {
         };
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoDrapDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoDrapDropModule, imports: [DragAndDropDirective], exports: [DragAndDropDirective] });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoDrapDropModule, imports: [DragAndDropDirective, TreeDragDropDirective], exports: [DragAndDropDirective, TreeDragDropDirective] });
     static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoDrapDropModule });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoDrapDropModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [DragAndDropDirective],
-                    exports: [DragAndDropDirective]
+                    imports: [DragAndDropDirective, TreeDragDropDirective],
+                    exports: [DragAndDropDirective, TreeDragDropDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1kcm9wLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9kcmFnLWRyb3Avc3JjL2RyYWctZHJvcC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUF1QixRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFOUQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRTdEOztHQUVHO0FBS0gsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixNQUFNLENBQUMsT0FBTztRQUNaLE9BQU87WUFDTCxRQUFRLEVBQUUsaUJBQWlCO1lBQzNCLFNBQVMsRUFBRSxFQUFFO1NBQ2QsQ0FBQztJQUNKLENBQUM7d0dBTlUsaUJBQWlCO3lHQUFqQixpQkFBaUIsWUFIbEIsb0JBQW9CLGFBQ3BCLG9CQUFvQjt5R0FFbkIsaUJBQWlCOzs0RkFBakIsaUJBQWlCO2tCQUo3QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLG9CQUFvQixDQUFDO29CQUMvQixPQUFPLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQztpQkFDaEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2R1bGVXaXRoUHJvdmlkZXJzLCBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBEcmFnQW5kRHJvcERpcmVjdGl2ZSB9IGZyb20gJy4vZHJhZy1kcm9wLmRpcmVjdGl2ZSc7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgaW1wb3J0IHRoZSBEcmFnQW5kRHJvcERpcmVjdGl2ZSBkaXJlY3RseVxuICovXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbRHJhZ0FuZERyb3BEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbRHJhZ0FuZERyb3BEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIElnb0RyYXBEcm9wTW9kdWxlIHtcbiAgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVyczxJZ29EcmFwRHJvcE1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogSWdvRHJhcERyb3BNb2R1bGUsXG4gICAgICBwcm92aWRlcnM6IFtdXG4gICAgfTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1kcm9wLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9kcmFnLWRyb3Avc3JjL2RyYWctZHJvcC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUF1QixRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFOUQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDN0QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7O0FBRWxGOztHQUVHO0FBS0gsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixNQUFNLENBQUMsT0FBTztRQUNaLE9BQU87WUFDTCxRQUFRLEVBQUUsaUJBQWlCO1lBQzNCLFNBQVMsRUFBRSxFQUFFO1NBQ2QsQ0FBQztJQUNKLENBQUM7d0dBTlUsaUJBQWlCO3lHQUFqQixpQkFBaUIsWUFIbEIsb0JBQW9CLEVBQUUscUJBQXFCLGFBQzNDLG9CQUFvQixFQUFFLHFCQUFxQjt5R0FFMUMsaUJBQWlCOzs0RkFBakIsaUJBQWlCO2tCQUo3QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLG9CQUFvQixFQUFFLHFCQUFxQixDQUFDO29CQUN0RCxPQUFPLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxxQkFBcUIsQ0FBQztpQkFDdkQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2R1bGVXaXRoUHJvdmlkZXJzLCBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBEcmFnQW5kRHJvcERpcmVjdGl2ZSB9IGZyb20gJy4vZHJhZy1kcm9wLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBUcmVlRHJhZ0Ryb3BEaXJlY3RpdmUgfSBmcm9tICcuL3RyZWUtZHJhZy1kcm9wL3RyZWUtZHJhZy1kcm9wLmRpcmVjdGl2ZSc7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgaW1wb3J0IHRoZSBEcmFnQW5kRHJvcERpcmVjdGl2ZSBkaXJlY3RseVxuICovXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbRHJhZ0FuZERyb3BEaXJlY3RpdmUsIFRyZWVEcmFnRHJvcERpcmVjdGl2ZV0sXG4gIGV4cG9ydHM6IFtEcmFnQW5kRHJvcERpcmVjdGl2ZSwgVHJlZURyYWdEcm9wRGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBJZ29EcmFwRHJvcE1vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KCk6IE1vZHVsZVdpdGhQcm92aWRlcnM8SWdvRHJhcERyb3BNb2R1bGU+IHtcbiAgICByZXR1cm4ge1xuICAgICAgbmdNb2R1bGU6IElnb0RyYXBEcm9wTW9kdWxlLFxuICAgICAgcHJvdmlkZXJzOiBbXVxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/esm2022/drag-drop/public_api.mjs

@@ -1,3 +1,4 @@
 export * from './drag-drop.module';
 export * from './drag-drop.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9kcmFnLWRyb3Avc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcmFnLWRyb3AubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1kcm9wLmRpcmVjdGl2ZSc7XG4iXX0=
+export * from './tree-drag-drop';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9kcmFnLWRyb3Avc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYWctZHJvcC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWRyb3AuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJlZS1kcmFnLWRyb3AnO1xuIl19

package/esm2022/drag-drop/tree-drag-drop/index.mjs

@@ -0,0 +1,3 @@
+export * from './tree-drag-drop.directive';
+export * from './tree-drag-drop.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vZHJhZy1kcm9wL3NyYy90cmVlLWRyYWctZHJvcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZWUtZHJhZy1kcm9wLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUtZHJhZy1kcm9wLmludGVyZmFjZSc7XG4iXX0=

package/esm2022/drag-drop/tree-drag-drop/tree-drag-drop.directive.mjs

@@ -0,0 +1,391 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { ContentChildren, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, QueryList, Renderer2, booleanAttribute } from '@angular/core';
+import { MatTreeNode } from '@angular/material/tree';
+import * as i0 from "@angular/core";
+/**
+ * This directive should be use with a MatTree flatened
+ * It should add all logic to drag the MatTreeNode and connect the (onDrop) output
+ * Class added:
+ *    Tree: --dragging
+ *    Node: --drag-hover | --dragged
+ */
+export class TreeDragDropDirective {
+    elementRef;
+    renderer;
+    draggedNode;
+    dropNodeTarget;
+    expandTimeout;
+    nodesListeners;
+    dropLineTarget;
+    highlightedNode = new SelectionModel();
+    treeControl;
+    /** The default is 5 */
+    maxLevel = 5;
+    set treeDragDropIsDisabled(disabled) {
+        this.isDisabled = disabled;
+        disabled ? this.removeAllListener() : this.addAllListener();
+    }
+    isDisabled = false;
+    dragStart = new EventEmitter();
+    // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+    onDrop = new EventEmitter(null);
+    // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+    onDropError = new EventEmitter();
+    hostDragOver(event) {
+        event.preventDefault();
+    }
+    hostDrop(event) {
+        this.drop(event);
+    }
+    dragging;
+    nodes;
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.onDrop.subscribe(() => this.dragEnd());
+        this.highlightedNode.changed.subscribe((change) => {
+            if (change.removed.length) {
+                this.removeNodeClass(change.removed[0].id, '--drag-hover');
+            }
+            if (change.added.length) {
+                this.addNodeClass(change.added[0].id, '--drag-hover');
+            }
+        });
+    }
+    ngAfterContentInit() {
+        this.nodes.changes.subscribe(() => {
+            this.addAllListener();
+        });
+    }
+    ngOnDestroy() {
+        this.removeAllListener();
+    }
+    onDragStart(node) {
+        this.dragging = true;
+        this.draggedNode = node;
+        this.addNodeClass(node.id, '--dragged');
+        this.dragStart.emit(node);
+    }
+    dragEnd() {
+        this.dragging = false;
+        if (this.draggedNode) {
+            this.removeNodeClass(this.draggedNode.id, '--dragged');
+            this.draggedNode = null;
+        }
+        this.dragLeave();
+        this.removeDropTargetLine();
+    }
+    dragOver(node, event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.dropNodeTarget = node;
+        const position = this.getPosition(event, node);
+        this.updateDropTargetLinePosition(position);
+        this.setHighlightedNode(node);
+        this.handleGroupExpansion(node, position.type === 'inside');
+    }
+    dragLeave() {
+        clearTimeout(this.expandTimeout);
+        this.expandTimeout = null;
+        this.highlightedNode.clear();
+    }
+    drop(event) {
+        if (!this.dropNodeTarget || this.isDisabled) {
+            return;
+        }
+        const dropPosition = this.getPosition(event, this.dropNodeTarget);
+        const validation = this.canDropNode(this.dropNodeTarget, dropPosition);
+        if (!validation.canDrop) {
+            this.onDropError.emit(validation);
+            return;
+        }
+        // Allow to drop a last child outside is group. We refer to it's ancestor for the target
+        if (dropPosition.type === 'below' &&
+            dropPosition.level !== this.dropNodeTarget.level) {
+            this.dropNodeTarget = this.getNodeAncestors(this.dropNodeTarget.id, dropPosition.level);
+        }
+        if (this.dropNodeTarget.isGroup) {
+            if (dropPosition.type === 'inside') {
+                const isExpanded = this.treeControl.isExpanded(this.dropNodeTarget);
+                if (isExpanded) {
+                    const children = this.getDirectDescendants(this.dropNodeTarget);
+                    if (children[0]?.id === this.draggedNode.id) {
+                        return;
+                    }
+                }
+                this.treeControl.expand(this.dropNodeTarget);
+                return this.onDrop.emit({
+                    node: this.draggedNode,
+                    ref: this.dropNodeTarget,
+                    position: dropPosition.type
+                });
+            }
+        }
+        if (dropPosition.type === 'below' &&
+            dropPosition.level !== this.dropNodeTarget.level) {
+            const ancestor = this.getNodeAncestors(this.dropNodeTarget.id);
+            return this.onDrop.emit({
+                node: this.draggedNode,
+                ref: ancestor,
+                position: dropPosition.type
+            });
+        }
+        this.onDrop.emit({
+            node: this.draggedNode,
+            ref: this.dropNodeTarget,
+            position: dropPosition.type
+        });
+    }
+    addNodeClass(id, className) {
+        const node = this.nodes.find((node) => node.data.id === id);
+        this.renderer.addClass(node['_elementRef'].nativeElement, className);
+    }
+    removeNodeClass(id, className) {
+        const node = this.nodes.find((node) => node.data.id === id);
+        this.renderer.removeClass(node['_elementRef'].nativeElement, className);
+    }
+    addAllListener() {
+        if (this.isDisabled) {
+            return;
+        }
+        const nodes = this.nodes?.toArray();
+        if (this.nodesListeners) {
+            this.removeAllListener();
+        }
+        this.nodesListeners = nodes?.map((node) => this.addListener(node));
+    }
+    addListener(node) {
+        const element = node['_elementRef'].nativeElement;
+        const listeners = [
+            ['dragstart', () => this.onDragStart(node.data)],
+            ['dragend', () => this.dragEnd()],
+            ['dragover', (event) => this.dragOver(node.data, event)],
+            ['dragleave', () => this.dragLeave()]
+        ];
+        element.setAttribute('draggable', 'true');
+        listeners.forEach(([type, listener]) => element.addEventListener(type, listener));
+        return { element, listeners };
+    }
+    removeAllListener() {
+        this.nodesListeners?.forEach(({ element, listeners }) => {
+            listeners.forEach(([type, listener]) => {
+                element.setAttribute('draggable', 'false');
+                element.removeEventListener(type, listener);
+            });
+        });
+        this.nodesListeners = null;
+    }
+    setHighlightedNode(node) {
+        const toHighlight = node.isGroup ? node : this.getNodeAncestors(node.id);
+        toHighlight
+            ? this.highlightedNode.select(toHighlight)
+            : this.highlightedNode.clear();
+    }
+    addDropTargetLine() {
+        const target = this.renderer.createElement('div');
+        target.classList.add('drop-target-line');
+        target.setAttribute('style', `position: absolute; top: 0; width: 100%; pointer-events: none; z-index: 4; height: 2px; background-color: black; transition: margin-left 150ms;`);
+        this.dropLineTarget = target;
+        this.renderer.appendChild(this.elementRef.nativeElement.parentElement, this.dropLineTarget);
+    }
+    removeDropTargetLine() {
+        if (!this.dropLineTarget) {
+            return;
+        }
+        this.renderer.removeChild(this.elementRef.nativeElement.parentElement, this.dropLineTarget);
+        this.dropLineTarget = null;
+    }
+    updateDropTargetLinePosition(position) {
+        if (!this.dropLineTarget) {
+            this.addDropTargetLine();
+        }
+        if (position.type === 'inside') {
+            return this.removeDropTargetLine();
+        }
+        this.renderer.setStyle(this.dropLineTarget, 'margin-left', position.level * 24 + 20 + 'px');
+        this.renderer.setStyle(this.dropLineTarget, 'transform', 'translate3d(0,' + position.y + 'px, 0)');
+    }
+    handleGroupExpansion(node, isInside) {
+        if (!isInside) {
+            return this.dragLeave();
+        }
+        const isOpen = this.treeControl.isExpanded(node);
+        if (!isOpen && !this.expandTimeout) {
+            this.expandTimeout = window.setTimeout(() => {
+                this.treeControl.expand(node);
+            }, 1200);
+        }
+    }
+    getNodeElement(node) {
+        const treeNode = this.nodes.find((n) => n.data.id === node.id);
+        return treeNode?.['_elementRef'].nativeElement;
+    }
+    canDropNode(hoveredNode, position) {
+        if (this.draggedNode.isGroup) {
+            return this.canDropGroup(hoveredNode, position);
+        }
+        const hasMaxLevelRestrictions = this.validateMaxHierarchyLevel(position);
+        if (hasMaxLevelRestrictions) {
+            return hasMaxLevelRestrictions;
+        }
+        return { canDrop: true };
+    }
+    canDropGroup(hoveredNode, position) {
+        // On ne veut pas permettre le Drop pour un groupe qui s'auto référence
+        if (hoveredNode.id === this.draggedNode.id) {
+            return {
+                canDrop: false,
+                message: 'igo.common.dragDrop.cannot.dropInsideItself'
+            };
+        }
+        const hasMaxLevelRestrictions = this.validateMaxHierarchyLevel(position);
+        if (hasMaxLevelRestrictions) {
+            return hasMaxLevelRestrictions;
+        }
+        const isHoverDescendant = this.isHoverDescendant(hoveredNode.id);
+        return {
+            canDrop: !isHoverDescendant,
+            message: isHoverDescendant && 'igo.common.dragDrop.cannot.dropInsideItself'
+        };
+    }
+    validateMaxHierarchyLevel(position) {
+        if (!this.maxLevel) {
+            return;
+        }
+        let level = position.type === 'inside' ? position.level + 1 : position.level;
+        if (this.draggedNode.isGroup) {
+            // We add an extra level +1 to avoid empty group in group
+            level = level + (this.draggedNode.descendantLevels ?? 0) + 1;
+        }
+        if (level > this.maxLevel) {
+            return {
+                canDrop: false,
+                message: 'igo.common.dragDrop.cannot.maxLevel',
+                params: { value: this.maxLevel }
+            };
+        }
+    }
+    isHoverDescendant(id) {
+        return this.treeControl
+            .getDescendants(this.draggedNode)
+            .some((child) => child.id === id);
+    }
+    getPosition(event, hoveredNode) {
+        if (this.draggedNode.isGroup) {
+            if (this.isHoverDescendant(hoveredNode.id)) {
+                hoveredNode = this.draggedNode;
+            }
+        }
+        let positionType = this.getPositionType(event, hoveredNode);
+        const bellowOpenedGroup = hoveredNode.isGroup &&
+            positionType === 'below' &&
+            this.treeControl.isExpanded(hoveredNode);
+        if (bellowOpenedGroup) {
+            positionType = 'inside';
+        }
+        return {
+            x: event.x,
+            y: this.getPositionY(hoveredNode, positionType),
+            level: this.getPositionLevel(hoveredNode, positionType, event.x),
+            type: positionType
+        };
+    }
+    getPositionY(node, type) {
+        const element = this.getNodeElement(node);
+        const rect = element.getBoundingClientRect();
+        return type === 'below'
+            ? element.offsetTop + rect.height - 1
+            : element.offsetTop + 1;
+    }
+    getPositionType(event, hoveredNode) {
+        const target = this.getNodeElement(hoveredNode);
+        const rect = target.getBoundingClientRect();
+        const middle = rect.top + rect.height / 2;
+        const y = event.y;
+        const selfReferencing = this.draggedNode.id === hoveredNode.id;
+        if (hoveredNode.isGroup && !selfReferencing) {
+            const tolerence = 5;
+            if (y <= middle + tolerence && y >= middle - tolerence) {
+                return 'inside';
+            }
+        }
+        const isBelow = y > middle;
+        return isBelow ? 'below' : 'above';
+    }
+    getPositionLevel(hoveredNode, type, x) {
+        if (hoveredNode.level === 0) {
+            return 0;
+        }
+        const ancestor = this.getNodeAncestors(hoveredNode.id);
+        const children = this.getDirectDescendants(ancestor);
+        const lastChild = [...children].pop();
+        if (type === 'below' && lastChild.id === hoveredNode.id) {
+            const target = this.getNodeElement(hoveredNode);
+            const rect = target.getBoundingClientRect();
+            const indentation = 24;
+            const xMin = rect.x + indentation;
+            const xMax = xMin + indentation * hoveredNode.level;
+            const isInsideSameGroup = x > xMax;
+            if (!isInsideSameGroup) {
+                const levelSubstracted = Math.round((xMax - x) / indentation);
+                return Math.max(0, hoveredNode.level - levelSubstracted);
+            }
+        }
+        return hoveredNode.level;
+    }
+    /**
+     * @param level if level is defined with go to the defined levle to find ancestor. Sinon on prend le current ancestor
+     */
+    getNodeAncestors(id, level) {
+        const nodes = this.treeControl.dataNodes;
+        const index = nodes.findIndex((node) => node.id === id);
+        const targetLevel = level ?? Math.max(0, nodes[index].level - 1);
+        return nodes
+            .slice(0, index)
+            .reverse()
+            .find((node) => node.level === targetLevel);
+    }
+    getDirectDescendants(node) {
+        const level = node.level + 1;
+        return this.treeControl
+            .getDescendants(node)
+            .filter((child) => child.level === level);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDropDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.13", type: TreeDragDropDirective, isStandalone: true, selector: "[igoTreeDragDrop]", inputs: { treeControl: "treeControl", maxLevel: "maxLevel", treeDragDropIsDisabled: ["treeDragDropIsDisabled", "treeDragDropIsDisabled", booleanAttribute] }, outputs: { dragStart: "dragStart", onDrop: "onDrop", onDropError: "onDropError" }, host: { listeners: { "dragover": "hostDragOver($event)", "drop": "hostDrop($event)" }, properties: { "class.--dragging": "this.dragging" } }, queries: [{ propertyName: "nodes", predicate: MatTreeNode, descendants: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoTreeDragDrop]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { treeControl: [{
+                type: Input,
+                args: [{ required: true }]
+            }], maxLevel: [{
+                type: Input
+            }], treeDragDropIsDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], dragStart: [{
+                type: Output
+            }], onDrop: [{
+                type: Output
+            }], onDropError: [{
+                type: Output
+            }], hostDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], hostDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }], dragging: [{
+                type: HostBinding,
+                args: ['class.--dragging']
+            }], nodes: [{
+                type: ContentChildren,
+                args: [MatTreeNode, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-drag-drop.directive.js","sourceRoot":"","sources":["../../../../../packages/common/drag-drop/src/tree-drag-drop/tree-drag-drop.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,eAAe,EACf,SAAS,EACT,UAAU,EACV,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,KAAK,EAEL,MAAM,EACN,SAAS,EACT,SAAS,EACT,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;;AA0BrD;;;;;;GAMG;AAKH,MAAM,OAAO,qBAAqB;IA0CtB;IACA;IA1CV,WAAW,CAAe;IAC1B,cAAc,CAAe;IAC7B,aAAa,CAAS;IACtB,cAAc,CAAkC;IAChD,cAAc,CAAc;IAC5B,eAAe,GAAG,IAAI,cAAc,EAAgB,CAAC;IAE1B,WAAW,CAAgC;IAEtE,uBAAuB;IACd,QAAQ,GAAG,CAAC,CAAC;IAEtB,IACI,sBAAsB,CAAC,QAAiB;QAC1C,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC;QAC3B,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;IAC9D,CAAC;IACO,UAAU,GAAG,KAAK,CAAC;IAEjB,SAAS,GAAG,IAAI,YAAY,EAAgB,CAAC;IAEvD,+DAA+D;IACrD,MAAM,GAAG,IAAI,YAAY,CAAgB,IAAI,CAAC,CAAC;IAEzD,+DAA+D;IACrD,WAAW,GAAG,IAAI,YAAY,EAAkB,CAAC;IAErB,YAAY,CAAC,KAAY;QAC7D,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAEiC,QAAQ,CAAC,KAAgB;QACzD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAEgC,QAAQ,CAAU;IAGnD,KAAK,CAAuC;IAE5C,YACU,UAAsB,EACtB,QAAmB;QADnB,eAAU,GAAV,UAAU,CAAY;QACtB,aAAQ,GAAR,QAAQ,CAAW;QAE3B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAE5C,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YAChD,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC1B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;YAC7D,CAAC;YAED,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;gBACxB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;YACxD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE;YAChC,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,WAAW,CAAC,IAAkB;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;QAExC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;YACvD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAC1B,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,QAAQ,CAAC,IAAkB,EAAE,KAAgB;QAC3C,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAE3B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAE/C,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;QAE5C,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAE9B,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED,SAAS;QACP,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,CAAC,KAAgB;QACnB,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAC5C,OAAO;QACT,CAAC;QAED,MAAM,YAAY,GAAiB,IAAI,CAAC,WAAW,CACjD,KAAK,EACL,IAAI,CAAC,cAAc,CACpB,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QACvE,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClC,OAAO;QACT,CAAC;QAED,wFAAwF;QACxF,IACE,YAAY,CAAC,IAAI,KAAK,OAAO;YAC7B,YAAY,CAAC,KAAK,KAAK,IAAI,CAAC,cAAc,CAAC,KAAK,EAChD,CAAC;YACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,gBAAgB,CACzC,IAAI,CAAC,cAAc,CAAC,EAAE,EACtB,YAAY,CAAC,KAAK,CACnB,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;YAChC,IAAI,YAAY,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACnC,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBACpE,IAAI,UAAU,EAAE,CAAC;oBACf,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;oBAChE,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;wBAC5C,OAAO;oBACT,CAAC;gBACH,CAAC;gBAED,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAC7C,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;oBACtB,IAAI,EAAE,IAAI,CAAC,WAAW;oBACtB,GAAG,EAAE,IAAI,CAAC,cAAc;oBACxB,QAAQ,EAAE,YAAY,CAAC,IAAI;iBAC5B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,IACE,YAAY,CAAC,IAAI,KAAK,OAAO;YAC7B,YAAY,CAAC,KAAK,KAAK,IAAI,CAAC,cAAc,CAAC,KAAK,EAChD,CAAC;YACD,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;YAC/D,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACtB,IAAI,EAAE,IAAI,CAAC,WAAW;gBACtB,GAAG,EAAE,QAAQ;gBACb,QAAQ,EAAE,YAAY,CAAC,IAAI;aAC5B,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,IAAI,EAAE,IAAI,CAAC,WAAW;YACtB,GAAG,EAAE,IAAI,CAAC,cAAc;YACxB,QAAQ,EAAE,YAAY,CAAC,IAAI;SAC5B,CAAC,CAAC;IACL,CAAC;IAEO,YAAY,CAAC,EAAU,EAAE,SAAiB;QAChD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IACvE,CAAC;IAEO,eAAe,CAAC,EAAU,EAAE,SAAiB;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IAC1E,CAAC;IAEO,cAAc;QACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,KAAK,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IACrE,CAAC;IAEO,WAAW,CAAC,IAA+B;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,aAA4B,CAAC;QACjE,MAAM,SAAS,GAAmD;YAChE,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChD,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACjC,CAAC,UAAU,EAAE,CAAC,KAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACnE,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;SACtC,CAAC;QACF,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAC1C,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,CACrC,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,CACzC,CAAC;QAEF,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;IAChC,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE;YACtD,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE;gBACrC,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBAC3C,OAAO,CAAC,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC9C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC7B,CAAC;IAEO,kBAAkB,CAAC,IAAkB;QAC3C,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzE,WAAW;YACT,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC;YAC1C,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IACnC,CAAC;IAEO,iBAAiB;QACvB,MAAM,MAAM,GAAgB,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC/D,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACzC,MAAM,CAAC,YAAY,CACjB,OAAO,EACP,iJAAiJ,CAClJ,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC;QAC7B,IAAI,CAAC,QAAQ,CAAC,WAAW,CACvB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,EAC3C,IAAI,CAAC,cAAc,CACpB,CAAC;IACJ,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,WAAW,CACvB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,EAC3C,IAAI,CAAC,cAAc,CACpB,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC7B,CAAC;IAEO,4BAA4B,CAAC,QAAsB;QACzD,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACzB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC;QAED,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,cAAc,EACnB,aAAa,EACb,QAAQ,CAAC,KAAK,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAChC,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,cAAc,EACnB,WAAW,EACX,gBAAgB,GAAG,QAAQ,CAAC,CAAC,GAAG,QAAQ,CACzC,CAAC;IACJ,CAAC;IAEO,oBAAoB,CAAC,IAAkB,EAAE,QAAiB;QAChE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;QAC1B,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACnC,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBAC1C,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC,EAAE,IAAI,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAEO,cAAc,CAAC,IAAkB;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/D,OAAO,QAAQ,EAAE,CAAC,aAAa,CAAC,CAAC,aAAa,CAAC;IACjD,CAAC;IAEO,WAAW,CACjB,WAAyB,EACzB,QAAsB;QAEtB,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,uBAAuB,GAAG,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;QACzE,IAAI,uBAAuB,EAAE,CAAC;YAC5B,OAAO,uBAAuB,CAAC;QACjC,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC3B,CAAC;IAEO,YAAY,CAClB,WAAyB,EACzB,QAAsB;QAEtB,uEAAuE;QACvE,IAAI,WAAW,CAAC,EAAE,KAAK,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;YAC3C,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,6CAA6C;aACvD,CAAC;QACJ,CAAC;QAED,MAAM,uBAAuB,GAAG,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;QACzE,IAAI,uBAAuB,EAAE,CAAC;YAC5B,OAAO,uBAAuB,CAAC;QACjC,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACjE,OAAO;YACL,OAAO,EAAE,CAAC,iBAAiB;YAC3B,OAAO,EACL,iBAAiB,IAAI,6CAA6C;SACrE,CAAC;IACJ,CAAC;IAEO,yBAAyB,CAAC,QAAsB;QACtD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QAED,IAAI,KAAK,GACP,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QAEnE,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YAC7B,yDAAyD;YACzD,KAAK,GAAG,KAAK,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1B,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,qCAAqC;gBAC9C,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE;aACjC,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,iBAAiB,CAAC,EAAU;QAClC,OAAO,IAAI,CAAC,WAAW;aACpB,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC;aAChC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACtC,CAAC;IAEO,WAAW,CACjB,KAAgB,EAChB,WAAyB;QAEzB,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;gBAC3C,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;YACjC,CAAC;QACH,CAAC;QAED,IAAI,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAE5D,MAAM,iBAAiB,GACrB,WAAW,CAAC,OAAO;YACnB,YAAY,KAAK,OAAO;YACxB,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QAC3C,IAAI,iBAAiB,EAAE,CAAC;YACtB,YAAY,GAAG,QAAQ,CAAC;QAC1B,CAAC;QAED,OAAO;YACL,CAAC,EAAE,KAAK,CAAC,CAAC;YACV,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,YAAY,CAAC;YAC/C,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC;YAChE,IAAI,EAAE,YAAY;SACnB,CAAC;IACJ,CAAC;IAEO,YAAY,CAAC,IAAkB,EAAE,IAAsB;QAC7D,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC1C,MAAM,IAAI,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAE7C,OAAO,IAAI,KAAK,OAAO;YACrB,CAAC,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC;YACrC,CAAC,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5B,CAAC;IAEO,eAAe,CACrB,KAAgB,EAChB,WAAyB;QAEzB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAChD,MAAM,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1C,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;QAElB,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,KAAK,WAAW,CAAC,EAAE,CAAC;QAC/D,IAAI,WAAW,CAAC,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;YAC5C,MAAM,SAAS,GAAG,CAAC,CAAC;YACpB,IAAI,CAAC,IAAI,MAAM,GAAG,SAAS,IAAI,CAAC,IAAI,MAAM,GAAG,SAAS,EAAE,CAAC;gBACvD,OAAO,QAAQ,CAAC;YAClB,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,GAAG,MAAM,CAAC;QAC3B,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;IACrC,CAAC;IAEO,gBAAgB,CACtB,WAAyB,EACzB,IAAsB,EACtB,CAAS;QAET,IAAI,WAAW,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,CAAC,CAAC;QACX,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QACrD,MAAM,SAAS,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC;QAEtC,IAAI,IAAI,KAAK,OAAO,IAAI,SAAS,CAAC,EAAE,KAAK,WAAW,CAAC,EAAE,EAAE,CAAC;YACxD,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YAChD,MAAM,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;YAE5C,MAAM,WAAW,GAAG,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC;YAClC,MAAM,IAAI,GAAG,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC;YAEpD,MAAM,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC;gBAC9D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,KAAK,GAAG,gBAAgB,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;QAED,OAAO,WAAW,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,gBAAgB,CACtB,EAAU,EACV,KAAc;QAEd,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;QACzC,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAExD,MAAM,WAAW,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QACjE,OAAO,KAAK;aACT,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;aACf,OAAO,EAAE;aACT,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,KAAK,WAAW,CAAC,CAAC;IAChD,CAAC;IAEO,oBAAoB,CAAC,IAAkB;QAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,WAAW;aACpB,cAAc,CAAC,IAAI,CAAC;aACpB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC;IAC9C,CAAC;wGAvdU,qBAAqB;4FAArB,qBAAqB,8LAaZ,gBAAgB,oRAyBnB,WAAW;;4FAtCjB,qBAAqB;kBAJjC,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;iBACjB;uGAS4B,WAAW;sBAArC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAGhB,QAAQ;sBAAhB,KAAK;gBAGF,sBAAsB;sBADzB,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAO5B,SAAS;sBAAlB,MAAM;gBAGG,MAAM;sBAAf,MAAM;gBAGG,WAAW;sBAApB,MAAM;gBAE+B,YAAY;sBAAjD,YAAY;uBAAC,UAAU,EAAE,CAAC,QAAQ,CAAC;gBAIF,QAAQ;sBAAzC,YAAY;uBAAC,MAAM,EAAE,CAAC,QAAQ,CAAC;gBAIC,QAAQ;sBAAxC,WAAW;uBAAC,kBAAkB;gBAG/B,KAAK;sBADJ,eAAe;uBAAC,WAAW,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\nimport { FlatTreeControl } from '@angular/cdk/tree';\nimport {\n  AfterContentInit,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  Renderer2,\n  booleanAttribute\n} from '@angular/core';\nimport { MatTreeNode } from '@angular/material/tree';\n\nimport {\n  DropPosition,\n  DropPositionType,\n  TreeFlatNode\n} from './tree-drag-drop.interface';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface TreeDropEvent<T = any> {\n  node: TreeFlatNode<T>;\n  ref: TreeFlatNode<T>;\n  position: DropPositionType;\n}\n\ninterface DragNodeListeners {\n  element: HTMLElement;\n  listeners: [string, EventListenerOrEventListenerObject][];\n}\n\nexport interface DropPermission {\n  canDrop: boolean;\n  message?: string;\n  params?: Record<string, unknown>;\n}\n\n/**\n * This directive should be use with a MatTree flatened\n * It should add all logic to drag the MatTreeNode and connect the (onDrop) output\n * Class added:\n *    Tree: --dragging\n *    Node: --drag-hover | --dragged\n */\n@Directive({\n  selector: '[igoTreeDragDrop]',\n  standalone: true\n})\nexport class TreeDragDropDirective implements AfterContentInit, OnDestroy {\n  draggedNode: TreeFlatNode;\n  dropNodeTarget: TreeFlatNode;\n  expandTimeout: number;\n  nodesListeners: DragNodeListeners[] | undefined;\n  dropLineTarget: HTMLElement;\n  highlightedNode = new SelectionModel<TreeFlatNode>();\n\n  @Input({ required: true }) treeControl: FlatTreeControl<TreeFlatNode>;\n\n  /** The default is 5 */\n  @Input() maxLevel = 5;\n\n  @Input({ transform: booleanAttribute })\n  set treeDragDropIsDisabled(disabled: boolean) {\n    this.isDisabled = disabled;\n    disabled ? this.removeAllListener() : this.addAllListener();\n  }\n  private isDisabled = false;\n\n  @Output() dragStart = new EventEmitter<TreeFlatNode>();\n\n  // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n  @Output() onDrop = new EventEmitter<TreeDropEvent>(null);\n\n  // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n  @Output() onDropError = new EventEmitter<DropPermission>();\n\n  @HostListener('dragover', ['$event']) hostDragOver(event: Event): void {\n    event.preventDefault();\n  }\n\n  @HostListener('drop', ['$event']) hostDrop(event: DragEvent): void {\n    this.drop(event);\n  }\n\n  @HostBinding('class.--dragging') dragging: boolean;\n\n  @ContentChildren(MatTreeNode, { descendants: true })\n  nodes: QueryList<MatTreeNode<TreeFlatNode>>;\n\n  constructor(\n    private elementRef: ElementRef,\n    private renderer: Renderer2\n  ) {\n    this.onDrop.subscribe(() => this.dragEnd());\n\n    this.highlightedNode.changed.subscribe((change) => {\n      if (change.removed.length) {\n        this.removeNodeClass(change.removed[0].id, '--drag-hover');\n      }\n\n      if (change.added.length) {\n        this.addNodeClass(change.added[0].id, '--drag-hover');\n      }\n    });\n  }\n\n  ngAfterContentInit(): void {\n    this.nodes.changes.subscribe(() => {\n      this.addAllListener();\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.removeAllListener();\n  }\n\n  onDragStart(node: TreeFlatNode): void {\n    this.dragging = true;\n    this.draggedNode = node;\n    this.addNodeClass(node.id, '--dragged');\n\n    this.dragStart.emit(node);\n  }\n\n  dragEnd(): void {\n    this.dragging = false;\n    if (this.draggedNode) {\n      this.removeNodeClass(this.draggedNode.id, '--dragged');\n      this.draggedNode = null;\n    }\n\n    this.dragLeave();\n    this.removeDropTargetLine();\n  }\n\n  dragOver(node: TreeFlatNode, event: DragEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n\n    this.dropNodeTarget = node;\n\n    const position = this.getPosition(event, node);\n\n    this.updateDropTargetLinePosition(position);\n\n    this.setHighlightedNode(node);\n\n    this.handleGroupExpansion(node, position.type === 'inside');\n  }\n\n  dragLeave(): void {\n    clearTimeout(this.expandTimeout);\n    this.expandTimeout = null;\n    this.highlightedNode.clear();\n  }\n\n  drop(event: DragEvent): void {\n    if (!this.dropNodeTarget || this.isDisabled) {\n      return;\n    }\n\n    const dropPosition: DropPosition = this.getPosition(\n      event,\n      this.dropNodeTarget\n    );\n\n    const validation = this.canDropNode(this.dropNodeTarget, dropPosition);\n    if (!validation.canDrop) {\n      this.onDropError.emit(validation);\n      return;\n    }\n\n    // Allow to drop a last child outside is group. We refer to it's ancestor for the target\n    if (\n      dropPosition.type === 'below' &&\n      dropPosition.level !== this.dropNodeTarget.level\n    ) {\n      this.dropNodeTarget = this.getNodeAncestors(\n        this.dropNodeTarget.id,\n        dropPosition.level\n      );\n    }\n\n    if (this.dropNodeTarget.isGroup) {\n      if (dropPosition.type === 'inside') {\n        const isExpanded = this.treeControl.isExpanded(this.dropNodeTarget);\n        if (isExpanded) {\n          const children = this.getDirectDescendants(this.dropNodeTarget);\n          if (children[0]?.id === this.draggedNode.id) {\n            return;\n          }\n        }\n\n        this.treeControl.expand(this.dropNodeTarget);\n        return this.onDrop.emit({\n          node: this.draggedNode,\n          ref: this.dropNodeTarget,\n          position: dropPosition.type\n        });\n      }\n    }\n\n    if (\n      dropPosition.type === 'below' &&\n      dropPosition.level !== this.dropNodeTarget.level\n    ) {\n      const ancestor = this.getNodeAncestors(this.dropNodeTarget.id);\n      return this.onDrop.emit({\n        node: this.draggedNode,\n        ref: ancestor,\n        position: dropPosition.type\n      });\n    }\n\n    this.onDrop.emit({\n      node: this.draggedNode,\n      ref: this.dropNodeTarget,\n      position: dropPosition.type\n    });\n  }\n\n  private addNodeClass(id: string, className: string): void {\n    const node = this.nodes.find((node) => node.data.id === id);\n    this.renderer.addClass(node['_elementRef'].nativeElement, className);\n  }\n\n  private removeNodeClass(id: string, className: string): void {\n    const node = this.nodes.find((node) => node.data.id === id);\n    this.renderer.removeClass(node['_elementRef'].nativeElement, className);\n  }\n\n  private addAllListener(): void {\n    if (this.isDisabled) {\n      return;\n    }\n    const nodes = this.nodes?.toArray();\n    if (this.nodesListeners) {\n      this.removeAllListener();\n    }\n\n    this.nodesListeners = nodes?.map((node) => this.addListener(node));\n  }\n\n  private addListener(node: MatTreeNode<TreeFlatNode>): DragNodeListeners {\n    const element = node['_elementRef'].nativeElement as HTMLElement;\n    const listeners: [string, EventListenerOrEventListenerObject][] = [\n      ['dragstart', () => this.onDragStart(node.data)],\n      ['dragend', () => this.dragEnd()],\n      ['dragover', (event: DragEvent) => this.dragOver(node.data, event)],\n      ['dragleave', () => this.dragLeave()]\n    ];\n    element.setAttribute('draggable', 'true');\n    listeners.forEach(([type, listener]) =>\n      element.addEventListener(type, listener)\n    );\n\n    return { element, listeners };\n  }\n\n  private removeAllListener(): void {\n    this.nodesListeners?.forEach(({ element, listeners }) => {\n      listeners.forEach(([type, listener]) => {\n        element.setAttribute('draggable', 'false');\n        element.removeEventListener(type, listener);\n      });\n    });\n    this.nodesListeners = null;\n  }\n\n  private setHighlightedNode(node: TreeFlatNode): void {\n    const toHighlight = node.isGroup ? node : this.getNodeAncestors(node.id);\n    toHighlight\n      ? this.highlightedNode.select(toHighlight)\n      : this.highlightedNode.clear();\n  }\n\n  private addDropTargetLine(): void {\n    const target: HTMLElement = this.renderer.createElement('div');\n    target.classList.add('drop-target-line');\n    target.setAttribute(\n      'style',\n      `position: absolute; top: 0; width: 100%; pointer-events: none; z-index: 4; height: 2px; background-color: black; transition: margin-left 150ms;`\n    );\n    this.dropLineTarget = target;\n    this.renderer.appendChild(\n      this.elementRef.nativeElement.parentElement,\n      this.dropLineTarget\n    );\n  }\n\n  private removeDropTargetLine(): void {\n    if (!this.dropLineTarget) {\n      return;\n    }\n    this.renderer.removeChild(\n      this.elementRef.nativeElement.parentElement,\n      this.dropLineTarget\n    );\n    this.dropLineTarget = null;\n  }\n\n  private updateDropTargetLinePosition(position: DropPosition): void {\n    if (!this.dropLineTarget) {\n      this.addDropTargetLine();\n    }\n\n    if (position.type === 'inside') {\n      return this.removeDropTargetLine();\n    }\n\n    this.renderer.setStyle(\n      this.dropLineTarget,\n      'margin-left',\n      position.level * 24 + 20 + 'px'\n    );\n    this.renderer.setStyle(\n      this.dropLineTarget,\n      'transform',\n      'translate3d(0,' + position.y + 'px, 0)'\n    );\n  }\n\n  private handleGroupExpansion(node: TreeFlatNode, isInside: boolean): void {\n    if (!isInside) {\n      return this.dragLeave();\n    }\n    const isOpen = this.treeControl.isExpanded(node);\n    if (!isOpen && !this.expandTimeout) {\n      this.expandTimeout = window.setTimeout(() => {\n        this.treeControl.expand(node);\n      }, 1200);\n    }\n  }\n\n  private getNodeElement(node: TreeFlatNode): HTMLElement | undefined {\n    const treeNode = this.nodes.find((n) => n.data.id === node.id);\n    return treeNode?.['_elementRef'].nativeElement;\n  }\n\n  private canDropNode(\n    hoveredNode: TreeFlatNode,\n    position: DropPosition\n  ): DropPermission {\n    if (this.draggedNode.isGroup) {\n      return this.canDropGroup(hoveredNode, position);\n    }\n\n    const hasMaxLevelRestrictions = this.validateMaxHierarchyLevel(position);\n    if (hasMaxLevelRestrictions) {\n      return hasMaxLevelRestrictions;\n    }\n\n    return { canDrop: true };\n  }\n\n  private canDropGroup(\n    hoveredNode: TreeFlatNode,\n    position: DropPosition\n  ): DropPermission {\n    // On ne veut pas permettre le Drop pour un groupe qui s'auto référence\n    if (hoveredNode.id === this.draggedNode.id) {\n      return {\n        canDrop: false,\n        message: 'igo.common.dragDrop.cannot.dropInsideItself'\n      };\n    }\n\n    const hasMaxLevelRestrictions = this.validateMaxHierarchyLevel(position);\n    if (hasMaxLevelRestrictions) {\n      return hasMaxLevelRestrictions;\n    }\n\n    const isHoverDescendant = this.isHoverDescendant(hoveredNode.id);\n    return {\n      canDrop: !isHoverDescendant,\n      message:\n        isHoverDescendant && 'igo.common.dragDrop.cannot.dropInsideItself'\n    };\n  }\n\n  private validateMaxHierarchyLevel(position: DropPosition): DropPermission {\n    if (!this.maxLevel) {\n      return;\n    }\n\n    let level =\n      position.type === 'inside' ? position.level + 1 : position.level;\n\n    if (this.draggedNode.isGroup) {\n      // We add an extra level +1 to avoid empty group in group\n      level = level + (this.draggedNode.descendantLevels ?? 0) + 1;\n    }\n\n    if (level > this.maxLevel) {\n      return {\n        canDrop: false,\n        message: 'igo.common.dragDrop.cannot.maxLevel',\n        params: { value: this.maxLevel }\n      };\n    }\n  }\n\n  private isHoverDescendant(id: string): boolean {\n    return this.treeControl\n      .getDescendants(this.draggedNode)\n      .some((child) => child.id === id);\n  }\n\n  private getPosition(\n    event: DragEvent,\n    hoveredNode: TreeFlatNode\n  ): DropPosition {\n    if (this.draggedNode.isGroup) {\n      if (this.isHoverDescendant(hoveredNode.id)) {\n        hoveredNode = this.draggedNode;\n      }\n    }\n\n    let positionType = this.getPositionType(event, hoveredNode);\n\n    const bellowOpenedGroup =\n      hoveredNode.isGroup &&\n      positionType === 'below' &&\n      this.treeControl.isExpanded(hoveredNode);\n    if (bellowOpenedGroup) {\n      positionType = 'inside';\n    }\n\n    return {\n      x: event.x,\n      y: this.getPositionY(hoveredNode, positionType),\n      level: this.getPositionLevel(hoveredNode, positionType, event.x),\n      type: positionType\n    };\n  }\n\n  private getPositionY(node: TreeFlatNode, type: DropPositionType): number {\n    const element = this.getNodeElement(node);\n    const rect = element.getBoundingClientRect();\n\n    return type === 'below'\n      ? element.offsetTop + rect.height - 1\n      : element.offsetTop + 1;\n  }\n\n  private getPositionType(\n    event: DragEvent,\n    hoveredNode: TreeFlatNode\n  ): DropPositionType {\n    const target = this.getNodeElement(hoveredNode);\n    const rect = target.getBoundingClientRect();\n    const middle = rect.top + rect.height / 2;\n    const y = event.y;\n\n    const selfReferencing = this.draggedNode.id === hoveredNode.id;\n    if (hoveredNode.isGroup && !selfReferencing) {\n      const tolerence = 5;\n      if (y <= middle + tolerence && y >= middle - tolerence) {\n        return 'inside';\n      }\n    }\n\n    const isBelow = y > middle;\n    return isBelow ? 'below' : 'above';\n  }\n\n  private getPositionLevel(\n    hoveredNode: TreeFlatNode,\n    type: DropPositionType,\n    x: number\n  ): number {\n    if (hoveredNode.level === 0) {\n      return 0;\n    }\n\n    const ancestor = this.getNodeAncestors(hoveredNode.id);\n    const children = this.getDirectDescendants(ancestor);\n    const lastChild = [...children].pop();\n\n    if (type === 'below' && lastChild.id === hoveredNode.id) {\n      const target = this.getNodeElement(hoveredNode);\n      const rect = target.getBoundingClientRect();\n\n      const indentation = 24;\n      const xMin = rect.x + indentation;\n      const xMax = xMin + indentation * hoveredNode.level;\n\n      const isInsideSameGroup = x > xMax;\n      if (!isInsideSameGroup) {\n        const levelSubstracted = Math.round((xMax - x) / indentation);\n        return Math.max(0, hoveredNode.level - levelSubstracted);\n      }\n    }\n\n    return hoveredNode.level;\n  }\n\n  /**\n   * @param level if level is defined with go to the defined levle to find ancestor. Sinon on prend le current ancestor\n   */\n  private getNodeAncestors(\n    id: string,\n    level?: number\n  ): TreeFlatNode | undefined {\n    const nodes = this.treeControl.dataNodes;\n    const index = nodes.findIndex((node) => node.id === id);\n\n    const targetLevel = level ?? Math.max(0, nodes[index].level - 1);\n    return nodes\n      .slice(0, index)\n      .reverse()\n      .find((node) => node.level === targetLevel);\n  }\n\n  private getDirectDescendants(node: TreeFlatNode): TreeFlatNode[] {\n    const level = node.level + 1;\n    return this.treeControl\n      .getDescendants(node)\n      .filter((child) => child.level === level);\n  }\n}\n"]}

package/esm2022/drag-drop/tree-drag-drop/tree-drag-drop.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1kcmFnLWRyb3AuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL2RyYWctZHJvcC9zcmMvdHJlZS1kcmFnLWRyb3AvdHJlZS1kcmFnLWRyb3AuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFRyZWVGbGF0Tm9kZTxUID0gYW55PiB7XG4gIGlkOiBzdHJpbmc7XG4gIGlzR3JvdXA6IGJvb2xlYW47XG4gIGRpc2FibGVkOiBib29sZWFuO1xuICBsZXZlbDogbnVtYmVyO1xuICAvLyBHaXZlIHRoZSBudW1iZXIgb2YgbGV2ZWwgaW5zaWRlIGEgZ3JvdXA7XG4gIGRlc2NlbmRhbnRMZXZlbHM/OiBudW1iZXI7XG4gIGRhdGE6IFQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRHJvcFBvc2l0aW9uIHtcbiAgeDogbnVtYmVyO1xuICB5OiBudW1iZXI7XG4gIGxldmVsOiBudW1iZXI7XG4gIHR5cGU6IERyb3BQb3NpdGlvblR5cGU7XG59XG5cbmV4cG9ydCB0eXBlIERyb3BQb3NpdGlvblR5cGUgPSAnYWJvdmUnIHwgJ2JlbG93JyB8ICdpbnNpZGUnO1xuIl19