ngx-drag-drop 2.0.0 → 13.0.0

package/README.md

@@ -318,8 +318,8 @@ https://github.com/timruffles/mobile-drag-drop
 ### Firefox
 
 * Beware that Firefox does not support dragging on `<button>` elements.
-  * `<button [dndDraggable]>` and `<button [dndHandler]>` won't work. 
-  * See https://bugzilla.mozilla.org/show_bug.cgi?id=568313 
+  * `<button [dndDraggable]>` and `<button [dndHandler]>` won't work.
+  * See https://bugzilla.mozilla.org/show_bug.cgi?id=568313
 
 
 ## Why?
@@ -329,36 +329,3 @@ HTML Drag-And-Drop API implementations are not behaving the same way across brow
 The directives contained in this module enable declarative drag and drop that "just works" across browsers in a consistent way.
 
 Credits go to the author and contributors of [angular-drag-drop-lists](https://github.com/marceljuenemann/angular-drag-and-drop-lists). 
-
-## Maintenance
-
-This project was generated with [Angular CLI](https://github.com/angular/angular-cli).
-
-For the library build it uses [ng-packagr](https://github.com/dherges/ng-packagr).
-
-#### Edit Library
-
-* edit lib code
-* run `npm start` (currently needs to be re-run on every lib code change)
-
-#### Release Library
-
-* assure correct version is set in `package.json`
-* build library with `npm run build:lib`
-* publish library with `npm run publish:stable` (use `npm run publish:next` for pre-releases)
-
-#### Release Docs
-
-* build docs site with `npm run build:docs`
-* commit and push changes in `docs` to `master`
-
-
----
-
-<p align="center">
-Made with :heart: & 
-<a href="https://www.jetbrains.com/?from=ngx-drag-drop">
-  <img align="center" alt="jetbrains" src="jetbrains.svg" width="120px" />
-</a>
-& :coffee:
-</p>

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

@@ -0,0 +1,192 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Input, Output } from "@angular/core";
+import { calculateDragImageOffset, setDragData, setDragImage } from "./dnd-utils";
+import { dndState, endDrag, startDrag } from "./dnd-state";
+import * as i0 from "@angular/core";
+export class DndDragImageRefDirective {
+    constructor(parent, elementRef) {
+        parent.registerDragImage(elementRef);
+    }
+}
+DndDragImageRefDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndDragImageRefDirective, deps: [{ token: DndDraggableDirective }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DndDragImageRefDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DndDragImageRefDirective, selector: "[dndDragImageRef]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndDragImageRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dndDragImageRef]"
+                }]
+        }], ctorParameters: function () { return [{ type: DndDraggableDirective }, { type: i0.ElementRef }]; } });
+export class DndDraggableDirective {
+    constructor(elementRef, renderer, ngZone) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.dndEffectAllowed = "copy";
+        this.dndDraggingClass = "dndDragging";
+        this.dndDraggingSourceClass = "dndDraggingSource";
+        this.dndDraggableDisabledClass = "dndDraggableDisabled";
+        this.dndDragImageOffsetFunction = calculateDragImageOffset;
+        this.dndStart = new EventEmitter();
+        this.dndDrag = new EventEmitter();
+        this.dndEnd = new EventEmitter();
+        this.dndMoved = new EventEmitter();
+        this.dndCopied = new EventEmitter();
+        this.dndLinked = new EventEmitter();
+        this.dndCanceled = new EventEmitter();
+        this.draggable = true;
+        this.isDragStarted = false;
+        this.dragEventHandler = (event) => this.onDrag(event);
+    }
+    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 === true) {
+            endDrag();
+        }
+    }
+    onDragStart(event) {
+        if (this.draggable === false) {
+            return false;
+        }
+        // check if there is dnd handle and if the dnd handle was used to start the drag
+        if (typeof this.dndHandle !== "undefined"
+            && typeof event._dndUsingHandle === "undefined") {
+            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 (typeof this.dndDragImageElementRef !== "undefined"
+            || typeof event._dndUsingHandle !== "undefined") {
+            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();
+        return true;
+    }
+    onDrag(event) {
+        this.dndDrag.emit(event);
+    }
+    onDragEnd(event) {
+        // get drop effect from custom stored state as its not reliable across browsers
+        const dropEffect = dndState.dropEffect;
+        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;
+    }
+    determineDragImage() {
+        // evaluate custom drag image existence
+        if (typeof this.dndDragImageElementRef !== "undefined") {
+            return this.dndDragImageElementRef.nativeElement;
+        }
+        else {
+            return this.elementRef.nativeElement;
+        }
+    }
+}
+DndDraggableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndDraggableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+DndDraggableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DndDraggableDirective, 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: "13.1.1", ngImport: i0, type: DndDraggableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dndDraggable]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }]; }, 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  HostBinding,\n  HostListener,\n  Input,\n  NgZone,\n  OnDestroy,\n  Output,\n  Renderer2\n} from \"@angular/core\";\nimport { calculateDragImageOffset, DndDragImageOffsetFunction, DndEvent, setDragData, setDragImage } from \"./dnd-utils\";\nimport { DndHandleDirective } from \"./dnd-handle.directive\";\nimport { dndState, endDrag, startDrag } from \"./dnd-state\";\nimport { EffectAllowed } from \"./dnd-types\";\n\n@Directive( {\n  selector: \"[dndDragImageRef]\"\n} )\nexport class DndDragImageRefDirective {\n\n  constructor( parent:DndDraggableDirective,\n               elementRef:ElementRef ) {\n\n    parent.registerDragImage( elementRef );\n  }\n}\n\n@Directive( {\n  selector: \"[dndDraggable]\"\n} )\nexport class DndDraggableDirective implements AfterViewInit, OnDestroy {\n\n  @Input()\n  dndDraggable:any;\n\n  @Input()\n  dndEffectAllowed:EffectAllowed = \"copy\";\n\n  @Input()\n  dndType?:string;\n\n  @Input()\n  dndDraggingClass = \"dndDragging\";\n\n  @Input()\n  dndDraggingSourceClass = \"dndDraggingSource\";\n\n  @Input()\n  dndDraggableDisabledClass = \"dndDraggableDisabled\";\n\n  @Input()\n  dndDragImageOffsetFunction:DndDragImageOffsetFunction = calculateDragImageOffset;\n\n  @Output()\n  readonly dndStart:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndDrag:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndEnd:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndMoved:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndCopied:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndLinked:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndCanceled:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @HostBinding( \"attr.draggable\" )\n  draggable = true;\n\n  private dndHandle?:DndHandleDirective;\n\n  private dndDragImageElementRef?:ElementRef;\n\n  private dragImage:Element | undefined;\n\n  private isDragStarted:boolean = false;\n\n  private readonly dragEventHandler:( event:DragEvent ) => void = ( event:DragEvent ) => this.onDrag( event );\n\n  @Input()\n  set dndDisableIf( value:boolean ) {\n\n    this.draggable = !value;\n\n    if( this.draggable ) {\n\n      this.renderer.removeClass( this.elementRef.nativeElement, this.dndDraggableDisabledClass );\n    }\n    else {\n\n      this.renderer.addClass( this.elementRef.nativeElement, this.dndDraggableDisabledClass );\n    }\n  }\n\n  @Input()\n  set dndDisableDragIf( value:boolean ) {\n    this.dndDisableIf = value;\n  }\n\n  constructor( private elementRef:ElementRef,\n               private renderer:Renderer2,\n               private ngZone:NgZone ) {\n  }\n\n  ngAfterViewInit():void {\n    this.ngZone.runOutsideAngular( () => {\n      this.elementRef.nativeElement.addEventListener( \"drag\", this.dragEventHandler );\n    } );\n  }\n\n  ngOnDestroy():void {\n    this.elementRef.nativeElement.removeEventListener( \"drag\", this.dragEventHandler );\n    if(this.isDragStarted === true) {\n      endDrag()\n    }\n  }\n\n  @HostListener( \"dragstart\", [ \"$event\" ] )\n  onDragStart( event:DndEvent ): boolean {\n\n    if( this.draggable === false ) {\n\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( typeof this.dndHandle !== \"undefined\"\n      && typeof event._dndUsingHandle === \"undefined\" ) {\n\n      return false;\n    }\n\n    // initialize global state\n    startDrag( event, this.dndEffectAllowed, this.dndType );\n\n    this.isDragStarted = true;\n\n    setDragData( event, {data: this.dndDraggable, type: this.dndType}, dndState.effectAllowed! );\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( typeof this.dndDragImageElementRef !== \"undefined\"\n      || typeof event._dndUsingHandle !== \"undefined\" ) {\n\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( this.elementRef.nativeElement, \"drag\", () => {\n\n      this.renderer.addClass( this.elementRef.nativeElement, this.dndDraggingSourceClass );\n      unregister();\n    } );\n\n    this.dndStart.emit( event );\n\n    event.stopPropagation();\n    return true;\n  }\n\n  onDrag( event:DragEvent ) {\n\n    this.dndDrag.emit( event );\n  }\n\n  @HostListener( \"dragend\", [ \"$event\" ] )\n  onDragEnd( event:DragEvent ) {\n\n    // get drop effect from custom stored state as its not reliable across browsers\n    const dropEffect = dndState.dropEffect;\n\n    let dropEffectEmitter:EventEmitter<DragEvent>;\n\n    switch( dropEffect ) {\n\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( this.elementRef.nativeElement, this.dndDraggingSourceClass );\n    }, 0 );\n\n    event.stopPropagation();\n  }\n\n  registerDragHandle( handle:DndHandleDirective | undefined ) {\n\n    this.dndHandle = handle;\n  }\n\n  registerDragImage( elementRef:ElementRef | undefined ) {\n\n    this.dndDragImageElementRef = elementRef;\n  }\n\n  private determineDragImage():Element {\n\n    // evaluate custom drag image existence\n    if( typeof this.dndDragImageElementRef !== \"undefined\" ) {\n\n      return this.dndDragImageElementRef.nativeElement as Element;\n    }\n    else {\n\n      return this.elementRef.nativeElement;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,277 @@
+import { ContentChild, Directive, EventEmitter, HostListener, Input, Output } from "@angular/core";
+import { getDirectChildElement, getDropData, shouldPositionPlaceholderBeforeElement } from "./dnd-utils";
+import { getDndType, getDropEffect, isExternalDrag, setDropEffect } from "./dnd-state";
+import * as i0 from "@angular/core";
+export class DndPlaceholderRefDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+}
+DndPlaceholderRefDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndPlaceholderRefDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DndPlaceholderRefDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DndPlaceholderRefDirective, selector: "[dndPlaceholderRef]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndPlaceholderRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dndPlaceholderRef]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+export class DndDropzoneDirective {
+    constructor(ngZone, elementRef, renderer) {
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.dndDropzone = "";
+        this.dndEffectAllowed = "uninitialized";
+        this.dndAllowExternal = false;
+        this.dndHorizontal = false;
+        this.dndDragoverClass = "dndDragover";
+        this.dndDropzoneDisabledClass = "dndDropzoneDisabled";
+        this.dndDragover = new EventEmitter();
+        this.dndDrop = new EventEmitter();
+        this.placeholder = null;
+        this.disabled = false;
+        this.dragEnterEventHandler = (event) => this.onDragEnter(event);
+        this.dragOverEventHandler = (event) => this.onDragOver(event);
+        this.dragLeaveEventHandler = (event) => this.onDragLeave(event);
+    }
+    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 (typeof event._dndDropzoneActive === "undefined") {
+            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) === false) {
+            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) === false) {
+            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) === false) {
+                return;
+            }
+            const data = getDropData(event, isExternalDrag());
+            if (this.isDropAllowed(data.type) === false) {
+                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) {
+        // check if still inside this dropzone and not yet handled by another dropzone
+        if (typeof event._dndDropzoneActive === "undefined") {
+            const newTarget = document.elementFromPoint(event.clientX, event.clientY);
+            if (this.elementRef.nativeElement.contains(newTarget)) {
+                event._dndDropzoneActive = true;
+                return;
+            }
+        }
+        this.cleanupDragoverState();
+        // cleanup drop effect when leaving dropzone
+        setDropEffect(event, "none");
+    }
+    isDropAllowed(type) {
+        // dropzone is disabled -> deny it
+        if (this.disabled === true) {
+            return false;
+        }
+        // if drag did not start from our directive
+        // and external drag sources are not allowed -> deny it
+        if (isExternalDrag() === true
+            && this.dndAllowExternal === false) {
+            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) === false) {
+            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();
+    }
+}
+DndDropzoneDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndDropzoneDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+DndDropzoneDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DndDropzoneDirective, 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: "13.1.1", ngImport: i0, type: DndDropzoneDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dndDropzone]"
+                }]
+        }], ctorParameters: function () { return [{ 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  Output,\n  Renderer2\n} from \"@angular/core\";\nimport {\n  DndEvent,\n  DragDropData,\n  getDirectChildElement,\n  getDropData,\n  shouldPositionPlaceholderBeforeElement\n} from \"./dnd-utils\";\nimport { getDndType, getDropEffect, isExternalDrag, setDropEffect } from \"./dnd-state\";\nimport { DropEffect, EffectAllowed } from \"./dnd-types\";\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( {\n  selector: \"[dndPlaceholderRef]\"\n} )\nexport class DndPlaceholderRefDirective {\n\n  constructor( public readonly elementRef:ElementRef ) {\n  }\n}\n\n@Directive( {\n  selector: \"[dndDropzone]\"\n} )\nexport class DndDropzoneDirective implements AfterViewInit, OnDestroy {\n\n  @Input()\n  dndDropzone?:string[] | \"\" = \"\";\n\n  @Input()\n  dndEffectAllowed:EffectAllowed = \"uninitialized\";\n\n  @Input()\n  dndAllowExternal:boolean = false;\n\n  @Input()\n  dndHorizontal:boolean = false;\n\n  @Input()\n  dndDragoverClass:string = \"dndDragover\";\n\n  @Input()\n  dndDropzoneDisabledClass = \"dndDropzoneDisabled\";\n\n  @Output()\n  readonly dndDragover:EventEmitter<DragEvent> = new EventEmitter<DragEvent>();\n\n  @Output()\n  readonly dndDrop:EventEmitter<DndDropEvent> = 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  private readonly dragEnterEventHandler:( event:DragEvent ) => void = ( event:DragEvent ) => this.onDragEnter( event );\n  private readonly dragOverEventHandler:( event:DragEvent ) => void = ( event:DragEvent ) => this.onDragOver( event );\n  private readonly dragLeaveEventHandler:( event:DragEvent ) => void = ( event:DragEvent ) => this.onDragLeave( event );\n\n  @Input()\n  set dndDisableIf( value:boolean ) {\n\n    this.disabled = !!value;\n\n    if( this.disabled ) {\n\n      this.renderer.addClass( this.elementRef.nativeElement, this.dndDropzoneDisabledClass );\n    }\n    else {\n\n      this.renderer.removeClass( this.elementRef.nativeElement, this.dndDropzoneDisabledClass );\n    }\n  }\n\n  @Input()\n  set dndDisableDropIf( value:boolean ) {\n    this.dndDisableIf = value;\n  }\n\n  constructor( private ngZone:NgZone,\n               private elementRef:ElementRef,\n               private renderer:Renderer2 ) {\n  }\n\n  ngAfterViewInit():void {\n\n    this.placeholder = this.tryGetPlaceholder();\n\n    this.removePlaceholderFromDOM();\n\n    this.ngZone.runOutsideAngular( () => {\n      this.elementRef.nativeElement.addEventListener( \"dragenter\", this.dragEnterEventHandler );\n      this.elementRef.nativeElement.addEventListener( \"dragover\", this.dragOverEventHandler );\n      this.elementRef.nativeElement.addEventListener( \"dragleave\", this.dragLeaveEventHandler );\n    } );\n  }\n\n  ngOnDestroy():void {\n    this.elementRef.nativeElement.removeEventListener( \"dragenter\", this.dragEnterEventHandler );\n    this.elementRef.nativeElement.removeEventListener( \"dragover\", this.dragOverEventHandler );\n    this.elementRef.nativeElement.removeEventListener( \"dragleave\", this.dragLeaveEventHandler );\n  }\n\n  onDragEnter( event:DndEvent ) {\n\n    // check if another dropzone is activated\n    if( event._dndDropzoneActive === true ) {\n\n      this.cleanupDragoverState();\n      return;\n    }\n\n    // set as active if the target element is inside this dropzone\n    if( typeof event._dndDropzoneActive === \"undefined\" ) {\n\n      const newTarget = document.elementFromPoint( event.clientX, event.clientY );\n\n      if( this.elementRef.nativeElement.contains( newTarget ) ) {\n\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 ) === false ) {\n\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\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 ) === false ) {\n\n      return;\n    }\n\n    this.checkAndUpdatePlaceholderPosition( event );\n\n    const dropEffect = getDropEffect( event, this.dndEffectAllowed );\n\n    if( dropEffect === \"none\" ) {\n\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( this.elementRef.nativeElement, this.dndDragoverClass );\n  }\n\n  @HostListener( \"drop\", [ \"$event\" ] )\n  onDrop( event:DragEvent ) {\n\n    try {\n\n      // check if this drag event is allowed to drop on this dropzone\n      const type = getDndType( event );\n      if( this.isDropAllowed( type ) === false ) {\n\n        return;\n      }\n\n      const data:DragDropData = getDropData( event, isExternalDrag() );\n\n      if( this.isDropAllowed( data.type ) === false ) {\n\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\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\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\n    }\n    finally {\n\n      this.cleanupDragoverState();\n    }\n  }\n\n  onDragLeave( event:DndEvent ) {\n\n    // check if still inside this dropzone and not yet handled by another dropzone\n    if( typeof event._dndDropzoneActive === \"undefined\" ) {\n\n      const newTarget = document.elementFromPoint( event.clientX, event.clientY );\n\n      if( this.elementRef.nativeElement.contains( newTarget ) ) {\n\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 isDropAllowed( type?:string ):boolean {\n\n    // dropzone is disabled -> deny it\n    if( this.disabled === true ) {\n\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() === true\n      && this.dndAllowExternal === false ) {\n\n      return false;\n    }\n\n    // no filtering by types -> allow it\n    if( !this.dndDropzone ) {\n\n      return true;\n    }\n\n    // no type set -> allow it\n    if( !type ) {\n\n      return true;\n    }\n\n    if( Array.isArray( this.dndDropzone ) === false ) {\n\n      throw new Error( \"dndDropzone: bound value to [dndDropzone] must be an array!\" );\n    }\n\n    // if dropzone contains type -> allow it\n    return this.dndDropzone.indexOf( type ) !== -1;\n  }\n\n  private tryGetPlaceholder():Element | null {\n\n    if( typeof this.dndPlaceholderRef !== \"undefined\" ) {\n\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\n    if( this.placeholder !== null\n      && this.placeholder.parentNode !== null ) {\n      this.placeholder.parentNode.removeChild( this.placeholder );\n    }\n  }\n\n  private checkAndUpdatePlaceholderPosition( event:DragEvent ):void {\n\n    if( this.placeholder === null ) {\n\n      return;\n    }\n\n    // make sure the placeholder is in the DOM\n    if( this.placeholder.parentNode !== this.elementRef.nativeElement ) {\n\n      this.renderer.appendChild( this.elementRef.nativeElement, this.placeholder );\n    }\n\n    // update the position if the event originates from a child element of the dropzone\n    const directChild = getDirectChildElement( this.elementRef.nativeElement, event.target as Element );\n\n    // early exit if no direct child or direct child is placeholder\n    if( directChild === null\n      || directChild === this.placeholder ) {\n\n      return;\n    }\n\n    const positionPlaceholderBeforeDirectChild = shouldPositionPlaceholderBeforeElement( event, directChild, this.dndHorizontal );\n\n    if( positionPlaceholderBeforeDirectChild ) {\n\n      // do insert before only if necessary\n      if( directChild.previousSibling !== this.placeholder ) {\n\n        this.renderer.insertBefore( this.elementRef.nativeElement, this.placeholder, directChild );\n      }\n    }\n    else {\n\n      // do insert after only if necessary\n      if( directChild.nextSibling !== this.placeholder ) {\n\n        this.renderer.insertBefore( this.elementRef.nativeElement, this.placeholder, directChild.nextSibling );\n      }\n    }\n  }\n\n  private getPlaceholderIndex():number | undefined {\n\n    if( this.placeholder === null ) {\n\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\n    this.renderer.removeClass( this.elementRef.nativeElement, this.dndDragoverClass );\n\n    this.removePlaceholderFromDOM();\n  }\n}\n"]}

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

