@tft/interact 12.5.3 → 13.0.0

package/esm2020/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 {
+    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();
+    }
+    get scale() {
+        return this.account_for_scale_dir?.scale;
+    }
+    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
+        };
+    }
+}
+DropzoneDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: DropzoneDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.InteractService }, { token: i2.AccountForScaleDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+DropzoneDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", 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: "13.2.1", ngImport: i0, type: DropzoneDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftDropzone]',
+                    host: {
+                        '[id]': 'dropzoneId'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ 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/esm2020/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 });
+        });
+    }
+}
+GesturableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: GesturableDirective, deps: [{ token: i0.ElementRef }, { token: i1.DraggableDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+GesturableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", 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: "13.2.1", 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: function () { return [{ 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/lib/directives/index.mjs

@@ -0,0 +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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhZ2dhYmxlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Ryb3B6b25lLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6YWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXByZXZpZXcuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZ2VzdHVyYWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXJvb3QuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYXBwbHktc2NhbGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0by1zY3JvbGwuZGlyZWN0aXZlJztcbiJdfQ==

package/esm2020/lib/directives/resizable.directive.mjs

@@ -0,0 +1,228 @@
+import { Directive, ElementRef, Input, Optional, SkipSelf, Output, EventEmitter, Renderer2, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import interact from 'interactjs';
+import { InteractService } from '../services/interact.service';
+import { DraggableDirective } from './draggable.directive';
+import { DropzoneDirective } from './dropzone.directive';
+import { DragRootDirective } from './drag-root.directive';
+import { AccountForScaleDirective } from './account-for-scale.directive';
+import { DEFAULT_REGISTRY_ID } from '../models';
+import { AutoScrollDirective } from './auto-scroll.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/interact.service";
+import * as i2 from "./drag-root.directive";
+import * as i3 from "./account-for-scale.directive";
+import * as i4 from "./draggable.directive";
+import * as i5 from "./dropzone.directive";
+import * as i6 from "./auto-scroll.directive";
+/** @dynamic */
+export class ResizableDirective {
+    constructor(el, _document, interactService, renderer, drag_root_dir, account_for_scale_dir, draggable_dir, dropzone_dir, auto_scroll_dir) {
+        this.el = el;
+        this._document = _document;
+        this.interactService = interactService;
+        this.renderer = renderer;
+        this.drag_root_dir = drag_root_dir;
+        this.account_for_scale_dir = account_for_scale_dir;
+        this.draggable_dir = draggable_dir;
+        this.dropzone_dir = dropzone_dir;
+        this.auto_scroll_dir = auto_scroll_dir;
+        this.enableResizeDefault = true;
+        // TODO: should this be an input with default or should consuming user set display in styles each time
+        this.position = 'absolute';
+        this.resizeDisabled = false;
+        this.resizeStart = new EventEmitter();
+        this.resizeMove = new EventEmitter();
+        this.resizeInertiaStart = new EventEmitter();
+        this.resizeEnd = new EventEmitter();
+        this.defaultConfig = {
+            edges: { left: true, right: true, bottom: true, top: true }
+        };
+        this.activeEdges = { left: false, right: false, top: false, bottom: false };
+        this.dragRootEl = drag_root_dir?.el?.nativeElement || this._document.body;
+    }
+    get scale() {
+        return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale;
+    }
+    ngOnInit() {
+        this.addResizePropertiesToElement(this.el.nativeElement);
+        // we check for a dropzone, we use its id as the registry id if there is on
+        // otherwise, we use DEFAULT_REGISTRY_ID as a registry id. This allows us to keep our interactable
+        // drag state organized by dropzones.
+        this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;
+        this.interactableId = this.draggable_dir?.interactableId || this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);
+        this.interactable = this.initiateResizeEvents({ ...this.defaultConfig, ...this.resizeConfig }, this.el.nativeElement);
+        this.alignDimensionsWithInputs(this.width, this.height);
+        this.interactableSubscription = this.interactService
+            .getInteractableState(this.interactableId, this.registryId)
+            .subscribe();
+    }
+    ngOnChanges(changes) {
+        if ((changes.resizeConfig || changes.resizeDisabled) && this.interactable) {
+            this.interactable.resizable({ ...this.resizeConfig, enabled: !this.resizeDisabled, });
+        }
+        if (changes.width || changes.height) {
+            this.alignDimensionsWithInputs(this.width, this.height);
+        }
+    }
+    ngOnDestroy() {
+        this.interactableSubscription.unsubscribe();
+        this.interactService.destroyInteractable(this.interactableId, this.registryId);
+    }
+    resizeListener(event) {
+        const element = this.el.nativeElement;
+        const scale = this.scale;
+        const { deltaRect } = event;
+        const deltaX = deltaRect.left / scale;
+        const deltaY = deltaRect.top / scale;
+        // We get the width and height directly from the native element because
+        // the event dimension can get out of sync when resizing with autoScroll
+        const rect = element.getBoundingClientRect();
+        const width = (rect.width + deltaRect.width) / scale;
+        const height = (rect.height + deltaRect.height) / scale;
+        this.interactService.updateSize(this.interactableId, this.registryId, { deltaX, deltaY, width, height }, this.el.nativeElement);
+    }
+    /**
+     *  hook elements into interacts resize event listeners
+     *  we spread the configs so that the consuming component only overwrites the
+     *  pieces that it explicitly indicates
+     * @param resizeConfig
+     * @param nativeElement
+     */
+    initiateResizeEvents(resizeConfig, nativeElement) {
+        // TODO: This should try and get interactable from tft_draggable if it exists
+        const defaultResizeConfig = {
+            ...resizeConfig,
+            enabled: !this.resizeDisabled,
+            ...(this.auto_scroll_dir && {
+                autoScroll: {
+                    ...this.auto_scroll_dir.autoScrollConfig,
+                    container: this.auto_scroll_dir.el.nativeElement
+                }
+            })
+        };
+        const interactable = this.draggable_dir?.interactable || interact(nativeElement);
+        return interactable.resizable(defaultResizeConfig)
+            .on('resizestart', (event) => {
+            this.activeEdges = event.edges;
+            if (this.auto_scroll_dir) {
+                this.subscribeToScrollEvents();
+            }
+            this.resizeStart.emit(this.mapResizeEvent(event));
+        })
+            .on('resizemove', (event) => {
+            if (this.enableResizeDefault) {
+                this.resizeListener(event);
+            }
+            const mappedEvent = this.mapResizeEvent(event);
+            this.resizeMove.emit(mappedEvent);
+        })
+            .on('resizeinertiastart', (event) => this.resizeInertiaStart.emit(this.mapResizeEvent(event)))
+            .on('resizeend', (event) => {
+            if (this.auto_scroll_dir) {
+                this.scrollEventsSubscription.unsubscribe();
+            }
+            this.activeEdges = { left: false, right: false, top: false, bottom: false };
+            this.resizeEnd.emit(this.mapResizeEvent(event));
+        });
+    }
+    mapResizeEvent(event) {
+        const target = this.el.nativeElement;
+        const relatedTarget = this.draggable_dir?.dropzone_dir?.el.nativeElement;
+        const scale = this.scale;
+        const positionInDropTarget = target && relatedTarget
+            ? this.interactService.calculatePositionInElement(relatedTarget, target, scale)
+            : null;
+        return {
+            interactEvent: event,
+            resizeRef: this,
+            dragRef: this.draggable_dir,
+            dragOrigin: this.dropzone_dir,
+            dropTarget: this.el.nativeElement.dropTarget,
+            positionInDropTarget,
+            size: {
+                width: target.clientWidth / scale,
+                height: target.clientHeight / scale
+            }
+        };
+    }
+    alignDimensionsWithInputs(width, height) {
+        this.interactService.updateSize(this.interactableId, this.registryId, { deltaX: 0, deltaY: 0, width, height }, this.el.nativeElement);
+    }
+    addResizePropertiesToElement(nativeElement) {
+        this.renderer.setProperty(nativeElement, 'resizeRef', this);
+    }
+    subscribeToScrollEvents() {
+        this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({ scrollLeft, scrollTop }) => {
+            const scale = this.scale;
+            const target = this.el.nativeElement;
+            const { width: prevWidth, height: prevHeight } = target.getBoundingClientRect();
+            const deltaHeight = scrollTop * (this.activeEdges.top ? -1 : this.activeEdges.bottom ? 1 : 0);
+            const deltaWidth = scrollLeft * (this.activeEdges.left ? -1 : this.activeEdges.right ? 1 : 0);
+            const height = (prevHeight + deltaHeight) / scale;
+            const width = (prevWidth + deltaWidth) / scale;
+            const deltaX = this.activeEdges.left ? (scrollLeft / scale) : 0;
+            const deltaY = this.activeEdges.top ? (scrollTop / scale) : 0;
+            this.interactService.updateSize(this.interactableId, this.registryId, { deltaX, deltaY, width, height }, this.el.nativeElement);
+        });
+    }
+}
+ResizableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: i1.InteractService }, { token: i0.Renderer2 }, { token: i2.DragRootDirective, optional: true }, { token: i3.AccountForScaleDirective, optional: true }, { token: i4.DraggableDirective, optional: true }, { token: i5.DropzoneDirective, optional: true, skipSelf: true }, { token: i6.AutoScrollDirective, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.1", type: ResizableDirective, selector: "[tftResizable]", inputs: { enableResizeDefault: "enableResizeDefault", position: "position", resizeConfig: "resizeConfig", interactableId: "interactableId", width: "width", height: "height", resizeDisabled: "resizeDisabled" }, outputs: { resizeStart: "resizeStart", resizeMove: "resizeMove", resizeInertiaStart: "resizeInertiaStart", resizeEnd: "resizeEnd" }, host: { properties: { "style.touchAction": "this.resizeDisabled ? \"auto\" : \"none\"", "style.position": "position", "style.boxSizing": "\"border-box\"" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ResizableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftResizable]',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        // prevents touch events from colliding with with mouse events
+                        // on touch screen
+                        '[style.touchAction]': 'this.resizeDisabled ? "auto" : "none"',
+                        // default to absolute here to accommodate likely use cases
+                        // consuming component can easily over ride with position input
+                        '[style.position]': 'position',
+                        // follows interactjs suggested practices
+                        '[style.boxSizing]': '"border-box"',
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.InteractService }, { type: i0.Renderer2 }, { type: i2.DragRootDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i3.AccountForScaleDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i4.DraggableDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i5.DropzoneDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i6.AutoScrollDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; }, propDecorators: { enableResizeDefault: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], resizeConfig: [{
+                type: Input
+            }], interactableId: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], resizeDisabled: [{
+                type: Input
+            }], resizeStart: [{
+                type: Output
+            }], resizeMove: [{
+                type: Output
+            }], resizeInertiaStart: [{
+                type: Output
+            }], resizeEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable.directive.js","sourceRoot":"","sources":["../../../../../../libs/interact/src/lib/directives/resizable.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAqB,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAA4B,SAAS,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AACtK,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAiC,mBAAmB,EAAkB,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;AAQ9D,eAAe;AAgBf,MAAM,OAAO,kBAAkB;IAiC7B,YACS,EAAc,EACK,SAAmB,EACrC,eAAgC,EAChC,QAAmB,EACP,aAAiC,EAClC,qBAAgD,EAC/C,aAAkC,EACtB,YAAgC,EACjC,eAAqC;QAR7D,OAAE,GAAF,EAAE,CAAY;QACK,cAAS,GAAT,SAAS,CAAU;QACrC,oBAAe,GAAf,eAAe,CAAiB;QAChC,aAAQ,GAAR,QAAQ,CAAW;QACP,kBAAa,GAAb,aAAa,CAAoB;QAClC,0BAAqB,GAArB,qBAAqB,CAA2B;QAC/C,kBAAa,GAAb,aAAa,CAAqB;QACtB,iBAAY,GAAZ,YAAY,CAAoB;QACjC,oBAAe,GAAf,eAAe,CAAsB;QAxC7D,wBAAmB,GAAG,IAAI,CAAC;QACpC,sGAAsG;QAC7F,aAAQ,GAAG,UAAU,CAAC;QAMtB,mBAAc,GAAG,KAAK,CAAC;QAEtB,gBAAW,GAAG,IAAI,YAAY,EAAkB,CAAC;QACjD,eAAU,GAAG,IAAI,YAAY,EAAkB,CAAC;QAChD,uBAAkB,GAAG,IAAI,YAAY,EAAkB,CAAC;QACxD,cAAS,GAAG,IAAI,YAAY,EAAkB,CAAC;QAEzD,kBAAa,GAAkD;YAC7D,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;SAC5D,CAAC;QAMM,gBAAW,GAAgB,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAC,CAAA;QAqBvF,IAAI,CAAC,UAAU,GAAI,aAAa,EAAE,EAAE,EAAE,aAA6B,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;IAC7F,CAAC;IAlBD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,qBAAqB,EAAE,KAAK,IAAI,IAAI,CAAC,aAAa,EAAE,qBAAqB,EAAE,KAAK,CAAC;IAC/F,CAAC;IAkBD,QAAQ;QACN,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;QAEzD,2EAA2E;QAC3E,kGAAkG;QAClG,qCAAqC;QACrC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,IAAI,mBAAmB,CAAC;QAEvE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,EAAE,cAAc,IAAI,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAE9I,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,oBAAoB,CAC3C,EAAC,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,EAC9C,IAAI,CAAC,EAAE,CAAC,aAAa,CACtB,CAAC;QAEF,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAExD,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,eAAe;aACjD,oBAAoB,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC;aAC1D,SAAS,EAAE,CAAC;IACjB,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE;YACzE,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,EAAC,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,cAAc,GAAE,CAAC,CAAC;SACrF;QACD,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE;YACnC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;SACzD;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC;QAC5C,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACjF,CAAC;IAED,cAAc,CAAC,KAAkB;QAC/B,MAAM,OAAO,GAAmB,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC;QACtD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,EAAC,SAAS,EAAC,GAAG,KAAK,CAAC;QAC1B,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,GAAC,KAAK,CAAC;QACpC,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,GAAC,KAAK,CAAC;QACnC,uEAAuE;QACvE,wEAAwE;QACxE,MAAM,IAAI,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAC,KAAK,CAAC;QACnD,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,GAAC,KAAK,CAAC;QAEtD,IAAI,CAAC,eAAe,CAAC,UAAU,CAC7B,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,UAAU,EACf,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAC,EAC/B,IAAI,CAAC,EAAE,CAAC,aAAa,CACtB,CAAC;IACJ,CAAC;IACD;;;;;;OAMG;IACH,oBAAoB,CAAC,YAA2D,EAAE,aAA6B;QAC7G,6EAA6E;QAC7E,MAAM,mBAAmB,GAAG;YAC1B,GAAG,YAAY;YACf,OAAO,EAAE,CAAC,IAAI,CAAC,cAAc;YAC7B,GAAG,CAAC,IAAI,CAAC,eAAe,IAAI;gBAC1B,UAAU,EAAE;oBACV,GAAG,IAAI,CAAC,eAAe,CAAC,gBAAgB;oBACxC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,aAA4B;iBAChE;aACF,CAAC;SACH,CAAC;QACF,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,IAAI,QAAQ,CAAC,aAAa,CAAC,CAAC;QACjF,OAAO,YAAY,CAAC,SAAS,CAAC,mBAAmB,CAAC;aAC/C,EAAE,CAAC,aAAa,EAAE,CAAC,KAAoB,EAAE,EAAE;YAC1C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,KAAoB,CAAC;YAC9C,IAAI,IAAI,CAAC,eAAe,EAAE;gBACxB,IAAI,CAAC,uBAAuB,EAAE,CAAC;aAChC;YACD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,CAAC,CAAC;aACD,EAAE,CAAC,YAAY,EAAG,CAAC,KAAoB,EAAE,EAAE;YAC1C,IAAI,IAAI,CAAC,mBAAmB,EAAE;gBAC5B,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;aAC3B;YACD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC/C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QACnC,CAAC,CAAC;aACD,EAAE,CAAC,oBAAoB,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;aAC5G,EAAE,CAAC,WAAW,EAAE,CAAC,KAAoB,EAAE,EAAE;YACxC,IAAI,IAAI,CAAC,eAAe,EAAE;gBACxB,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC;aAC7C;YACD,IAAI,CAAC,WAAW,GAAG,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAC,CAAA;YAEzE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,KAAoB;QACjC,MAAM,MAAM,GAAI,IAAI,CAAC,EAAE,CAAC,aAA+B,CAAC;QACxD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,EAAE,EAAE,CAAC,aAAa,CAAC;QACzE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,MAAM,oBAAoB,GAAG,MAAM,IAAI,aAAa;YAClD,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,0BAA0B,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC;YAC/E,CAAC,CAAC,IAAI,CAAC;QACT,OAAO;YACL,aAAa,EAAE,KAAK;YACpB,SAAS,EAAE,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,aAAa;YAC3B,UAAU,EAAE,IAAI,CAAC,YAAY;YAC7B,UAAU,EAAE,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,UAAU;YAC5C,oBAAoB;YACpB,IAAI,EAAE;gBACJ,KAAK,EAAE,MAAM,CAAC,WAAW,GAAG,KAAK;gBACjC,MAAM,EAAE,MAAM,CAAC,YAAY,GAAG,KAAK;aACpC;SACF,CAAA;IACH,CAAC;IAED,yBAAyB,CAAC,KAAa,EAAE,MAAc;QACrD,IAAI,CAAC,eAAe,CAAC,UAAU,CAC7B,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,UAAU,EACf,EAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAC,EACrC,IAAI,CAAC,EAAE,CAAC,aAAa,CACtB,CAAC;IACJ,CAAC;IAED,4BAA4B,CAAC,aAA6B;QACxD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,uBAAuB;QACrB,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,EAAC,UAAU,EAAE,SAAS,EAAC,EAAE,EAAE;YAC7G,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACzB,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,aAA4B,CAAC;YACpD,MAAM,EAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAC,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;YAE9E,MAAM,WAAW,GAAG,SAAS,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9F,MAAM,UAAU,GAAG,UAAU,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE9F,MAAM,MAAM,GAAG,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,KAAK,CAAC;YAClD,MAAM,KAAK,GAAG,CAAC,SAAS,GAAG,UAAU,CAAC,GAAG,KAAK,CAAC;YAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAChE,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9D,IAAI,CAAC,eAAe,CAAC,UAAU,CAC7B,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,UAAU,EACf,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAC,EAC/B,IAAI,CAAC,EAAE,CAAC,aAA4B,CACrC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;;+GA5MU,kBAAkB,4CAmCnB,QAAQ;mGAnCP,kBAAkB;2FAAlB,kBAAkB;kBAf9B,SAAS;mBAAC;oBACT,QAAQ,EAAE,gBAAgB;oBAC1B,qEAAqE;oBACrE,IAAI,EAAE;wBACJ,8DAA8D;wBAC9D,kBAAkB;wBAClB,qBAAqB,EAAE,uCAAuC;wBAC9D,2DAA2D;wBAC3D,+DAA+D;wBAC/D,kBAAkB,EAAE,UAAU;wBAC9B,yCAAyC;wBACzC,mBAAmB,EAAE,cAAc;qBAEpC;iBACF;mFAoCwC,QAAQ;0BAA5C,MAAM;2BAAC,QAAQ;;0BAGf,QAAQ;;0BACR,QAAQ;;0BACR,QAAQ;;0BACR,QAAQ;;0BAAI,QAAQ;;0BACpB,QAAQ;;0BAAI,QAAQ;4CAxCd,mBAAmB;sBAA3B,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBAEI,WAAW;sBAApB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,kBAAkB;sBAA3B,MAAM;gBACG,SAAS;sBAAlB,MAAM","sourcesContent":["import { Directive, OnInit, OnDestroy, ElementRef, Input, Optional, SkipSelf, Output, EventEmitter, OnChanges, SimpleChanges, Renderer2, Inject} from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport interact from 'interactjs';\nimport { InteractService } from '../services/interact.service';\nimport { ResizableOptions, ResizeEvent, Interactable } from '@interactjs/types/index';\nimport { Subscription } from 'rxjs';\nimport { DraggableDirective } from './draggable.directive';\nimport { DropzoneDirective } from './dropzone.directive';\nimport { DragRootDirective } from './drag-root.directive';\nimport { AccountForScaleDirective } from './account-for-scale.directive';\nimport { NgResizeEvent, TftResizeEvent, DEFAULT_REGISTRY_ID, TftDragElement } from '../models';\nimport { AutoScrollDirective } from './auto-scroll.directive';\n\ninterface ActiveEdges {\n  top: boolean;\n  bottom: boolean;\n  left: boolean;\n  right: boolean;\n}\n/** @dynamic */\n@Directive({\n  selector: '[tftResizable]',\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    // prevents touch events from colliding with with mouse events\n    // on touch screen\n    '[style.touchAction]': 'this.resizeDisabled ? \"auto\" : \"none\"',\n    // default to absolute here to accommodate likely use cases\n    // consuming component can easily over ride with position input\n    '[style.position]': 'position',\n    // follows interactjs suggested practices\n    '[style.boxSizing]': '\"border-box\"',\n\n  }\n})\nexport class ResizableDirective implements OnInit, OnDestroy, OnChanges {\n\n  @Input() enableResizeDefault = true;\n  // TODO: should this be an input with default or should consuming user set display in styles each time\n  @Input() position = 'absolute';\n  @Input() resizeConfig: Partial<Interact.OrBoolean<ResizableOptions>>;\n  @Input() interactableId: string;\n\n  @Input() width: number;\n  @Input() height: number;\n  @Input() resizeDisabled = false;\n\n  @Output() resizeStart = new EventEmitter<TftResizeEvent>();\n  @Output() resizeMove = new EventEmitter<TftResizeEvent>();\n  @Output() resizeInertiaStart = new EventEmitter<TftResizeEvent>();\n  @Output() resizeEnd = new EventEmitter<TftResizeEvent>();\n\n  defaultConfig: Partial<Interact.OrBoolean<ResizableOptions>> = {\n    edges: { left: true, right: true, bottom: true, top: true }\n  };\n  registryId: string;\n  interactable: Interactable;\n  // The\n  dragRootEl: HTMLElement;\n\n  private activeEdges: ActiveEdges = {left: false, right: false, top: false, bottom: false}\n  private interactableSubscription: Subscription;\n  private scrollEventsSubscription: Subscription;\n\n  get scale(): number {\n    return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale;\n  }\n\n  constructor(\n    public el: ElementRef,\n    @Inject(DOCUMENT) private _document: Document,\n    private interactService: InteractService,\n    private renderer: Renderer2,\n    @Optional() private drag_root_dir?: DragRootDirective,\n    @Optional() public account_for_scale_dir?: AccountForScaleDirective,\n    @Optional() private draggable_dir?: DraggableDirective,\n    @Optional() @SkipSelf() private dropzone_dir?: DropzoneDirective,\n    @Optional() @SkipSelf() public auto_scroll_dir?: AutoScrollDirective\n\n\n  ) {\n    this.dragRootEl = (drag_root_dir?.el?.nativeElement as HTMLElement) || this._document.body;\n  }\n\n  ngOnInit() {\n    this.addResizePropertiesToElement(this.el.nativeElement);\n\n    // we check for a dropzone, we use its id as the registry id if there is on\n    // otherwise, we use DEFAULT_REGISTRY_ID as a registry id. This allows us to keep our interactable\n    // drag state organized by dropzones.\n    this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;\n\n    this.interactableId = this.draggable_dir?.interactableId || this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);\n\n    this.interactable = this.initiateResizeEvents(\n      {...this.defaultConfig, ...this.resizeConfig },\n      this.el.nativeElement\n    );\n\n    this.alignDimensionsWithInputs(this.width, this.height);\n\n    this.interactableSubscription = this.interactService\n      .getInteractableState(this.interactableId, this.registryId)\n      .subscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if ((changes.resizeConfig || changes.resizeDisabled) && this.interactable) {\n      this.interactable.resizable({...this.resizeConfig, enabled: !this.resizeDisabled,});\n    }\n    if (changes.width || changes.height) {\n      this.alignDimensionsWithInputs(this.width, this.height);\n    }\n  }\n\n  ngOnDestroy() {\n    this.interactableSubscription.unsubscribe();\n    this.interactService.destroyInteractable(this.interactableId, this.registryId);\n  }\n\n  resizeListener(event: ResizeEvent) {\n    const element: TftDragElement = this.el.nativeElement;\n    const scale = this.scale;\n    const {deltaRect} = event;\n    const deltaX = deltaRect.left/scale;\n    const deltaY = deltaRect.top/scale;\n    // We get the width and height directly from the native element because\n    // the event dimension can get out of sync when resizing with autoScroll\n    const rect = element.getBoundingClientRect();\n    const width = (rect.width + deltaRect.width)/scale;\n    const height = (rect.height + deltaRect.height)/scale;\n\n    this.interactService.updateSize(\n      this.interactableId,\n      this.registryId,\n      {deltaX, deltaY, width, height},\n      this.el.nativeElement\n    );\n  }\n  /**\n   *  hook elements into interacts resize event listeners\n   *  we spread the configs so that the consuming component only overwrites the\n   *  pieces that it explicitly indicates\n   * @param resizeConfig\n   * @param nativeElement\n   */\n  initiateResizeEvents(resizeConfig: Partial<Interact.OrBoolean<ResizableOptions>>, nativeElement: TftDragElement) {\n    // TODO: This should try and get interactable from tft_draggable if it exists\n    const defaultResizeConfig = {\n      ...resizeConfig,\n      enabled: !this.resizeDisabled,\n      ...(this.auto_scroll_dir && {\n        autoScroll: {\n          ...this.auto_scroll_dir.autoScrollConfig,\n          container: this.auto_scroll_dir.el.nativeElement as HTMLElement\n        }\n      })\n    };\n    const interactable = this.draggable_dir?.interactable || interact(nativeElement);\n    return interactable.resizable(defaultResizeConfig)\n      .on('resizestart', (event: NgResizeEvent) => {\n        this.activeEdges = event.edges as ActiveEdges;\n        if (this.auto_scroll_dir) {\n          this.subscribeToScrollEvents();\n        }\n        this.resizeStart.emit(this.mapResizeEvent(event))\n      })\n      .on('resizemove',  (event: NgResizeEvent) => {\n        if (this.enableResizeDefault) {\n          this.resizeListener(event)\n        }\n        const mappedEvent = this.mapResizeEvent(event);\n        this.resizeMove.emit(mappedEvent)\n      })\n      .on('resizeinertiastart', (event: NgResizeEvent) => this.resizeInertiaStart.emit(this.mapResizeEvent(event)))\n      .on('resizeend', (event: NgResizeEvent) => {\n        if (this.auto_scroll_dir) {\n          this.scrollEventsSubscription.unsubscribe();\n        }\n        this.activeEdges = {left: false, right: false, top: false, bottom: false}\n\n        this.resizeEnd.emit(this.mapResizeEvent(event));\n      });\n  }\n\n  mapResizeEvent(event: NgResizeEvent ): TftResizeEvent {\n    const target  = this.el.nativeElement as TftDragElement;\n    const relatedTarget = this.draggable_dir?.dropzone_dir?.el.nativeElement;\n    const scale = this.scale;\n    const positionInDropTarget = target && relatedTarget\n      ? this.interactService.calculatePositionInElement(relatedTarget, target, scale)\n      : null;\n    return {\n      interactEvent: event,\n      resizeRef: this,\n      dragRef: this.draggable_dir,\n      dragOrigin: this.dropzone_dir,\n      dropTarget: this.el.nativeElement.dropTarget,\n      positionInDropTarget,\n      size: {\n        width: target.clientWidth / scale,\n        height: target.clientHeight / scale\n      }\n    }\n  }\n\n  alignDimensionsWithInputs(width: number, height: number) {\n    this.interactService.updateSize(\n      this.interactableId,\n      this.registryId,\n      {deltaX: 0, deltaY: 0, width, height},\n      this.el.nativeElement\n    );\n  }\n\n  addResizePropertiesToElement(nativeElement: TftDragElement) {\n    this.renderer.setProperty(nativeElement, 'resizeRef', this);\n  }\n\n  subscribeToScrollEvents() {\n    this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({scrollLeft, scrollTop}) => {\n      const scale = this.scale;\n      const target = this.el.nativeElement as HTMLElement;\n      const {width: prevWidth, height: prevHeight} = target.getBoundingClientRect();\n\n      const deltaHeight = scrollTop * (this.activeEdges.top ? -1 : this.activeEdges.bottom ? 1 : 0);\n      const deltaWidth = scrollLeft * (this.activeEdges.left ? -1 : this.activeEdges.right ? 1 : 0);\n\n      const height = (prevHeight + deltaHeight) / scale;\n      const width = (prevWidth + deltaWidth) / scale;\n      const deltaX = this.activeEdges.left ? (scrollLeft / scale) : 0;\n      const deltaY = this.activeEdges.top ? (scrollTop / scale) : 0;\n      this.interactService.updateSize(\n        this.interactableId,\n        this.registryId,\n        {deltaX, deltaY, width, height},\n        this.el.nativeElement as HTMLElement\n      );\n    });\n  }\n}\n"]}

package/esm2020/lib/interact.module.mjs

@@ -0,0 +1,66 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ArrayOfNPipe } from './pipes/array-of-n.pipe';
+import { ApplyScaleDirective, DraggableDirective, DragRootDirective, AutoScrollDirective, AccountForScaleDirective, GesturableDirective, ResizableDirective, DropzoneDirective, DragPreviewDirective } from './directives';
+import { InteractService } from './services/interact.service';
+import { INTERACT_ROOT_CONFIG } from './models';
+import * as i0 from "@angular/core";
+const EXPORTS = [
+    DraggableDirective,
+    ResizableDirective,
+    DropzoneDirective,
+    GesturableDirective,
+    DragRootDirective,
+    AutoScrollDirective,
+    AccountForScaleDirective,
+    ApplyScaleDirective,
+    DragPreviewDirective,
+    ArrayOfNPipe,
+];
+export class InteractModule {
+    static forRoot(config) {
+        const defaultConfig = { cssDimensionUnit: 'px' };
+        return {
+            ngModule: InteractModule,
+            providers: [
+                { provide: INTERACT_ROOT_CONFIG, useValue: { ...defaultConfig, ...config } },
+                InteractService
+            ]
+        };
+    }
+}
+InteractModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+InteractModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractModule, declarations: [DraggableDirective,
+        ResizableDirective,
+        DropzoneDirective,
+        GesturableDirective,
+        DragRootDirective,
+        AutoScrollDirective,
+        AccountForScaleDirective,
+        ApplyScaleDirective,
+        DragPreviewDirective,
+        ArrayOfNPipe], imports: [CommonModule], exports: [DraggableDirective,
+        ResizableDirective,
+        DropzoneDirective,
+        GesturableDirective,
+        DragRootDirective,
+        AutoScrollDirective,
+        AccountForScaleDirective,
+        ApplyScaleDirective,
+        DragPreviewDirective,
+        ArrayOfNPipe] });
+InteractModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    // providers: [{ provide: INTERACT_ROOT_CONFIG, useValue: 'px' }],
+                    declarations: [
+                        ...EXPORTS,
+                    ],
+                    exports: [
+                        ...EXPORTS
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './interact';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9saWIvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbnRlcmFjdCc7Il19

package/esm2020/lib/models/interact.mjs

@@ -0,0 +1,28 @@
+import { InjectionToken } from '@angular/core';
+export const INTERACT_ROOT_CONFIG = new InjectionToken('INTERACT_ROOT_CONFIG_PARAMS');
+export const DEFAULT_REGISTRY_ID = 'DEFAULT';
+/**
+ * Default initial value for Delta BehaviorSubject
+ */
+export const defaultDelta = {
+    deltaX: 0,
+    deltaY: 0,
+    targetElement: null
+};
+/**
+ * Default initial value for Size BehaviorSubject
+ */
+export const defaultSize = {
+    width: null,
+    height: null,
+    targetElement: null
+};
+/**
+ * Default initial value for Position BehaviorSubject
+ */
+export const defaultPosition = {
+    x: 0,
+    y: 0,
+    targetElement: null
+};
+//# sourceMappingURL=data:application/json;base64,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