727 lines
30 KiB
JavaScript
727 lines
30 KiB
JavaScript
import * as i0 from '@angular/core';
|
|
import { inject, forwardRef, ElementRef, Directive, EventEmitter, Renderer2, NgZone, Input, Output, HostBinding, HostListener, ContentChild, NgModule } from '@angular/core';
|
|
|
|
const DROP_EFFECTS = ['move', 'copy', 'link'];
|
|
const CUSTOM_MIME_TYPE = 'application/x-dnd';
|
|
const JSON_MIME_TYPE = 'application/json';
|
|
const MSIE_MIME_TYPE = 'Text';
|
|
function mimeTypeIsCustom(mimeType) {
|
|
return mimeType.substr(0, CUSTOM_MIME_TYPE.length) === CUSTOM_MIME_TYPE;
|
|
}
|
|
function getWellKnownMimeType(event) {
|
|
if (event.dataTransfer) {
|
|
const types = event.dataTransfer.types;
|
|
// IE 9 workaround.
|
|
if (!types) {
|
|
return MSIE_MIME_TYPE;
|
|
}
|
|
for (let i = 0; i < types.length; i++) {
|
|
if (types[i] === MSIE_MIME_TYPE ||
|
|
types[i] === JSON_MIME_TYPE ||
|
|
mimeTypeIsCustom(types[i])) {
|
|
return types[i];
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function setDragData(event, data, effectAllowed) {
|
|
// Internet Explorer and Microsoft Edge don't support custom mime types, see design doc:
|
|
// https://github.com/marceljuenemann/angular-drag-and-drop-lists/wiki/Data-Transfer-Design
|
|
const mimeType = CUSTOM_MIME_TYPE + (data.type ? '-' + data.type : '');
|
|
const dataString = JSON.stringify(data);
|
|
try {
|
|
event.dataTransfer?.setData(mimeType, dataString);
|
|
}
|
|
catch (e) {
|
|
// Setting a custom MIME type did not work, we are probably in IE or Edge.
|
|
try {
|
|
event.dataTransfer?.setData(JSON_MIME_TYPE, dataString);
|
|
}
|
|
catch (e) {
|
|
// We are in Internet Explorer and can only use the Text MIME type. Also note that IE
|
|
// does not allow changing the cursor in the dragover event, therefore we have to choose
|
|
// the one we want to display now by setting effectAllowed.
|
|
const effectsAllowed = filterEffects(DROP_EFFECTS, effectAllowed);
|
|
if (event.dataTransfer) {
|
|
event.dataTransfer.effectAllowed = effectsAllowed[0];
|
|
}
|
|
event.dataTransfer?.setData(MSIE_MIME_TYPE, dataString);
|
|
}
|
|
}
|
|
}
|
|
function getDropData(event, dragIsExternal) {
|
|
// check if the mime type is well known
|
|
const mimeType = getWellKnownMimeType(event);
|
|
// drag did not originate from [dndDraggable]
|
|
if (dragIsExternal === true) {
|
|
if (mimeType !== null && mimeTypeIsCustom(mimeType)) {
|
|
// the type of content is well known and safe to handle
|
|
return JSON.parse(event.dataTransfer?.getData(mimeType) ?? '{}');
|
|
}
|
|
// the contained data is unknown, let user handle it
|
|
return {};
|
|
}
|
|
if (mimeType !== null) {
|
|
// the type of content is well known and safe to handle
|
|
return JSON.parse(event.dataTransfer?.getData(mimeType) ?? '{}');
|
|
}
|
|
// the contained data is unknown, let user handle it
|
|
return {};
|
|
}
|
|
function filterEffects(effects, allowed) {
|
|
if (allowed === 'all' || allowed === 'uninitialized') {
|
|
return effects;
|
|
}
|
|
return effects.filter(function (effect) {
|
|
return allowed.toLowerCase().indexOf(effect) !== -1;
|
|
});
|
|
}
|
|
function getDirectChildElement(parentElement, childElement) {
|
|
let directChild = childElement;
|
|
while (directChild.parentNode !== parentElement) {
|
|
// reached root node without finding given parent
|
|
if (!directChild.parentNode) {
|
|
return null;
|
|
}
|
|
directChild = directChild.parentNode;
|
|
}
|
|
return directChild;
|
|
}
|
|
function shouldPositionPlaceholderBeforeElement(event, element, horizontal) {
|
|
const bounds = element.getBoundingClientRect();
|
|
// If the pointer is in the upper half of the list item element,
|
|
// we position the placeholder before the list item, otherwise after it.
|
|
if (horizontal) {
|
|
return event.clientX < bounds.left + bounds.width / 2;
|
|
}
|
|
return event.clientY < bounds.top + bounds.height / 2;
|
|
}
|
|
function calculateDragImageOffset(event, dragImage) {
|
|
const dragImageComputedStyle = window.getComputedStyle(dragImage);
|
|
const paddingTop = parseFloat(dragImageComputedStyle.paddingTop) || 0;
|
|
const paddingLeft = parseFloat(dragImageComputedStyle.paddingLeft) || 0;
|
|
const borderTop = parseFloat(dragImageComputedStyle.borderTopWidth) || 0;
|
|
const borderLeft = parseFloat(dragImageComputedStyle.borderLeftWidth) || 0;
|
|
return {
|
|
x: event.offsetX + paddingLeft + borderLeft,
|
|
y: event.offsetY + paddingTop + borderTop,
|
|
};
|
|
}
|
|
function setDragImage(event, dragImage, offsetFunction) {
|
|
const offset = offsetFunction(event, dragImage) || { x: 0, y: 0 };
|
|
event.dataTransfer.setDragImage(dragImage, offset.x, offset.y);
|
|
}
|
|
|
|
const _dndState = {
|
|
isDragging: false,
|
|
dropEffect: 'none',
|
|
effectAllowed: 'all',
|
|
type: undefined,
|
|
};
|
|
function startDrag(event, effectAllowed, type) {
|
|
_dndState.isDragging = true;
|
|
_dndState.dropEffect = 'none';
|
|
_dndState.effectAllowed = effectAllowed;
|
|
_dndState.type = type;
|
|
if (event.dataTransfer) {
|
|
event.dataTransfer.effectAllowed = effectAllowed;
|
|
}
|
|
}
|
|
function endDrag() {
|
|
_dndState.isDragging = false;
|
|
_dndState.dropEffect = undefined;
|
|
_dndState.effectAllowed = undefined;
|
|
_dndState.type = undefined;
|
|
}
|
|
function setDropEffect(event, dropEffect) {
|
|
if (_dndState.isDragging === true) {
|
|
_dndState.dropEffect = dropEffect;
|
|
}
|
|
if (event.dataTransfer) {
|
|
event.dataTransfer.dropEffect = dropEffect;
|
|
}
|
|
}
|
|
function getDropEffect(event, effectAllowed) {
|
|
const dataTransferEffectAllowed = event.dataTransfer
|
|
? event.dataTransfer.effectAllowed
|
|
: 'uninitialized';
|
|
let effects = filterEffects(DROP_EFFECTS, dataTransferEffectAllowed);
|
|
if (_dndState.isDragging === true) {
|
|
effects = filterEffects(effects, _dndState.effectAllowed);
|
|
}
|
|
if (effectAllowed) {
|
|
effects = filterEffects(effects, effectAllowed);
|
|
}
|
|
// MacOS automatically filters dataTransfer.effectAllowed depending on the modifier keys,
|
|
// therefore the following modifier keys will only affect other operating systems.
|
|
if (effects.length === 0) {
|
|
return 'none';
|
|
}
|
|
if (event.ctrlKey && effects.indexOf('copy') !== -1) {
|
|
return 'copy';
|
|
}
|
|
if (event.altKey && effects.indexOf('link') !== -1) {
|
|
return 'link';
|
|
}
|
|
return effects[0];
|
|
}
|
|
function getDndType(event) {
|
|
if (_dndState.isDragging === true) {
|
|
return _dndState.type;
|
|
}
|
|
const mimeType = getWellKnownMimeType(event);
|
|
if (mimeType === null) {
|
|
return undefined;
|
|
}
|
|
if (mimeType === MSIE_MIME_TYPE || mimeType === JSON_MIME_TYPE) {
|
|
return undefined;
|
|
}
|
|
return mimeType.substr(CUSTOM_MIME_TYPE.length + 1) || undefined;
|
|
}
|
|
function isExternalDrag() {
|
|
return _dndState.isDragging === false;
|
|
}
|
|
const dndState = _dndState;
|
|
|
|
class DndDragImageRefDirective {
|
|
dndDraggableDirective = inject(forwardRef(() => DndDraggableDirective));
|
|
elementRef = inject(ElementRef);
|
|
ngOnInit() {
|
|
this.dndDraggableDirective.registerDragImage(this.elementRef);
|
|
}
|
|
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DndDragImageRefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
|
|
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: DndDragImageRefDirective, isStandalone: true, selector: "[dndDragImageRef]", ngImport: i0 });
|
|
}
|
|
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DndDragImageRefDirective, decorators: [{
|
|
type: Directive,
|
|
args: [{ selector: '[dndDragImageRef]', standalone: true }]
|
|
}] });
|
|
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: "16.0.1", ngImport: i0, type: DndDraggableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
|
|
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", 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: "16.0.1", 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']]
|
|
}] } });
|
|
|
|
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: "16.0.1", ngImport: i0, type: DndPlaceholderRefDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
|
|
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: DndPlaceholderRefDirective, isStandalone: true, selector: "[dndPlaceholderRef]", ngImport: i0 });
|
|
}
|
|
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DndPlaceholderRefDirective, decorators: [{
|
|
type: Directive,
|
|
args: [{ selector: '[dndPlaceholderRef]', standalone: true }]
|
|
}], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
|
|
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: "16.0.1", 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: "16.0.1", 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: "16.0.1", ngImport: i0, type: DndDropzoneDirective, decorators: [{
|
|
type: Directive,
|
|
args: [{ selector: '[dndDropzone]', standalone: true }]
|
|
}], 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']]
|
|
}] } });
|
|
|
|
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: "16.0.1", ngImport: i0, type: DndHandleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
|
|
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", 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: "16.0.1", 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']]
|
|
}] } });
|
|
|
|
class DndModule {
|
|
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DndModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
|
|
static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", 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: "16.0.1", ngImport: i0, type: DndModule });
|
|
}
|
|
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DndModule, decorators: [{
|
|
type: NgModule,
|
|
args: [{
|
|
exports: [
|
|
DndDraggableDirective,
|
|
DndDropzoneDirective,
|
|
DndHandleDirective,
|
|
DndPlaceholderRefDirective,
|
|
DndDragImageRefDirective,
|
|
],
|
|
imports: [
|
|
DndDragImageRefDirective,
|
|
DndDropzoneDirective,
|
|
DndHandleDirective,
|
|
DndPlaceholderRefDirective,
|
|
DndDraggableDirective,
|
|
],
|
|
}]
|
|
}] });
|
|
|
|
/*
|
|
* Public API Surface of dnd
|
|
*/
|
|
|
|
/**
|
|
* Generated bundle index. Do not edit.
|
|
*/
|
|
|
|
export { DndDragImageRefDirective, DndDraggableDirective, DndDropzoneDirective, DndHandleDirective, DndModule, DndPlaceholderRefDirective };
|
|
//# sourceMappingURL=ngx-drag-drop.mjs.map
|