@@ -0,0 +1,30 @@
+import { Directive, HostBinding, HostListener } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./dnd-draggable.directive";
+export class DndHandleDirective {
+    constructor(parent) {
+        this.draggable = true;
+        parent.registerDragHandle(this);
+    }
+    onDragEvent(event) {
+        event._dndUsingHandle = true;
+    }
+}
+DndHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndHandleDirective, deps: [{ token: i1.DndDraggableDirective }], target: i0.ɵɵFactoryTarget.Directive });
+DndHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DndHandleDirective, selector: "[dndHandle]", host: { listeners: { "dragstart": "onDragEvent($event)", "dragend": "onDragEvent($event)" }, properties: { "attr.draggable": "this.draggable" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DndHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dndHandle]"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DndDraggableDirective }]; }, propDecorators: { draggable: [{
+                type: HostBinding,
+                args: ["attr.draggable"]
+            }], onDragEvent: [{
+                type: HostListener,
+                args: ["dragstart", ["$event"]]
+            }, {
+                type: HostListener,
+                args: ["dragend", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5kLWhhbmRsZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9kbmQvc3JjL2xpYi9kbmQtaGFuZGxlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQU9yRSxNQUFNLE9BQU8sa0JBQWtCO0lBSzdCLFlBQWEsTUFBNEI7UUFGekMsY0FBUyxHQUFHLElBQUksQ0FBQztRQUlmLE1BQU0sQ0FBQyxrQkFBa0IsQ0FBRSxJQUFJLENBQUUsQ0FBQztJQUNwQyxDQUFDO0lBSUQsV0FBVyxDQUFFLEtBQWM7UUFFekIsS0FBSyxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUM7SUFDL0IsQ0FBQzs7K0dBZlUsa0JBQWtCO21HQUFsQixrQkFBa0I7MkZBQWxCLGtCQUFrQjtrQkFIOUIsU0FBUzttQkFBRTtvQkFDVixRQUFRLEVBQUUsYUFBYTtpQkFDeEI7NEdBSUMsU0FBUztzQkFEUixXQUFXO3VCQUFFLGdCQUFnQjtnQkFVOUIsV0FBVztzQkFGVixZQUFZO3VCQUFFLFdBQVcsRUFBRSxDQUFFLFFBQVEsQ0FBRTs7c0JBQ3ZDLFlBQVk7dUJBQUUsU0FBUyxFQUFFLENBQUUsUUFBUSxDQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0QmluZGluZywgSG9zdExpc3RlbmVyIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IERuZEV2ZW50IH0gZnJvbSBcIi4vZG5kLXV0aWxzXCI7XG5pbXBvcnQgeyBEbmREcmFnZ2FibGVEaXJlY3RpdmUgfSBmcm9tIFwiLi9kbmQtZHJhZ2dhYmxlLmRpcmVjdGl2ZVwiO1xuXG5ARGlyZWN0aXZlKCB7XG4gIHNlbGVjdG9yOiBcIltkbmRIYW5kbGVdXCJcbn0gKVxuZXhwb3J0IGNsYXNzIERuZEhhbmRsZURpcmVjdGl2ZSB7XG5cbiAgQEhvc3RCaW5kaW5nKCBcImF0dHIuZHJhZ2dhYmxlXCIgKVxuICBkcmFnZ2FibGUgPSB0cnVlO1xuXG4gIGNvbnN0cnVjdG9yKCBwYXJlbnQ6RG5kRHJhZ2dhYmxlRGlyZWN0aXZlICkge1xuXG4gICAgcGFyZW50LnJlZ2lzdGVyRHJhZ0hhbmRsZSggdGhpcyApO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lciggXCJkcmFnc3RhcnRcIiwgWyBcIiRldmVudFwiIF0gKVxuICBASG9zdExpc3RlbmVyKCBcImRyYWdlbmRcIiwgWyBcIiRldmVudFwiIF0gKVxuICBvbkRyYWdFdmVudCggZXZlbnQ6RG5kRXZlbnQgKSB7XG5cbiAgICBldmVudC5fZG5kVXNpbmdIYW5kbGUgPSB0cnVlO1xuICB9XG59XG4iXX0=