@tft/interact 14.0.0 → 15.1.0

package/esm2022/lib/directives/draggable.directive.mjs

@@ -0,0 +1,320 @@
+import { Directive, ElementRef, Input, Output, EventEmitter, Optional, SkipSelf, Renderer2, ContentChild, ViewContainerRef, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import interact from 'interactjs';
+import { InteractService } from '../services/interact.service';
+import { DropzoneDirective } from './dropzone.directive';
+import { DEFAULT_REGISTRY_ID } from '../models';
+import { DragPreviewDirective } from './drag-preview.directive';
+import { getRootNode } from '../utils';
+import { DragRootDirective } from './drag-root.directive';
+import { AccountForScaleDirective } from './account-for-scale.directive';
+import { AutoScrollDirective } from './auto-scroll.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/interact.service";
+import * as i2 from "./account-for-scale.directive";
+import * as i3 from "./dropzone.directive";
+import * as i4 from "./drag-root.directive";
+import * as i5 from "./auto-scroll.directive";
+/** @dynamic */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class DraggableDirective {
+    // check all the different places for scale
+    get scale() {
+        return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale || this.dragRoot?.account_for_scale_dir?.scale || 1;
+    }
+    constructor(el, interactService, renderer, _viewContainerRef, _document, account_for_scale_dir, dropzone_dir, drag_root_dir, auto_scroll_dir) {
+        this.el = el;
+        this.interactService = interactService;
+        this.renderer = renderer;
+        this._viewContainerRef = _viewContainerRef;
+        this._document = _document;
+        this.account_for_scale_dir = account_for_scale_dir;
+        this.dropzone_dir = dropzone_dir;
+        this.drag_root_dir = drag_root_dir;
+        this.auto_scroll_dir = auto_scroll_dir;
+        /* zIndex while dragging*/
+        this.dragZIndex = 10000;
+        this.enableDragDefault = true;
+        /**
+         * @deprecated replaced by 'dragDisabled' property, please migrate before v13
+         */
+        this.disabled = false;
+        this.dragDisabled = false;
+        this.showPlaceholder = false;
+        // pipes all interact events to event emitters
+        this.dragStart = new EventEmitter();
+        this.dragMove = new EventEmitter();
+        this.dragInertiaStart = new EventEmitter();
+        this.dragEnd = new EventEmitter();
+    }
+    ngOnInit() {
+        this.interactable = this.initiateDragEvents(this.dragConfig, this.el.nativeElement);
+        this.dragRootEl = (this.dragRoot?.el?.nativeElement || this.drag_root_dir?.el?.nativeElement) || this._document.body;
+        // register with parent dropzone if it exists, otherwise use default
+        // this gives us a place on the registry to store our drag items that don't have a dropzone
+        this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;
+        // add draggable to directory and store its id
+        this.interactableId = this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);
+        this.alignPositionWithInputs(this.x, this.y);
+        // cache subscription to interactable state so we can unsubscribe onDestroy
+        this.interactableState = this.interactService
+            .getInteractableState(this.interactableId, this.registryId);
+        // keep our cached position values in line with our drag state
+        this.interactableSubscription = this.interactableState.subscribe((state) => {
+            this.y = state.y;
+            this.x = state.x;
+        });
+        this.setDragConfig();
+    }
+    // TODO: watch config here as well and update interactable
+    ngOnChanges(changes) {
+        // we do this here instead of using a setter on the input so that it
+        // will only run once when there is a change to x and y
+        if (changes.y || changes.x) {
+            this.alignPositionWithInputs(this.x, this.y);
+        }
+        if (changes.dragConfig || changes.disabled || changes.dragDisabled) {
+            if (!this.interactable)
+                return;
+            this.setDragConfig();
+        }
+        /**
+         * @deprecated remove this in v13
+         */
+        if (changes.disabled) {
+            console.warn(`It looks like your using the 'disabled' input on a tftDraggable directive, it has been deprecated and is replaced with 'dragDisabled', please migrate by v13`);
+        }
+    }
+    setDragConfig() {
+        const enabled = !(this.disabled || this.dragDisabled);
+        const dragConfig = { ...this.dragConfig, enabled };
+        this.interactable.draggable(dragConfig);
+    }
+    ngAfterViewInit() {
+        this.addDragPropertiesToElement(this.el.nativeElement);
+        if (!this.dropzone_dir) {
+            this.previewRef = this.el.nativeElement;
+        }
+    }
+    ngOnDestroy() {
+        // clean up state and subscriptions related to destroyed component
+        this.interactableSubscription.unsubscribe();
+        this.interactService.destroyInteractable(this.interactableId, this.registryId);
+    }
+    dragMoveListener(event, element) {
+        const { dx, dy } = event;
+        const scale = this.scale;
+        const deltaX = scale ? dx / scale : dx;
+        const deltaY = scale ? dy / scale : dy;
+        this.interactService.updateDeltas(this.interactableId, this.registryId, { deltaX, deltaY }, element);
+    }
+    setDragStyles(dragElement) {
+        this.renderer.setStyle(dragElement, 'touchAction', 'none');
+        this.renderer.setStyle(dragElement, 'zIndex', this.dragZIndex);
+        this.renderer.setStyle(dragElement, 'position', 'absolute');
+    }
+    addDragPropertiesToElement(nativeElement) {
+        this.renderer.setProperty(nativeElement, 'dropTarget', this.dropzone_dir || null);
+        this.renderer.setProperty(nativeElement, 'dragOrigin', this.dropzone_dir || null);
+        this.renderer.setProperty(nativeElement, 'dragRef', this);
+    }
+    mapDragEvent(event) {
+        const { target, dropzone } = event;
+        const dropzoneElement = dropzone?.target || target.dropTarget?.el.nativeElement;
+        const scale = this.scale;
+        const positionInDropTarget = target && dropzoneElement
+            ? this.interactService.calculatePositionInElement(dropzoneElement, this.previewRef, scale)
+            : null;
+        return {
+            interactEvent: event,
+            dragRef: this,
+            dragOrigin: target.dragOrigin,
+            dropTarget: target.dropTarget,
+            positionInDropTarget
+        };
+    }
+    setPosition(x, y) {
+        this.interactService.updatePosition(this.interactableId, this.registryId, { x, y }, this.el.nativeElement);
+    }
+    alignPositionWithInputs(x, y) {
+        // short circuit if positions aren't numbers or  if they haven't changed
+        if (!this.isValidPosition(x, y))
+            return;
+        this.interactService.updatePosition(this.interactableId, this.registryId, { x, y }, this.el.nativeElement);
+    }
+    isValidPosition(x, y) {
+        return this.isNumeric(x) && this.isNumeric(y);
+    }
+    // We use use this instead of isNaN here to try and help performance
+    // We should be able to reliably restrict to numbers or falsey values
+    isNumeric(num) {
+        return typeof num === 'number' && !isNaN(num);
+    }
+    initiateDragEvents(dragConfig, nativeElement) {
+        const defaultDragConfig = {
+            ...dragConfig,
+            enabled: !(this.disabled || this.dragDisabled),
+            ...(this.auto_scroll_dir && {
+                autoScroll: {
+                    ...this.auto_scroll_dir.autoScrollConfig,
+                    container: this.auto_scroll_dir.el.nativeElement
+                }
+            })
+        };
+        return interact(nativeElement).draggable(defaultDragConfig)
+            .on('dragstart', (event) => {
+            const interaction = event.interaction;
+            // check if we should append drag element to body
+            if (this.enableDragDefault
+                && interaction.pointerIsDown
+            // TODO: probably don't need following condition checks anymore remove by 2022
+            // && !!this.dropzone_dir
+            // && !interaction.interacting()
+            ) {
+                if (this._previewTemplate) {
+                    const viewRef = this._viewContainerRef.createEmbeddedView(this._previewTemplate.templateRef);
+                    this.previewRef = getRootNode(viewRef, this._document);
+                }
+                else {
+                    this.previewRef = cloneElement(this.el.nativeElement);
+                }
+                this.addDragPropertiesToElement(this.previewRef);
+                this.setDragStyles(this.previewRef);
+                this.dragRootEl.prepend(this.previewRef);
+                const scale = this.account_for_scale_dir?.scale || this.dragRoot?.account_for_scale_dir?.scale || 1;
+                const { x, y } = this.interactService.calculatePositionInElement(this.dragRootEl, nativeElement, scale);
+                this.interactService.updatePosition(this.interactableId, this.registryId, { x, y }, this.previewRef);
+                if (!this.showPlaceholder) {
+                    this.renderer.setStyle(this.el.nativeElement, 'display', 'none');
+                }
+            }
+            // subscribe to scroll events if they are there, by only subscribing on dragstart we avoid wasting subscriptions on interactables that aren't be dragged
+            if (this.auto_scroll_dir) {
+                this.subscribeToScrollEvents();
+            }
+            this.dragStart.emit(this.mapDragEvent(event));
+        })
+            .on('dragmove', (event) => {
+            if (this.enableDragDefault) {
+                const dragElement = this.dropzone_dir && this.previewRef || nativeElement;
+                this.dragMoveListener(event, dragElement);
+            }
+            const mappedEvent = this.mapDragEvent(event);
+            this.dragMove.emit(mappedEvent);
+        })
+            .on('draginertiastart', (event) => {
+            this.dragInertiaStart.emit(this.mapDragEvent(event));
+        })
+            .on('dragend', (event) => {
+            const mappedEvent = this.mapDragEvent(event);
+            if (!!this.dropzone_dir && this.dropzone_dir === event.target.dropTarget) {
+                const { x, y } = mappedEvent.positionInDropTarget;
+                this.setPosition(x, y);
+            }
+            this.renderer.setStyle(this.el.nativeElement, 'display', '');
+            this.dragEnd.emit(mappedEvent);
+            // unsubscribe from scroll events if subscribed
+            if (this.auto_scroll_dir) {
+                this.scrollEventsSubscription.unsubscribe();
+            }
+            if (this.el.nativeElement !== this.previewRef) {
+                // we do this in a timeout, so that we don't remove before the dropzone can get the boundingElementRect
+                setTimeout(() => {
+                    this.dragRootEl.removeChild(this.previewRef);
+                });
+            }
+        });
+    }
+    subscribeToScrollEvents() {
+        this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({ scrollLeft, scrollTop }) => {
+            const deltaX = this.scale ? scrollLeft / this.scale : scrollLeft;
+            const deltaY = this.scale ? scrollTop / this.scale : scrollTop;
+            this.interactService.updateDeltas(this.interactableId, this.registryId, { deltaX, deltaY }, this.previewRef);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DraggableDirective, deps: [{ token: i0.ElementRef }, { token: i1.InteractService }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: i2.AccountForScaleDirective, optional: true }, { token: i3.DropzoneDirective, optional: true, skipSelf: true }, { token: i4.DragRootDirective, optional: true, skipSelf: true }, { token: i5.AutoScrollDirective, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: DraggableDirective, selector: "[tftDraggable]", inputs: { x: "x", y: "y", dragZIndex: "dragZIndex", zIndex: "zIndex", interactableId: "interactableId", dragData: "dragData", enableDragDefault: "enableDragDefault", disabled: "disabled", dragDisabled: "dragDisabled", dragConfig: "dragConfig", showPlaceholder: "showPlaceholder", dragRoot: "dragRoot" }, outputs: { dragStart: "dragStart", dragMove: "dragMove", dragInertiaStart: "dragInertiaStart", dragEnd: "dragEnd" }, host: { properties: { "style.touchAction": "this.dragDisabled ? \"auto\" : \"none\"", "style.position": "\"absolute\"", "id": "interactableId" } }, queries: [{ propertyName: "_previewTemplate", first: true, predicate: DragPreviewDirective, descendants: true }], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DraggableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftDraggable]',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        '[style.touchAction]': 'this.dragDisabled ? "auto" : "none"',
+                        '[style.position]': '"absolute"',
+                        '[id]': 'interactableId',
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.InteractService }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i2.AccountForScaleDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i3.DropzoneDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i4.DragRootDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i5.AutoScrollDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }], propDecorators: { x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], dragZIndex: [{
+                type: Input
+            }], zIndex: [{
+                type: Input
+            }], interactableId: [{
+                type: Input
+            }], dragData: [{
+                type: Input
+            }], enableDragDefault: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], dragDisabled: [{
+                type: Input
+            }], dragConfig: [{
+                type: Input
+            }], showPlaceholder: [{
+                type: Input
+            }], dragRoot: [{
+                type: Input
+            }], dragStart: [{
+                type: Output
+            }], dragMove: [{
+                type: Output
+            }], dragInertiaStart: [{
+                type: Output
+            }], dragEnd: [{
+                type: Output
+            }], _previewTemplate: [{
+                type: ContentChild,
+                args: [DragPreviewDirective]
+            }] } });
+/**
+ * Component utils
+ */
+// create a clone of the component passed in and add it to the root component
+function cloneElement(element) {
+    const clone = element.cloneNode(true);
+    clone.removeAttribute('id');
+    return clone;
+}
+function getPreviewInsertionPoint(documentRef) {
+    // We can't use the body if the user is in fullscreen mode,
+    // because the preview will render under the fullscreen element.
+    return documentRef.fullscreenElement ||
+        documentRef.webkitFullscreenElement ||
+        documentRef.mozFullScreenElement ||
+        documentRef.msFullscreenElement ||
+        documentRef.body;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draggable.directive.js","sourceRoot":"","sources":["../../../../../../libs/interact/src/lib/directives/draggable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, OnInit, Output,\n   OnDestroy, EventEmitter, Optional, SkipSelf, Renderer2, SimpleChanges, OnChanges, ContentChild, ViewContainerRef, Inject, AfterViewInit } from '@angular/core';\nimport { DOCUMENT } from '@angular/common'\nimport interact from 'interactjs';\nimport { InteractService } from '../services/interact.service';\nimport { DraggableOptions, Interactable } from '@interactjs/types/index';\nimport { Subscription, Observable } from 'rxjs';\nimport { DropzoneDirective } from './dropzone.directive';\nimport { NgDragEvent, TftDragEvent, DEFAULT_REGISTRY_ID, TftCoords, TftDragElement} from '../models';\nimport { DragPreviewDirective } from './drag-preview.directive';\nimport { getRootNode } from '../utils';\nimport { DragRootDirective } from './drag-root.directive';\nimport { AccountForScaleDirective } from './account-for-scale.directive';\nimport { AutoScrollDirective } from './auto-scroll.directive';\n\n/** @dynamic */\n@Directive({\n  selector: '[tftDraggable]',\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    '[style.touchAction]': 'this.dragDisabled ? \"auto\" : \"none\"',\n    '[style.position]': '\"absolute\"',\n    '[id]': 'interactableId',\n  }\n})\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class DraggableDirective<D = any> implements OnInit, OnChanges, OnDestroy, AfterViewInit {\n\n\n  @Input() x: number;\n  @Input() y: number;\n  /* zIndex while dragging*/\n  @Input() dragZIndex = 10000;\n  /** zIndex while at rest */\n  @Input() zIndex: number\n  @Input() interactableId: string;\n  @Input() dragData: D;\n  @Input() enableDragDefault = true;\n  /**\n   * @deprecated replaced by 'dragDisabled' property, please migrate before v13\n   */\n  @Input() disabled = false;\n  @Input() dragDisabled = false;\n  @Input() dragConfig: Partial<Interact.OrBoolean<DraggableOptions>>;\n  @Input() showPlaceholder = false;\n\n  /**\n   * The element we want to prepend the drag element to.\n   * Use `tftDragRoot` directive on a parent element to set custom root element\n   *  @default document.body\n   */\n  @Input() dragRoot: DragRootDirective; // HTMLElement;\n\n  private dragRootEl: HTMLElement;\n  // pipes all interact events to event emitters\n  @Output() dragStart = new EventEmitter<TftDragEvent>();\n  @Output() dragMove = new EventEmitter<TftDragEvent>();\n  @Output() dragInertiaStart = new EventEmitter<TftDragEvent>();\n  @Output() dragEnd = new EventEmitter<TftDragEvent>();\n\n  @ContentChild(DragPreviewDirective) _previewTemplate: DragPreviewDirective;\n  // dragPreview: Interact.Element;\n  interactableState: Observable<TftCoords>;\n  interactable: Interactable;\n  private registryId: string;\n  private interactableSubscription: Subscription;\n  private scrollEventsSubscription: Subscription;\n\n  // cache holding element to use as drag preview (the element the user sees being dragged around)\n  previewRef: TftDragElement;\n  // check all the different places for scale\n  get scale(): number {\n    return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale || this.dragRoot?.account_for_scale_dir?.scale || 1;\n  }\n\n  constructor(\n    public el: ElementRef,\n    private interactService: InteractService,\n    private renderer: Renderer2,\n    private _viewContainerRef: ViewContainerRef,\n    @Inject(DOCUMENT) private _document: Document,\n    @Optional() public account_for_scale_dir?: AccountForScaleDirective,\n    @Optional() @SkipSelf() public dropzone_dir?: DropzoneDirective,\n    @Optional() @SkipSelf() public drag_root_dir?: DragRootDirective,\n    @Optional() @SkipSelf() public auto_scroll_dir?: AutoScrollDirective\n  ) { }\n\n  ngOnInit() {\n    this.interactable = this.initiateDragEvents(this.dragConfig, this.el.nativeElement);\n    this.dragRootEl = (this.dragRoot?.el?.nativeElement || this.drag_root_dir?.el?.nativeElement) as HTMLElement || this._document.body;\n    // register with parent dropzone if it exists, otherwise use default\n    // this gives us a place on the registry to store our drag items that don't have a dropzone\n    this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;\n    // add draggable to directory and store its id\n    this.interactableId = this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);\n    this.alignPositionWithInputs(this.x, this.y);\n    // cache subscription to interactable state so we can unsubscribe onDestroy\n    this.interactableState = this.interactService\n      .getInteractableState(this.interactableId, this.registryId);\n    // keep our cached position values in line with our drag state\n    this.interactableSubscription = this.interactableState.subscribe((state) => {\n      this.y = state.y;\n      this.x = state.x;\n    });\n    this.setDragConfig();\n  }\n\n  // TODO: watch config here as well and update interactable\n  ngOnChanges(changes: SimpleChanges) {\n    // we do this here instead of using a setter on the input so that it\n    // will only run once when there is a change to x and y\n    if(changes.y || changes.x) {\n      this.alignPositionWithInputs(this.x, this.y);\n    }\n    if(changes.dragConfig || changes.disabled || changes.dragDisabled) {\n      if(!this.interactable) return;\n      this.setDragConfig();\n    }\n    /**\n     * @deprecated remove this in v13\n     */\n    if (changes.disabled) {\n      console.warn(`It looks like your using the 'disabled' input on a tftDraggable directive, it has been deprecated and is replaced with 'dragDisabled', please migrate by v13`)\n    }\n  }\n\n  setDragConfig() {\n    const enabled = !(this.disabled || this.dragDisabled)\n    const dragConfig = {...this.dragConfig, enabled};\n    this.interactable.draggable(dragConfig);\n  }\n\n  ngAfterViewInit() {\n    this.addDragPropertiesToElement(this.el.nativeElement);\n    if (!this.dropzone_dir) {\n      this.previewRef = this.el.nativeElement;\n    }\n  }\n\n  ngOnDestroy() {\n    // clean up state and subscriptions related to destroyed component\n    this.interactableSubscription.unsubscribe();\n    this.interactService.destroyInteractable(this.interactableId, this.registryId);\n  }\n\n  dragMoveListener(event: NgDragEvent, element: Interact.Element) {\n    const { dx, dy } = event;\n    const scale = this.scale;\n    const deltaX = scale ? dx / scale : dx;\n    const deltaY = scale ? dy / scale : dy;\n\n    this.interactService.updateDeltas(\n      this.interactableId,\n      this.registryId,\n      {deltaX, deltaY},\n      element\n    );\n  }\n\n  setDragStyles(dragElement: HTMLElement) {\n    this.renderer.setStyle(dragElement, 'touchAction', 'none')\n    this.renderer.setStyle(dragElement, 'zIndex', this.dragZIndex)\n    this.renderer.setStyle(dragElement, 'position', 'absolute')\n  }\n\n  addDragPropertiesToElement(nativeElement: TftDragElement) {\n    this.renderer.setProperty(nativeElement, 'dropTarget', this.dropzone_dir || null);\n    this.renderer.setProperty(nativeElement, 'dragOrigin', this.dropzone_dir || null);\n    this.renderer.setProperty(nativeElement, 'dragRef', this);\n  }\n\n  mapDragEvent(event: NgDragEvent): TftDragEvent {\n    const { target, dropzone } = event;\n    const dropzoneElement = dropzone?.target || target.dropTarget?.el.nativeElement;\n    const scale = this.scale;\n    const positionInDropTarget = target && dropzoneElement\n      ? this.interactService.calculatePositionInElement(dropzoneElement, this.previewRef, scale)\n      : null;\n    return {\n      interactEvent: event,\n      dragRef: this,\n      dragOrigin: target.dragOrigin,\n      dropTarget: target.dropTarget,\n      positionInDropTarget\n    }\n  }\n\n  setPosition(x: number, y: number) {\n    this.interactService.updatePosition(\n      this.interactableId,\n      this.registryId,\n      {x, y},\n      this.el.nativeElement\n    );\n  }\n\n  alignPositionWithInputs(x: number, y: number) {\n    // short circuit if positions aren't numbers or  if they haven't changed\n    if(!this.isValidPosition(x, y)) return;\n    this.interactService.updatePosition(\n      this.interactableId,\n      this.registryId,\n      {x, y},\n      this.el.nativeElement\n    );\n  }\n\n  isValidPosition(x: number, y: number) {\n    return this.isNumeric(x) && this.isNumeric(y);\n  }\n  // We use use this instead of isNaN here to try and help performance\n  // We should be able to reliably restrict to numbers or falsey values\n  isNumeric(num: number) {\n    return typeof num === 'number' && !isNaN(num);\n  }\n\n  initiateDragEvents(dragConfig: Partial<Interact.OrBoolean<DraggableOptions>>, nativeElement: HTMLElement) {\n    const defaultDragConfig = {\n      ...dragConfig,\n      enabled:  !(this.disabled || this.dragDisabled),\n      ...(this.auto_scroll_dir && {\n        autoScroll:\n          {\n            ...this.auto_scroll_dir.autoScrollConfig,\n            container: this.auto_scroll_dir.el.nativeElement as HTMLElement\n          }\n        }\n      )\n    };\n    return interact(nativeElement).draggable(defaultDragConfig)\n      .on('dragstart',  (event: NgDragEvent) => {\n        const interaction = event.interaction;\n        // check if we should append drag element to body\n        if ( this.enableDragDefault\n          && interaction.pointerIsDown\n          // TODO: probably don't need following condition checks anymore remove by 2022\n          // && !!this.dropzone_dir\n          // && !interaction.interacting()\n          ) {\n          if (this._previewTemplate) {\n            const viewRef = this._viewContainerRef.createEmbeddedView(this._previewTemplate.templateRef);\n            this.previewRef = getRootNode(viewRef, this._document);\n          } else {\n            this.previewRef = cloneElement(this.el.nativeElement);\n          }\n          this.addDragPropertiesToElement(this.previewRef);\n          this.setDragStyles(this.previewRef)\n\n          this.dragRootEl.prepend(this.previewRef);\n          const scale = this.account_for_scale_dir?.scale || this.dragRoot?.account_for_scale_dir?.scale || 1;\n          const {x, y} = this.interactService.calculatePositionInElement(this.dragRootEl, nativeElement, scale);\n          this.interactService.updatePosition(this.interactableId, this.registryId, {x, y}, this.previewRef);\n          if (!this.showPlaceholder) {\n            this.renderer.setStyle(this.el.nativeElement, 'display', 'none');\n          }\n        }\n        // subscribe to scroll events if they are there, by only subscribing on dragstart we avoid wasting subscriptions on interactables that aren't be dragged\n        if (this.auto_scroll_dir) {\n          this.subscribeToScrollEvents();\n        }\n        this.dragStart.emit(this.mapDragEvent(event));\n      })\n      .on('dragmove', (event: NgDragEvent) => {\n        if (this.enableDragDefault) {\n          const dragElement = this.dropzone_dir && this.previewRef || nativeElement\n          this.dragMoveListener(event, dragElement);\n        }\n        const mappedEvent = this.mapDragEvent(event);\n        this.dragMove.emit(mappedEvent);\n      })\n      .on('draginertiastart', (event: NgDragEvent) => {\n        this.dragInertiaStart.emit(this.mapDragEvent(event))\n      })\n      .on('dragend', (event: NgDragEvent) => {\n        const mappedEvent = this.mapDragEvent(event)\n        if(!!this.dropzone_dir && this.dropzone_dir === event.target.dropTarget) {\n          const { x, y} = mappedEvent.positionInDropTarget;\n          this.setPosition(x, y);\n        }\n        this.renderer.setStyle(this.el.nativeElement, 'display', '');\n        this.dragEnd.emit(mappedEvent);\n        // unsubscribe from scroll events if subscribed\n        if (this.auto_scroll_dir) {\n          this.scrollEventsSubscription.unsubscribe();\n        }\n        if ( this.el.nativeElement !== this.previewRef) {\n          // we do this in a timeout, so that we don't remove before the dropzone can get the boundingElementRect\n          setTimeout(() => {\n            this.dragRootEl.removeChild(this.previewRef);\n          })\n        }\n      });\n  }\n\n  subscribeToScrollEvents() {\n    this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({scrollLeft, scrollTop}) => {\n      const deltaX = this.scale ? scrollLeft / this.scale : scrollLeft;\n      const deltaY = this.scale ? scrollTop / this.scale : scrollTop;\n\n      this.interactService.updateDeltas(\n        this.interactableId,\n        this.registryId,\n        {deltaX, deltaY},\n        this.previewRef\n      );\n    });\n\n  }\n}\n\n/**\n * Component utils\n */\n// create a clone of the component passed in and add it to the root component\nfunction cloneElement(element: HTMLElement) {\n  const clone = element.cloneNode(true) as HTMLElement;\n  clone.removeAttribute('id');\n  return clone;\n}\nfunction getPreviewInsertionPoint(documentRef: any): HTMLElement {\n  // We can't use the body if the user is in fullscreen mode,\n  // because the preview will render under the fullscreen element.\n  return documentRef.fullscreenElement ||\n         documentRef.webkitFullscreenElement ||\n         documentRef.mozFullScreenElement ||\n         documentRef.msFullscreenElement ||\n         documentRef.body;\n}\n"]}

package/esm2022/lib/directives/dropzone.directive.mjs

@@ -0,0 +1,114 @@
+import { Directive, ElementRef, Input, Output, EventEmitter, Renderer2, Optional, HostBinding } from '@angular/core';
+import interact from 'interactjs';
+import { InteractService } from '../services/interact.service';
+import { AccountForScaleDirective } from './account-for-scale.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/interact.service";
+import * as i2 from "./account-for-scale.directive";
+export class DropzoneDirective {
+    get scale() {
+        return this.account_for_scale_dir?.scale;
+    }
+    constructor(el, renderer, interactService, account_for_scale_dir) {
+        this.el = el;
+        this.renderer = renderer;
+        this.interactService = interactService;
+        this.account_for_scale_dir = account_for_scale_dir;
+        this.dropzoneConfig = {};
+        this.position = 'relative';
+        // proxies to pass interact events through to consumer of directive
+        this.dropActivate = new EventEmitter();
+        this.dragEnter = new EventEmitter();
+        this.dragLeave = new EventEmitter();
+        this.dragDrop = new EventEmitter();
+    }
+    ngOnInit() {
+        // connects
+        this.dropzone = this.connectDropzoneEvents(this.el.nativeElement, this.dropzoneConfig);
+        this.dropzoneId = this.interactService.addRegistryToSystem(this.dropzoneId);
+    }
+    ngOnChanges(changes) {
+        if (!changes.dropzoneConfig || !this.dropzone)
+            return;
+        // this.dropzone.unset();
+        // this.dropzone = this.connectDropzoneEvents(this.el.nativeElement, this.dropzoneConfig)
+        this.dropzone.dropzone(this.dropzoneConfig);
+    }
+    /**
+    * Connects element to interacts dropzone events and returns a reference to the interactable
+    * @param nativeElement the element to tie drop events to
+    * @param dropzoneConfig the interact configuration to use when connecting
+    */
+    connectDropzoneEvents(nativeElement, dropzoneConfig) {
+        return interact(nativeElement).dropzone(dropzoneConfig)
+            // TODO: investigate when this fires in different scenarios
+            .on('dropactivate', (event) => {
+            this.dropActivate.emit(this.mapDropzoneEvent(event));
+        })
+            .on('dragenter', (event) => {
+            this.renderer.setProperty(event.relatedTarget, 'dropTarget', this);
+            this.dragEnter.emit(this.mapDropzoneEvent(event));
+        })
+            .on('dragleave', (event) => {
+            if (event.relatedTarget.dropTarget === this) {
+                this.renderer.setProperty(event.relatedTarget, 'dropTarget', null);
+            }
+            this.dragLeave.emit(this.mapDropzoneEvent(event));
+        })
+            .on('drop', (event) => {
+            this.dragDrop.emit(this.mapDropzoneEvent(event));
+        });
+    }
+    /**
+     * Maps the drop event emitted by interact to something a little easier to use
+     * @param event the drop event emitted by interact, extended with extra fields we added to
+     */
+    mapDropzoneEvent(event) {
+        const zoneElement = event.target;
+        const dragElement = event.relatedTarget?.dragRef?.previewRef;
+        const scale = this.scale;
+        const positionInDropTarget = zoneElement && dragElement
+            ? this.interactService.calculatePositionInElement(zoneElement, dragElement, scale)
+            : null;
+        return {
+            interactEvent: event,
+            dragRef: dragElement.dragRef,
+            dragOrigin: dragElement.dragOrigin,
+            dropTarget: event.relatedTarget.dropTarget,
+            positionInDropTarget
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DropzoneDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.InteractService }, { token: i2.AccountForScaleDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: DropzoneDirective, selector: "[tftDropzone]", inputs: { dropzoneId: "dropzoneId", dropzoneConfig: "dropzoneConfig", dropzoneData: "dropzoneData", position: "position" }, outputs: { dropActivate: "dropActivate", dragEnter: "dragEnter", dragLeave: "dragLeave", dragDrop: "dragDrop" }, host: { properties: { "id": "dropzoneId", "style.position": "this.position" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DropzoneDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftDropzone]',
+                    host: {
+                        '[id]': 'dropzoneId'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.InteractService }, { type: i2.AccountForScaleDirective, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { dropzoneId: [{
+                type: Input
+            }], dropzoneConfig: [{
+                type: Input
+            }], dropzoneData: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['style.position']
+            }], dropActivate: [{
+                type: Output
+            }], dragEnter: [{
+                type: Output
+            }], dragLeave: [{
+                type: Output
+            }], dragDrop: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropzone.directive.js","sourceRoot":"","sources":["../../../../../../libs/interact/src/lib/directives/dropzone.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, OnInit, Output, EventEmitter, SimpleChanges, OnChanges, Renderer2, Optional, HostBinding } from '@angular/core';\nimport interact from 'interactjs';\nimport { DropzoneOptions, Interactable } from '@interactjs/types/index';\nimport { InteractService } from '../services/interact.service';\nimport { NgDropEvent, TftDragElement, TftDropEvent } from '../models';\nimport { AccountForScaleDirective } from './account-for-scale.directive';\n\nexport type PositionOption = 'relative' | 'absolute' | 'fixed' | 'static' | 'sticky' | 'unset' | 'inherit' | 'initial' | 'revert'\n@Directive({\n  selector: '[tftDropzone]',\n  host: {\n    '[id]': 'dropzoneId'\n  }\n})\nexport class DropzoneDirective implements OnInit, OnChanges {\n\n  @Input() dropzoneId: string;\n  @Input() dropzoneConfig: DropzoneOptions = {};\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  @Input() dropzoneData: any;\n\n  @Input()\n  @HostBinding('style.position') position: PositionOption = 'relative';\n  // proxies to pass interact events through to consumer of directive\n  @Output() dropActivate = new EventEmitter<TftDropEvent>();\n  @Output() dragEnter = new EventEmitter<TftDropEvent>();\n  @Output() dragLeave = new EventEmitter<TftDropEvent>();\n  @Output() dragDrop = new EventEmitter<TftDropEvent>();\n\n  dropzone: Interactable;\n\n  get scale(): number {\n    return this.account_for_scale_dir?.scale;\n  }\n  constructor(\n    public el: ElementRef,\n    private renderer: Renderer2,\n    private interactService: InteractService,\n    @Optional() private account_for_scale_dir?: AccountForScaleDirective\n  ) { }\n\n  ngOnInit() {\n    // connects\n    this.dropzone = this.connectDropzoneEvents(this.el.nativeElement, this.dropzoneConfig);\n    this.dropzoneId = this.interactService.addRegistryToSystem(this.dropzoneId);\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if(!changes.dropzoneConfig || !this.dropzone) return;\n    // this.dropzone.unset();\n    // this.dropzone = this.connectDropzoneEvents(this.el.nativeElement, this.dropzoneConfig)\n    this.dropzone.dropzone(this.dropzoneConfig)\n  }\n  /**\n  * Connects element to interacts dropzone events and returns a reference to the interactable\n  * @param nativeElement the element to tie drop events to\n  * @param dropzoneConfig the interact configuration to use when connecting\n  */\n  connectDropzoneEvents(nativeElement, dropzoneConfig: DropzoneOptions) {\n    return interact(nativeElement).dropzone(dropzoneConfig)\n      // TODO: investigate when this fires in different scenarios\n      .on('dropactivate', (event: NgDropEvent) => {\n        this.dropActivate.emit(this.mapDropzoneEvent(event));\n      })\n      .on('dragenter', (event: NgDropEvent) => {\n        this.renderer.setProperty(event.relatedTarget, 'dropTarget', this)\n        this.dragEnter.emit(this.mapDropzoneEvent(event));\n      })\n      .on('dragleave', (event: NgDropEvent) => {\n        if ( event.relatedTarget.dropTarget === this) {\n          this.renderer.setProperty(event.relatedTarget, 'dropTarget', null)\n        }\n        this.dragLeave.emit(this.mapDropzoneEvent(event));\n      })\n      .on('drop',  (event: NgDropEvent) => {\n        this.dragDrop.emit(this.mapDropzoneEvent(event));\n      });\n  }\n  /**\n   * Maps the drop event emitted by interact to something a little easier to use\n   * @param event the drop event emitted by interact, extended with extra fields we added to\n   */\n  mapDropzoneEvent(event: NgDropEvent): TftDropEvent {\n    const zoneElement = event.target;\n    const dragElement = event.relatedTarget?.dragRef?.previewRef as TftDragElement;\n    const scale = this.scale;\n    const positionInDropTarget = zoneElement && dragElement\n    ? this.interactService.calculatePositionInElement(zoneElement, dragElement, scale)\n    : null;\n    return {\n      interactEvent: event,\n      dragRef: dragElement.dragRef,\n      dragOrigin: dragElement.dragOrigin,\n      dropTarget: event.relatedTarget.dropTarget,\n      positionInDropTarget\n    }\n  }\n}\n"]}

package/esm2022/lib/directives/gesturable.directive.mjs

@@ -0,0 +1,82 @@
+import { Directive, ElementRef, Input, Output, EventEmitter, Optional } from '@angular/core';
+import interact from 'interactjs';
+import { DraggableDirective } from '../directives';
+import * as i0 from "@angular/core";
+import * as i1 from "../directives";
+/** @dynamic */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class GesturableDirective {
+    constructor(el, draggable_dir) {
+        this.el = el;
+        this.draggable_dir = draggable_dir;
+        this.gestureDisabled = false;
+        // pipes all interact events to event emitters
+        this.gestureStart = new EventEmitter();
+        this.gestureMove = new EventEmitter();
+        this.gestureEnd = new EventEmitter();
+    }
+    ngOnInit() {
+        this.gesturableId = this.draggable_dir?.interactableId || 'id';
+        this.interactable = this.initiateGestureEvents(this.gestureConfig, this.el.nativeElement);
+        this.setGestureConfig();
+    }
+    // TODO: watch config here as well and update interactable
+    ngOnChanges(changes) {
+        // we do this here instead of using a setter on the input so that it
+        // will only run once when there is a change to x and y
+        if (changes.gestureConfig || changes.gestureDisabled) {
+            if (!this.interactable)
+                return;
+            this.setGestureConfig();
+        }
+    }
+    setGestureConfig() {
+        const enabled = !this.gestureDisabled;
+        const gestureConfig = { ...this.gestureConfig, enabled };
+        this.interactable.gesturable(gestureConfig);
+    }
+    initiateGestureEvents(gestureConfig, nativeElement) {
+        const defaultConfig = {
+            enabled: !this.gestureDisabled,
+        };
+        const interactable = this.draggable_dir?.interactable || interact(nativeElement);
+        return interactable.gesturable({ ...defaultConfig, ...gestureConfig })
+            .on('gesturestart', (event) => {
+            this.gestureStart.emit({ gestureRef: this, interactEvent: event });
+        })
+            .on('gesturemove', (event) => {
+            this.gestureMove.emit({ gestureRef: this, interactEvent: event });
+        })
+            .on('gestureend', (event) => {
+            this.gestureEnd.emit({ gestureRef: this, interactEvent: event });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: GesturableDirective, deps: [{ token: i0.ElementRef }, { token: i1.DraggableDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: GesturableDirective, selector: "[tftGesturable]", inputs: { gesturableId: "gesturableId", gestureDisabled: "gestureDisabled", gestureConfig: "gestureConfig" }, outputs: { gestureStart: "gestureStart", gestureMove: "gestureMove", gestureEnd: "gestureEnd" }, host: { properties: { "id": "gesturableId" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: GesturableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftGesturable]',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        // '[style.touchAction]': 'this.gestureDisabled ? "auto" : "none"',
+                        '[id]': 'gesturableId',
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.DraggableDirective, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { gesturableId: [{
+                type: Input
+            }], gestureDisabled: [{
+                type: Input
+            }], gestureConfig: [{
+                type: Input
+            }], gestureStart: [{
+                type: Output
+            }], gestureMove: [{
+                type: Output
+            }], gestureEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/directives/index.mjs

@@ -1,10 +1,10 @@
-export * from './draggable.directive';
-export * from './dropzone.directive';
-export * from './resizable.directive';
-export * from './drag-preview.directive';
-export * from './gesturable.directive';
-export * from './drag-root.directive';
-export * from './account-for-scale.directive';
-export * from './apply-scale.directive';
-export * from './auto-scroll.directive';
+export * from './draggable.directive';
+export * from './dropzone.directive';
+export * from './resizable.directive';
+export * from './drag-preview.directive';
+export * from './gesturable.directive';
+export * from './drag-root.directive';
+export * from './account-for-scale.directive';
+export * from './apply-scale.directive';
+export * from './auto-scroll.directive';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhZ2dhYmxlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Ryb3B6b25lLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6YWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXByZXZpZXcuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZ2VzdHVyYWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXJvb3QuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYXBwbHktc2NhbGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0by1zY3JvbGwuZGlyZWN0aXZlJztcbiJdfQ==