ngx-drag-drop 16.0.0 → 17.0.0

package/esm2022/lib/dnd-draggable.directive.mjs

@@ -0,0 +1,199 @@
+import { Directive, ElementRef, EventEmitter, forwardRef, HostBinding, HostListener, inject, Input, NgZone, Output, Renderer2, } from '@angular/core';
+import { dndState, endDrag, startDrag } from './dnd-state';
+import { calculateDragImageOffset, setDragData, setDragImage, } from './dnd-utils';
+import * as i0 from "@angular/core";
+export class DndDragImageRefDirective {
+    dndDraggableDirective = inject(forwardRef(() => DndDraggableDirective));
+    elementRef = inject(ElementRef);
+    ngOnInit() {
+        this.dndDraggableDirective.registerDragImage(this.elementRef);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDragImageRefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: DndDragImageRefDirective, isStandalone: true, selector: "[dndDragImageRef]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDragImageRefDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dndDragImageRef]', standalone: true }]
+        }] });
+export class DndDraggableDirective {
+    dndDraggable;
+    dndEffectAllowed = 'copy';
+    dndType;
+    dndDraggingClass = 'dndDragging';
+    dndDraggingSourceClass = 'dndDraggingSource';
+    dndDraggableDisabledClass = 'dndDraggableDisabled';
+    dndDragImageOffsetFunction = calculateDragImageOffset;
+    dndStart = new EventEmitter();
+    dndDrag = new EventEmitter();
+    dndEnd = new EventEmitter();
+    dndMoved = new EventEmitter();
+    dndCopied = new EventEmitter();
+    dndLinked = new EventEmitter();
+    dndCanceled = new EventEmitter();
+    draggable = true;
+    dndHandle;
+    dndDragImageElementRef;
+    dragImage;
+    isDragStarted = false;
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    ngZone = inject(NgZone);
+    set dndDisableIf(value) {
+        this.draggable = !value;
+        if (this.draggable) {
+            this.renderer.removeClass(this.elementRef.nativeElement, this.dndDraggableDisabledClass);
+        }
+        else {
+            this.renderer.addClass(this.elementRef.nativeElement, this.dndDraggableDisabledClass);
+        }
+    }
+    set dndDisableDragIf(value) {
+        this.dndDisableIf = value;
+    }
+    ngAfterViewInit() {
+        this.ngZone.runOutsideAngular(() => {
+            this.elementRef.nativeElement.addEventListener('drag', this.dragEventHandler);
+        });
+    }
+    ngOnDestroy() {
+        this.elementRef.nativeElement.removeEventListener('drag', this.dragEventHandler);
+        if (this.isDragStarted) {
+            endDrag();
+        }
+    }
+    onDragStart(event) {
+        if (!this.draggable) {
+            return false;
+        }
+        // check if there is dnd handle and if the dnd handle was used to start the drag
+        if (this.dndHandle != null && event._dndUsingHandle == null) {
+            event.stopPropagation();
+            return false;
+        }
+        // initialize global state
+        startDrag(event, this.dndEffectAllowed, this.dndType);
+        this.isDragStarted = true;
+        setDragData(event, { data: this.dndDraggable, type: this.dndType }, dndState.effectAllowed);
+        this.dragImage = this.determineDragImage();
+        // set dragging css class prior to setDragImage so styles are applied before
+        // TODO breaking change: add class to elementRef rather than drag image which could be another element
+        this.renderer.addClass(this.dragImage, this.dndDraggingClass);
+        // set custom dragimage if present
+        // set dragimage if drag is started from dndHandle
+        if (this.dndDragImageElementRef != null || event._dndUsingHandle != null) {
+            setDragImage(event, this.dragImage, this.dndDragImageOffsetFunction);
+        }
+        // add dragging source css class on first drag event
+        const unregister = this.renderer.listen(this.elementRef.nativeElement, 'drag', () => {
+            this.renderer.addClass(this.elementRef.nativeElement, this.dndDraggingSourceClass);
+            unregister();
+        });
+        this.dndStart.emit(event);
+        event.stopPropagation();
+        setTimeout(() => {
+            this.renderer.setStyle(this.dragImage, 'pointer-events', 'none');
+        }, 100);
+        return true;
+    }
+    onDrag(event) {
+        this.dndDrag.emit(event);
+    }
+    onDragEnd(event) {
+        if (!this.draggable || !this.isDragStarted) {
+            return;
+        }
+        // get drop effect from custom stored state as its not reliable across browsers
+        const dropEffect = dndState.dropEffect;
+        this.renderer.setStyle(this.dragImage, 'pointer-events', 'unset');
+        let dropEffectEmitter;
+        switch (dropEffect) {
+            case 'copy':
+                dropEffectEmitter = this.dndCopied;
+                break;
+            case 'link':
+                dropEffectEmitter = this.dndLinked;
+                break;
+            case 'move':
+                dropEffectEmitter = this.dndMoved;
+                break;
+            default:
+                dropEffectEmitter = this.dndCanceled;
+                break;
+        }
+        dropEffectEmitter.emit(event);
+        this.dndEnd.emit(event);
+        // reset global state
+        endDrag();
+        this.isDragStarted = false;
+        this.renderer.removeClass(this.dragImage, this.dndDraggingClass);
+        // IE9 special hammering
+        window.setTimeout(() => {
+            this.renderer.removeClass(this.elementRef.nativeElement, this.dndDraggingSourceClass);
+        }, 0);
+        event.stopPropagation();
+    }
+    registerDragHandle(handle) {
+        this.dndHandle = handle;
+    }
+    registerDragImage(elementRef) {
+        this.dndDragImageElementRef = elementRef;
+    }
+    dragEventHandler = (event) => this.onDrag(event);
+    determineDragImage() {
+        // evaluate custom drag image existence
+        if (typeof this.dndDragImageElementRef !== 'undefined') {
+            return this.dndDragImageElementRef.nativeElement;
+        }
+        else {
+            return this.elementRef.nativeElement;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDraggableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: DndDraggableDirective, isStandalone: true, selector: "[dndDraggable]", inputs: { dndDraggable: "dndDraggable", dndEffectAllowed: "dndEffectAllowed", dndType: "dndType", dndDraggingClass: "dndDraggingClass", dndDraggingSourceClass: "dndDraggingSourceClass", dndDraggableDisabledClass: "dndDraggableDisabledClass", dndDragImageOffsetFunction: "dndDragImageOffsetFunction", dndDisableIf: "dndDisableIf", dndDisableDragIf: "dndDisableDragIf" }, outputs: { dndStart: "dndStart", dndDrag: "dndDrag", dndEnd: "dndEnd", dndMoved: "dndMoved", dndCopied: "dndCopied", dndLinked: "dndLinked", dndCanceled: "dndCanceled" }, host: { listeners: { "dragstart": "onDragStart($event)", "dragend": "onDragEnd($event)" }, properties: { "attr.draggable": "this.draggable" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDraggableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dndDraggable]', standalone: true }]
+        }], propDecorators: { dndDraggable: [{
+                type: Input
+            }], dndEffectAllowed: [{
+                type: Input
+            }], dndType: [{
+                type: Input
+            }], dndDraggingClass: [{
+                type: Input
+            }], dndDraggingSourceClass: [{
+                type: Input
+            }], dndDraggableDisabledClass: [{
+                type: Input
+            }], dndDragImageOffsetFunction: [{
+                type: Input
+            }], dndStart: [{
+                type: Output
+            }], dndDrag: [{
+                type: Output
+            }], dndEnd: [{
+                type: Output
+            }], dndMoved: [{
+                type: Output
+            }], dndCopied: [{
+                type: Output
+            }], dndLinked: [{
+                type: Output
+            }], dndCanceled: [{
+                type: Output
+            }], draggable: [{
+                type: HostBinding,
+                args: ['attr.draggable']
+            }], dndDisableIf: [{
+                type: Input
+            }], dndDisableDragIf: [{
+                type: Input
+            }], onDragStart: [{
+                type: HostListener,
+                args: ['dragstart', ['$event']]
+            }], onDragEnd: [{
+                type: HostListener,
+                args: ['dragend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd-draggable.directive.js","sourceRoot":"","sources":["../../../../projects/dnd/src/lib/dnd-draggable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  HostBinding,\n  HostListener,\n  inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n} from '@angular/core';\nimport { DndHandleDirective } from './dnd-handle.directive';\nimport { dndState, endDrag, startDrag } from './dnd-state';\nimport { EffectAllowed } from './dnd-types';\nimport {\n  calculateDragImageOffset,\n  DndDragImageOffsetFunction,\n  DndEvent,\n  setDragData,\n  setDragImage,\n} from './dnd-utils';\n\n@Directive({ selector: '[dndDragImageRef]', standalone: true })\nexport class DndDragImageRefDirective implements OnInit {\n  dndDraggableDirective = inject(forwardRef(() => DndDraggableDirective));\n  elementRef: ElementRef<HTMLElement> = inject(ElementRef);\n\n  ngOnInit() {\n    this.dndDraggableDirective.registerDragImage(this.elementRef);\n  }\n}\n\n@Directive({ selector: '[dndDraggable]', standalone: true })\nexport class DndDraggableDirective implements AfterViewInit, OnDestroy {\n  @Input() dndDraggable: any;\n  @Input() dndEffectAllowed: EffectAllowed = 'copy';\n  @Input() dndType?: string;\n  @Input() dndDraggingClass = 'dndDragging';\n  @Input() dndDraggingSourceClass = 'dndDraggingSource';\n  @Input() dndDraggableDisabledClass = 'dndDraggableDisabled';\n  @Input() dndDragImageOffsetFunction: DndDragImageOffsetFunction =\n    calculateDragImageOffset;\n\n  @Output() readonly dndStart: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndDrag: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndEnd: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndMoved: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndCopied: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndLinked: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n  @Output() readonly dndCanceled: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n\n  @HostBinding('attr.draggable') draggable = true;\n\n  private dndHandle?: DndHandleDirective;\n  private dndDragImageElementRef?: ElementRef;\n  private dragImage: Element | undefined;\n  private isDragStarted: boolean = false;\n\n  private elementRef: ElementRef<HTMLElement> = inject(ElementRef);\n  private renderer = inject(Renderer2);\n  private ngZone = inject(NgZone);\n\n  @Input() set dndDisableIf(value: boolean) {\n    this.draggable = !value;\n\n    if (this.draggable) {\n      this.renderer.removeClass(\n        this.elementRef.nativeElement,\n        this.dndDraggableDisabledClass\n      );\n    } else {\n      this.renderer.addClass(\n        this.elementRef.nativeElement,\n        this.dndDraggableDisabledClass\n      );\n    }\n  }\n\n  @Input() set dndDisableDragIf(value: boolean) {\n    this.dndDisableIf = value;\n  }\n\n  ngAfterViewInit(): void {\n    this.ngZone.runOutsideAngular(() => {\n      this.elementRef.nativeElement.addEventListener(\n        'drag',\n        this.dragEventHandler\n      );\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.elementRef.nativeElement.removeEventListener(\n      'drag',\n      this.dragEventHandler\n    );\n    if (this.isDragStarted) {\n      endDrag();\n    }\n  }\n\n  @HostListener('dragstart', ['$event']) onDragStart(event: DndEvent): boolean {\n    if (!this.draggable) {\n      return false;\n    }\n\n    // check if there is dnd handle and if the dnd handle was used to start the drag\n    if (this.dndHandle != null && event._dndUsingHandle == null) {\n      event.stopPropagation();\n      return false;\n    }\n\n    // initialize global state\n    startDrag(event, this.dndEffectAllowed, this.dndType);\n\n    this.isDragStarted = true;\n\n    setDragData(\n      event,\n      { data: this.dndDraggable, type: this.dndType },\n      dndState.effectAllowed!\n    );\n\n    this.dragImage = this.determineDragImage();\n\n    // set dragging css class prior to setDragImage so styles are applied before\n    // TODO breaking change: add class to elementRef rather than drag image which could be another element\n    this.renderer.addClass(this.dragImage, this.dndDraggingClass);\n\n    // set custom dragimage if present\n    // set dragimage if drag is started from dndHandle\n    if (this.dndDragImageElementRef != null || event._dndUsingHandle != null) {\n      setDragImage(event, this.dragImage, this.dndDragImageOffsetFunction);\n    }\n\n    // add dragging source css class on first drag event\n    const unregister = this.renderer.listen(\n      this.elementRef.nativeElement,\n      'drag',\n      () => {\n        this.renderer.addClass(\n          this.elementRef.nativeElement,\n          this.dndDraggingSourceClass\n        );\n        unregister();\n      }\n    );\n\n    this.dndStart.emit(event);\n\n    event.stopPropagation();\n\n    setTimeout(() => {\n      this.renderer.setStyle(this.dragImage, 'pointer-events', 'none');\n    }, 100);\n\n    return true;\n  }\n\n  onDrag(event: DragEvent) {\n    this.dndDrag.emit(event);\n  }\n\n  @HostListener('dragend', ['$event']) onDragEnd(event: DragEvent) {\n    if (!this.draggable || !this.isDragStarted) {\n      return;\n    }\n    // get drop effect from custom stored state as its not reliable across browsers\n    const dropEffect = dndState.dropEffect;\n\n    this.renderer.setStyle(this.dragImage, 'pointer-events', 'unset');\n\n    let dropEffectEmitter: EventEmitter<DragEvent>;\n\n    switch (dropEffect) {\n      case 'copy':\n        dropEffectEmitter = this.dndCopied;\n        break;\n\n      case 'link':\n        dropEffectEmitter = this.dndLinked;\n        break;\n\n      case 'move':\n        dropEffectEmitter = this.dndMoved;\n        break;\n\n      default:\n        dropEffectEmitter = this.dndCanceled;\n        break;\n    }\n\n    dropEffectEmitter.emit(event);\n    this.dndEnd.emit(event);\n\n    // reset global state\n    endDrag();\n\n    this.isDragStarted = false;\n\n    this.renderer.removeClass(this.dragImage, this.dndDraggingClass);\n\n    // IE9 special hammering\n    window.setTimeout(() => {\n      this.renderer.removeClass(\n        this.elementRef.nativeElement,\n        this.dndDraggingSourceClass\n      );\n    }, 0);\n\n    event.stopPropagation();\n  }\n\n  registerDragHandle(handle: DndHandleDirective | undefined) {\n    this.dndHandle = handle;\n  }\n\n  registerDragImage(elementRef: ElementRef | undefined) {\n    this.dndDragImageElementRef = elementRef;\n  }\n\n  private readonly dragEventHandler: (event: DragEvent) => void = (\n    event: DragEvent\n  ) => this.onDrag(event);\n\n  private determineDragImage(): Element {\n    // evaluate custom drag image existence\n    if (typeof this.dndDragImageElementRef !== 'undefined') {\n      return this.dndDragImageElementRef.nativeElement as Element;\n    } else {\n      return this.elementRef.nativeElement;\n    }\n  }\n}\n"]}

package/esm2022/lib/dnd-dropzone.directive.mjs

@@ -0,0 +1,280 @@
+import { ContentChild, Directive, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+import { getDndType, getDropEffect, isExternalDrag, setDropEffect, } from './dnd-state';
+import { getDirectChildElement, getDropData, shouldPositionPlaceholderBeforeElement, } from './dnd-utils';
+import * as i0 from "@angular/core";
+export class DndPlaceholderRefDirective {
+    elementRef;
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    ngOnInit() {
+        // placeholder has to be "invisible" to the cursor, or it would interfere with the dragover detection for the same dropzone
+        this.elementRef.nativeElement.style.pointerEvents = 'none';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndPlaceholderRefDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: DndPlaceholderRefDirective, isStandalone: true, selector: "[dndPlaceholderRef]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndPlaceholderRefDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dndPlaceholderRef]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+export class DndDropzoneDirective {
+    ngZone;
+    elementRef;
+    renderer;
+    dndDropzone = '';
+    dndEffectAllowed = 'uninitialized';
+    dndAllowExternal = false;
+    dndHorizontal = false;
+    dndDragoverClass = 'dndDragover';
+    dndDropzoneDisabledClass = 'dndDropzoneDisabled';
+    dndDragover = new EventEmitter();
+    dndDrop = new EventEmitter();
+    dndPlaceholderRef;
+    placeholder = null;
+    disabled = false;
+    constructor(ngZone, elementRef, renderer) {
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+    }
+    set dndDisableIf(value) {
+        this.disabled = value;
+        if (this.disabled) {
+            this.renderer.addClass(this.elementRef.nativeElement, this.dndDropzoneDisabledClass);
+        }
+        else {
+            this.renderer.removeClass(this.elementRef.nativeElement, this.dndDropzoneDisabledClass);
+        }
+    }
+    set dndDisableDropIf(value) {
+        this.dndDisableIf = value;
+    }
+    ngAfterViewInit() {
+        this.placeholder = this.tryGetPlaceholder();
+        this.removePlaceholderFromDOM();
+        this.ngZone.runOutsideAngular(() => {
+            this.elementRef.nativeElement.addEventListener('dragenter', this.dragEnterEventHandler);
+            this.elementRef.nativeElement.addEventListener('dragover', this.dragOverEventHandler);
+            this.elementRef.nativeElement.addEventListener('dragleave', this.dragLeaveEventHandler);
+        });
+    }
+    ngOnDestroy() {
+        this.elementRef.nativeElement.removeEventListener('dragenter', this.dragEnterEventHandler);
+        this.elementRef.nativeElement.removeEventListener('dragover', this.dragOverEventHandler);
+        this.elementRef.nativeElement.removeEventListener('dragleave', this.dragLeaveEventHandler);
+    }
+    onDragEnter(event) {
+        // check if another dropzone is activated
+        if (event._dndDropzoneActive === true) {
+            this.cleanupDragoverState();
+            return;
+        }
+        // set as active if the target element is inside this dropzone
+        if (event._dndDropzoneActive == null) {
+            const newTarget = document.elementFromPoint(event.clientX, event.clientY);
+            if (this.elementRef.nativeElement.contains(newTarget)) {
+                event._dndDropzoneActive = true;
+            }
+        }
+        // check if this drag event is allowed to drop on this dropzone
+        const type = getDndType(event);
+        if (!this.isDropAllowed(type)) {
+            return;
+        }
+        // allow the dragenter
+        event.preventDefault();
+    }
+    onDragOver(event) {
+        // With nested dropzones, we want to ignore this event if a child dropzone
+        // has already handled a dragover.  Historically, event.stopPropagation() was
+        // used to prevent this bubbling, but that prevents any dragovers outside the
+        // ngx-drag-drop component, and stops other use cases such as scrolling on drag.
+        // Instead, we can check if the event was already prevented by a child and bail early.
+        if (event.defaultPrevented) {
+            return;
+        }
+        // check if this drag event is allowed to drop on this dropzone
+        const type = getDndType(event);
+        if (!this.isDropAllowed(type)) {
+            return;
+        }
+        this.checkAndUpdatePlaceholderPosition(event);
+        const dropEffect = getDropEffect(event, this.dndEffectAllowed);
+        if (dropEffect === 'none') {
+            this.cleanupDragoverState();
+            return;
+        }
+        // allow the dragover
+        event.preventDefault();
+        // set the drop effect
+        setDropEffect(event, dropEffect);
+        this.dndDragover.emit(event);
+        this.renderer.addClass(this.elementRef.nativeElement, this.dndDragoverClass);
+    }
+    onDrop(event) {
+        try {
+            // check if this drag event is allowed to drop on this dropzone
+            const type = getDndType(event);
+            if (!this.isDropAllowed(type)) {
+                return;
+            }
+            const data = getDropData(event, isExternalDrag());
+            if (!this.isDropAllowed(data.type)) {
+                return;
+            }
+            // signal custom drop handling
+            event.preventDefault();
+            const dropEffect = getDropEffect(event);
+            setDropEffect(event, dropEffect);
+            if (dropEffect === 'none') {
+                return;
+            }
+            const dropIndex = this.getPlaceholderIndex();
+            // if for whatever reason the placeholder is not present in the DOM but it should be there
+            // we don't allow/emit the drop event since it breaks the contract
+            // seems to only happen if drag and drop is executed faster than the DOM updates
+            if (dropIndex === -1) {
+                return;
+            }
+            this.dndDrop.emit({
+                event: event,
+                dropEffect: dropEffect,
+                isExternal: isExternalDrag(),
+                data: data.data,
+                index: dropIndex,
+                type: type,
+            });
+            event.stopPropagation();
+        }
+        finally {
+            this.cleanupDragoverState();
+        }
+    }
+    onDragLeave(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        // check if still inside this dropzone and not yet handled by another dropzone
+        if (event._dndDropzoneActive == null) {
+            if (this.elementRef.nativeElement.contains(event.relatedTarget)) {
+                event._dndDropzoneActive = true;
+                return;
+            }
+        }
+        this.cleanupDragoverState();
+        // cleanup drop effect when leaving dropzone
+        setDropEffect(event, 'none');
+    }
+    dragEnterEventHandler = (event) => this.onDragEnter(event);
+    dragOverEventHandler = (event) => this.onDragOver(event);
+    dragLeaveEventHandler = (event) => this.onDragLeave(event);
+    isDropAllowed(type) {
+        // dropzone is disabled -> deny it
+        if (this.disabled) {
+            return false;
+        }
+        // if drag did not start from our directive
+        // and external drag sources are not allowed -> deny it
+        if (isExternalDrag() && !this.dndAllowExternal) {
+            return false;
+        }
+        // no filtering by types -> allow it
+        if (!this.dndDropzone) {
+            return true;
+        }
+        // no type set -> allow it
+        if (!type) {
+            return true;
+        }
+        if (!Array.isArray(this.dndDropzone)) {
+            throw new Error('dndDropzone: bound value to [dndDropzone] must be an array!');
+        }
+        // if dropzone contains type -> allow it
+        return this.dndDropzone.indexOf(type) !== -1;
+    }
+    tryGetPlaceholder() {
+        if (typeof this.dndPlaceholderRef !== 'undefined') {
+            return this.dndPlaceholderRef.elementRef.nativeElement;
+        }
+        // TODO nasty workaround needed because if ng-container / template is used @ContentChild() or DI will fail because
+        // of wrong context see angular bug https://github.com/angular/angular/issues/13517
+        return this.elementRef.nativeElement.querySelector('[dndPlaceholderRef]');
+    }
+    removePlaceholderFromDOM() {
+        if (this.placeholder !== null && this.placeholder.parentNode !== null) {
+            this.placeholder.parentNode.removeChild(this.placeholder);
+        }
+    }
+    checkAndUpdatePlaceholderPosition(event) {
+        if (this.placeholder === null) {
+            return;
+        }
+        // make sure the placeholder is in the DOM
+        if (this.placeholder.parentNode !== this.elementRef.nativeElement) {
+            this.renderer.appendChild(this.elementRef.nativeElement, this.placeholder);
+        }
+        // update the position if the event originates from a child element of the dropzone
+        const directChild = getDirectChildElement(this.elementRef.nativeElement, event.target);
+        // early exit if no direct child or direct child is placeholder
+        if (directChild === null || directChild === this.placeholder) {
+            return;
+        }
+        const positionPlaceholderBeforeDirectChild = shouldPositionPlaceholderBeforeElement(event, directChild, this.dndHorizontal);
+        if (positionPlaceholderBeforeDirectChild) {
+            // do insert before only if necessary
+            if (directChild.previousSibling !== this.placeholder) {
+                this.renderer.insertBefore(this.elementRef.nativeElement, this.placeholder, directChild);
+            }
+        }
+        else {
+            // do insert after only if necessary
+            if (directChild.nextSibling !== this.placeholder) {
+                this.renderer.insertBefore(this.elementRef.nativeElement, this.placeholder, directChild.nextSibling);
+            }
+        }
+    }
+    getPlaceholderIndex() {
+        if (this.placeholder === null) {
+            return undefined;
+        }
+        const element = this.elementRef.nativeElement;
+        return Array.prototype.indexOf.call(element.children, this.placeholder);
+    }
+    cleanupDragoverState() {
+        this.renderer.removeClass(this.elementRef.nativeElement, this.dndDragoverClass);
+        this.removePlaceholderFromDOM();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDropzoneDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: DndDropzoneDirective, isStandalone: true, selector: "[dndDropzone]", inputs: { dndDropzone: "dndDropzone", dndEffectAllowed: "dndEffectAllowed", dndAllowExternal: "dndAllowExternal", dndHorizontal: "dndHorizontal", dndDragoverClass: "dndDragoverClass", dndDropzoneDisabledClass: "dndDropzoneDisabledClass", dndDisableIf: "dndDisableIf", dndDisableDropIf: "dndDisableDropIf" }, outputs: { dndDragover: "dndDragover", dndDrop: "dndDrop" }, host: { listeners: { "drop": "onDrop($event)" } }, queries: [{ propertyName: "dndPlaceholderRef", first: true, predicate: DndPlaceholderRefDirective, descendants: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndDropzoneDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dndDropzone]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { dndDropzone: [{
+                type: Input
+            }], dndEffectAllowed: [{
+                type: Input
+            }], dndAllowExternal: [{
+                type: Input
+            }], dndHorizontal: [{
+                type: Input
+            }], dndDragoverClass: [{
+                type: Input
+            }], dndDropzoneDisabledClass: [{
+                type: Input
+            }], dndDragover: [{
+                type: Output
+            }], dndDrop: [{
+                type: Output
+            }], dndPlaceholderRef: [{
+                type: ContentChild,
+                args: [DndPlaceholderRefDirective]
+            }], dndDisableIf: [{
+                type: Input
+            }], dndDisableDropIf: [{
+                type: Input
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd-dropzone.directive.js","sourceRoot":"","sources":["../../../../projects/dnd/src/lib/dnd-dropzone.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ContentChild,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n} from '@angular/core';\nimport {\n  getDndType,\n  getDropEffect,\n  isExternalDrag,\n  setDropEffect,\n} from './dnd-state';\nimport { DropEffect, EffectAllowed } from './dnd-types';\nimport {\n  DndEvent,\n  DragDropData,\n  getDirectChildElement,\n  getDropData,\n  shouldPositionPlaceholderBeforeElement,\n} from './dnd-utils';\n\nexport interface DndDropEvent {\n  event: DragEvent;\n  dropEffect: DropEffect;\n  isExternal: boolean;\n  data?: any;\n  index?: number;\n  type?: any;\n}\n\n@Directive({ selector: '[dndPlaceholderRef]', standalone: true })\nexport class DndPlaceholderRefDirective implements OnInit {\n  constructor(public readonly elementRef: ElementRef<HTMLElement>) {}\n\n  ngOnInit() {\n    // placeholder has to be \"invisible\" to the cursor, or it would interfere with the dragover detection for the same dropzone\n    this.elementRef.nativeElement.style.pointerEvents = 'none';\n  }\n}\n\n@Directive({ selector: '[dndDropzone]', standalone: true })\nexport class DndDropzoneDirective implements AfterViewInit, OnDestroy {\n  @Input() dndDropzone?: string[] | '' = '';\n\n  @Input() dndEffectAllowed: EffectAllowed = 'uninitialized';\n\n  @Input() dndAllowExternal: boolean = false;\n\n  @Input() dndHorizontal: boolean = false;\n\n  @Input() dndDragoverClass: string = 'dndDragover';\n\n  @Input() dndDropzoneDisabledClass = 'dndDropzoneDisabled';\n\n  @Output() readonly dndDragover: EventEmitter<DragEvent> =\n    new EventEmitter<DragEvent>();\n\n  @Output() readonly dndDrop: EventEmitter<DndDropEvent> =\n    new EventEmitter<DndDropEvent>();\n\n  @ContentChild(DndPlaceholderRefDirective)\n  private readonly dndPlaceholderRef?: DndPlaceholderRefDirective;\n\n  private placeholder: Element | null = null;\n\n  private disabled: boolean = false;\n\n  constructor(\n    private ngZone: NgZone,\n    private elementRef: ElementRef,\n    private renderer: Renderer2\n  ) {}\n\n  @Input() set dndDisableIf(value: boolean) {\n    this.disabled = value;\n\n    if (this.disabled) {\n      this.renderer.addClass(\n        this.elementRef.nativeElement,\n        this.dndDropzoneDisabledClass\n      );\n    } else {\n      this.renderer.removeClass(\n        this.elementRef.nativeElement,\n        this.dndDropzoneDisabledClass\n      );\n    }\n  }\n\n  @Input() set dndDisableDropIf(value: boolean) {\n    this.dndDisableIf = value;\n  }\n\n  ngAfterViewInit(): void {\n    this.placeholder = this.tryGetPlaceholder();\n\n    this.removePlaceholderFromDOM();\n\n    this.ngZone.runOutsideAngular(() => {\n      this.elementRef.nativeElement.addEventListener(\n        'dragenter',\n        this.dragEnterEventHandler\n      );\n      this.elementRef.nativeElement.addEventListener(\n        'dragover',\n        this.dragOverEventHandler\n      );\n      this.elementRef.nativeElement.addEventListener(\n        'dragleave',\n        this.dragLeaveEventHandler\n      );\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.elementRef.nativeElement.removeEventListener(\n      'dragenter',\n      this.dragEnterEventHandler\n    );\n    this.elementRef.nativeElement.removeEventListener(\n      'dragover',\n      this.dragOverEventHandler\n    );\n    this.elementRef.nativeElement.removeEventListener(\n      'dragleave',\n      this.dragLeaveEventHandler\n    );\n  }\n\n  onDragEnter(event: DndEvent) {\n    // check if another dropzone is activated\n    if (event._dndDropzoneActive === true) {\n      this.cleanupDragoverState();\n      return;\n    }\n\n    // set as active if the target element is inside this dropzone\n    if (event._dndDropzoneActive == null) {\n      const newTarget = document.elementFromPoint(event.clientX, event.clientY);\n\n      if (this.elementRef.nativeElement.contains(newTarget)) {\n        event._dndDropzoneActive = true;\n      }\n    }\n\n    // check if this drag event is allowed to drop on this dropzone\n    const type = getDndType(event);\n    if (!this.isDropAllowed(type)) {\n      return;\n    }\n\n    // allow the dragenter\n    event.preventDefault();\n  }\n\n  onDragOver(event: DragEvent) {\n    // With nested dropzones, we want to ignore this event if a child dropzone\n    // has already handled a dragover.  Historically, event.stopPropagation() was\n    // used to prevent this bubbling, but that prevents any dragovers outside the\n    // ngx-drag-drop component, and stops other use cases such as scrolling on drag.\n    // Instead, we can check if the event was already prevented by a child and bail early.\n    if (event.defaultPrevented) {\n      return;\n    }\n\n    // check if this drag event is allowed to drop on this dropzone\n    const type = getDndType(event);\n    if (!this.isDropAllowed(type)) {\n      return;\n    }\n\n    this.checkAndUpdatePlaceholderPosition(event);\n\n    const dropEffect = getDropEffect(event, this.dndEffectAllowed);\n\n    if (dropEffect === 'none') {\n      this.cleanupDragoverState();\n      return;\n    }\n\n    // allow the dragover\n    event.preventDefault();\n\n    // set the drop effect\n    setDropEffect(event, dropEffect);\n\n    this.dndDragover.emit(event);\n\n    this.renderer.addClass(\n      this.elementRef.nativeElement,\n      this.dndDragoverClass\n    );\n  }\n\n  @HostListener('drop', ['$event']) onDrop(event: DragEvent) {\n    try {\n      // check if this drag event is allowed to drop on this dropzone\n      const type = getDndType(event);\n      if (!this.isDropAllowed(type)) {\n        return;\n      }\n\n      const data: DragDropData = getDropData(event, isExternalDrag());\n\n      if (!this.isDropAllowed(data.type)) {\n        return;\n      }\n\n      // signal custom drop handling\n      event.preventDefault();\n\n      const dropEffect = getDropEffect(event);\n\n      setDropEffect(event, dropEffect);\n\n      if (dropEffect === 'none') {\n        return;\n      }\n\n      const dropIndex = this.getPlaceholderIndex();\n\n      // if for whatever reason the placeholder is not present in the DOM but it should be there\n      // we don't allow/emit the drop event since it breaks the contract\n      // seems to only happen if drag and drop is executed faster than the DOM updates\n      if (dropIndex === -1) {\n        return;\n      }\n\n      this.dndDrop.emit({\n        event: event,\n        dropEffect: dropEffect,\n        isExternal: isExternalDrag(),\n        data: data.data,\n        index: dropIndex,\n        type: type,\n      });\n\n      event.stopPropagation();\n    } finally {\n      this.cleanupDragoverState();\n    }\n  }\n\n  onDragLeave(event: DndEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n\n    // check if still inside this dropzone and not yet handled by another dropzone\n    if (event._dndDropzoneActive == null) {\n      if (this.elementRef.nativeElement.contains(event.relatedTarget)) {\n        event._dndDropzoneActive = true;\n        return;\n      }\n    }\n\n    this.cleanupDragoverState();\n\n    // cleanup drop effect when leaving dropzone\n    setDropEffect(event, 'none');\n  }\n\n  private readonly dragEnterEventHandler: (event: DragEvent) => void = (\n    event: DragEvent\n  ) => this.onDragEnter(event);\n\n  private readonly dragOverEventHandler: (event: DragEvent) => void = (\n    event: DragEvent\n  ) => this.onDragOver(event);\n\n  private readonly dragLeaveEventHandler: (event: DragEvent) => void = (\n    event: DragEvent\n  ) => this.onDragLeave(event);\n\n  private isDropAllowed(type?: string): boolean {\n    // dropzone is disabled -> deny it\n    if (this.disabled) {\n      return false;\n    }\n\n    // if drag did not start from our directive\n    // and external drag sources are not allowed -> deny it\n    if (isExternalDrag() && !this.dndAllowExternal) {\n      return false;\n    }\n\n    // no filtering by types -> allow it\n    if (!this.dndDropzone) {\n      return true;\n    }\n\n    // no type set -> allow it\n    if (!type) {\n      return true;\n    }\n\n    if (!Array.isArray(this.dndDropzone)) {\n      throw new Error(\n        'dndDropzone: bound value to [dndDropzone] must be an array!'\n      );\n    }\n\n    // if dropzone contains type -> allow it\n    return this.dndDropzone.indexOf(type) !== -1;\n  }\n\n  private tryGetPlaceholder(): Element | null {\n    if (typeof this.dndPlaceholderRef !== 'undefined') {\n      return this.dndPlaceholderRef.elementRef.nativeElement as Element;\n    }\n\n    // TODO nasty workaround needed because if ng-container / template is used @ContentChild() or DI will fail because\n    // of wrong context see angular bug https://github.com/angular/angular/issues/13517\n    return this.elementRef.nativeElement.querySelector('[dndPlaceholderRef]');\n  }\n\n  private removePlaceholderFromDOM() {\n    if (this.placeholder !== null && this.placeholder.parentNode !== null) {\n      this.placeholder.parentNode.removeChild(this.placeholder);\n    }\n  }\n\n  private checkAndUpdatePlaceholderPosition(event: DragEvent): void {\n    if (this.placeholder === null) {\n      return;\n    }\n\n    // make sure the placeholder is in the DOM\n    if (this.placeholder.parentNode !== this.elementRef.nativeElement) {\n      this.renderer.appendChild(\n        this.elementRef.nativeElement,\n        this.placeholder\n      );\n    }\n\n    // update the position if the event originates from a child element of the dropzone\n    const directChild = getDirectChildElement(\n      this.elementRef.nativeElement,\n      event.target as Element\n    );\n\n    // early exit if no direct child or direct child is placeholder\n    if (directChild === null || directChild === this.placeholder) {\n      return;\n    }\n\n    const positionPlaceholderBeforeDirectChild =\n      shouldPositionPlaceholderBeforeElement(\n        event,\n        directChild,\n        this.dndHorizontal\n      );\n\n    if (positionPlaceholderBeforeDirectChild) {\n      // do insert before only if necessary\n      if (directChild.previousSibling !== this.placeholder) {\n        this.renderer.insertBefore(\n          this.elementRef.nativeElement,\n          this.placeholder,\n          directChild\n        );\n      }\n    } else {\n      // do insert after only if necessary\n      if (directChild.nextSibling !== this.placeholder) {\n        this.renderer.insertBefore(\n          this.elementRef.nativeElement,\n          this.placeholder,\n          directChild.nextSibling\n        );\n      }\n    }\n  }\n\n  private getPlaceholderIndex(): number | undefined {\n    if (this.placeholder === null) {\n      return undefined;\n    }\n\n    const element = this.elementRef.nativeElement as HTMLElement;\n\n    return Array.prototype.indexOf.call(element.children, this.placeholder);\n  }\n\n  private cleanupDragoverState() {\n    this.renderer.removeClass(\n      this.elementRef.nativeElement,\n      this.dndDragoverClass\n    );\n\n    this.removePlaceholderFromDOM();\n  }\n}\n"]}

package/esm2022/lib/dnd-handle.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive, HostBinding, HostListener, inject, } from '@angular/core';
+import { DndDraggableDirective } from './dnd-draggable.directive';
+import * as i0 from "@angular/core";
+export class DndHandleDirective {
+    draggable = true;
+    dndDraggableDirective = inject(DndDraggableDirective);
+    ngOnInit() {
+        this.dndDraggableDirective.registerDragHandle(this);
+    }
+    onDragEvent(event) {
+        event._dndUsingHandle = true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndHandleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: DndHandleDirective, isStandalone: true, selector: "[dndHandle]", host: { listeners: { "dragstart": "onDragEvent($event)", "dragend": "onDragEvent($event)" }, properties: { "attr.draggable": "this.draggable" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndHandleDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dndHandle]', standalone: true }]
+        }], propDecorators: { draggable: [{
+                type: HostBinding,
+                args: ['attr.draggable']
+            }], onDragEvent: [{
+                type: HostListener,
+                args: ['dragstart', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['dragend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5kLWhhbmRsZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9kbmQvc3JjL2xpYi9kbmQtaGFuZGxlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsU0FBUyxFQUNULFdBQVcsRUFDWCxZQUFZLEVBQ1osTUFBTSxHQUVQLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQUlsRSxNQUFNLE9BQU8sa0JBQWtCO0lBQ0UsU0FBUyxHQUFHLElBQUksQ0FBQztJQUVoRCxxQkFBcUIsR0FBRyxNQUFNLENBQUMscUJBQXFCLENBQUMsQ0FBQztJQUV0RCxRQUFRO1FBQ04sSUFBSSxDQUFDLHFCQUFxQixDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3RELENBQUM7SUFJRCxXQUFXLENBQUMsS0FBZTtRQUN6QixLQUFLLENBQUMsZUFBZSxHQUFHLElBQUksQ0FBQztJQUMvQixDQUFDO3VHQWJVLGtCQUFrQjsyRkFBbEIsa0JBQWtCOzsyRkFBbEIsa0JBQWtCO2tCQUQ5QixTQUFTO21CQUFDLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFOzhCQUV2QixTQUFTO3NCQUF2QyxXQUFXO3VCQUFDLGdCQUFnQjtnQkFVN0IsV0FBVztzQkFGVixZQUFZO3VCQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQzs7c0JBQ3BDLFlBQVk7dUJBQUMsU0FBUyxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGlyZWN0aXZlLFxuICBIb3N0QmluZGluZyxcbiAgSG9zdExpc3RlbmVyLFxuICBpbmplY3QsXG4gIE9uSW5pdCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEbmREcmFnZ2FibGVEaXJlY3RpdmUgfSBmcm9tICcuL2RuZC1kcmFnZ2FibGUuZGlyZWN0aXZlJztcbmltcG9ydCB7IERuZEV2ZW50IH0gZnJvbSAnLi9kbmQtdXRpbHMnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICdbZG5kSGFuZGxlXScsIHN0YW5kYWxvbmU6IHRydWUgfSlcbmV4cG9ydCBjbGFzcyBEbmRIYW5kbGVEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQge1xuICBASG9zdEJpbmRpbmcoJ2F0dHIuZHJhZ2dhYmxlJykgZHJhZ2dhYmxlID0gdHJ1ZTtcblxuICBkbmREcmFnZ2FibGVEaXJlY3RpdmUgPSBpbmplY3QoRG5kRHJhZ2dhYmxlRGlyZWN0aXZlKTtcblxuICBuZ09uSW5pdCgpIHtcbiAgICB0aGlzLmRuZERyYWdnYWJsZURpcmVjdGl2ZS5yZWdpc3RlckRyYWdIYW5kbGUodGhpcyk7XG4gIH1cblxuICBASG9zdExpc3RlbmVyKCdkcmFnc3RhcnQnLCBbJyRldmVudCddKVxuICBASG9zdExpc3RlbmVyKCdkcmFnZW5kJywgWyckZXZlbnQnXSlcbiAgb25EcmFnRXZlbnQoZXZlbnQ6IERuZEV2ZW50KSB7XG4gICAgZXZlbnQuX2RuZFVzaW5nSGFuZGxlID0gdHJ1ZTtcbiAgfVxufVxuIl19

package/esm2022/lib/dnd.module.mjs

@@ -0,0 +1,38 @@
+import { NgModule } from '@angular/core';
+import { DndDraggableDirective, DndDragImageRefDirective, } from './dnd-draggable.directive';
+import { DndDropzoneDirective, DndPlaceholderRefDirective, } from './dnd-dropzone.directive';
+import { DndHandleDirective } from './dnd-handle.directive';
+import * as i0 from "@angular/core";
+export class DndModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.4", ngImport: i0, type: DndModule, imports: [DndDragImageRefDirective,
+            DndDropzoneDirective,
+            DndHandleDirective,
+            DndPlaceholderRefDirective,
+            DndDraggableDirective], exports: [DndDraggableDirective,
+            DndDropzoneDirective,
+            DndHandleDirective,
+            DndPlaceholderRefDirective,
+            DndDragImageRefDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DndModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        DndDraggableDirective,
+                        DndDropzoneDirective,
+                        DndHandleDirective,
+                        DndPlaceholderRefDirective,
+                        DndDragImageRefDirective,
+                    ],
+                    imports: [
+                        DndDragImageRefDirective,
+                        DndDropzoneDirective,
+                        DndHandleDirective,
+                        DndPlaceholderRefDirective,
+                        DndDraggableDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5kLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2RuZC9zcmMvbGliL2RuZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQ0wscUJBQXFCLEVBQ3JCLHdCQUF3QixHQUN6QixNQUFNLDJCQUEyQixDQUFDO0FBQ25DLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsMEJBQTBCLEdBQzNCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7O0FBa0I1RCxNQUFNLE9BQU8sU0FBUzt1R0FBVCxTQUFTO3dHQUFULFNBQVMsWUFQbEIsd0JBQXdCO1lBQ3hCLG9CQUFvQjtZQUNwQixrQkFBa0I7WUFDbEIsMEJBQTBCO1lBQzFCLHFCQUFxQixhQVhyQixxQkFBcUI7WUFDckIsb0JBQW9CO1lBQ3BCLGtCQUFrQjtZQUNsQiwwQkFBMEI7WUFDMUIsd0JBQXdCO3dHQVVmLFNBQVM7OzJGQUFULFNBQVM7a0JBaEJyQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxxQkFBcUI7d0JBQ3JCLG9CQUFvQjt3QkFDcEIsa0JBQWtCO3dCQUNsQiwwQkFBMEI7d0JBQzFCLHdCQUF3QjtxQkFDekI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLHdCQUF3Qjt3QkFDeEIsb0JBQW9CO3dCQUNwQixrQkFBa0I7d0JBQ2xCLDBCQUEwQjt3QkFDMUIscUJBQXFCO3FCQUN0QjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICBEbmREcmFnZ2FibGVEaXJlY3RpdmUsXG4gIERuZERyYWdJbWFnZVJlZkRpcmVjdGl2ZSxcbn0gZnJvbSAnLi9kbmQtZHJhZ2dhYmxlLmRpcmVjdGl2ZSc7XG5pbXBvcnQge1xuICBEbmREcm9wem9uZURpcmVjdGl2ZSxcbiAgRG5kUGxhY2Vob2xkZXJSZWZEaXJlY3RpdmUsXG59IGZyb20gJy4vZG5kLWRyb3B6b25lLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBEbmRIYW5kbGVEaXJlY3RpdmUgfSBmcm9tICcuL2RuZC1oYW5kbGUuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZXhwb3J0czogW1xuICAgIERuZERyYWdnYWJsZURpcmVjdGl2ZSxcbiAgICBEbmREcm9wem9uZURpcmVjdGl2ZSxcbiAgICBEbmRIYW5kbGVEaXJlY3RpdmUsXG4gICAgRG5kUGxhY2Vob2xkZXJSZWZEaXJlY3RpdmUsXG4gICAgRG5kRHJhZ0ltYWdlUmVmRGlyZWN0aXZlLFxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgRG5kRHJhZ0ltYWdlUmVmRGlyZWN0aXZlLFxuICAgIERuZERyb3B6b25lRGlyZWN0aXZlLFxuICAgIERuZEhhbmRsZURpcmVjdGl2ZSxcbiAgICBEbmRQbGFjZWhvbGRlclJlZkRpcmVjdGl2ZSxcbiAgICBEbmREcmFnZ2FibGVEaXJlY3RpdmUsXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIERuZE1vZHVsZSB7fVxuIl19