@tft/interact 12.5.2 → 14.0.0

package/esm2020/index.mjs

@@ -0,0 +1,6 @@
+export * from './lib/interact.module';
+export * from './lib/directives';
+export * from './lib/models';
+export * from './lib/pipes';
+export * from './lib/utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsa0JBQWtCLENBQUE7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmFjdC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcydcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9waXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi91dGlscyc7XG4iXX0=

package/esm2020/lib/directives/account-for-scale.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Use to apply scale to the element and tell the drag and resize directives to account for the scale when
+ * @example <div tftAccountForScale [scale]="2.5"> <div tftDraggable> </div> </div>
+ * @note if `dragRoot` is used this directive should be used on the same element to ensure that the drag
+ * element accounts for scale
+ */
+export class AccountForScaleDirective {
+    constructor(el) {
+        this.el = el;
+        // this setup allows consumers to set x, y scale independently or just set them both with scale
+        this.scale = 1;
+    }
+}
+AccountForScaleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: AccountForScaleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AccountForScaleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: AccountForScaleDirective, selector: "[tftAccountForScale]", inputs: { scale: "scale" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: AccountForScaleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftAccountForScale]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scale: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL2RpcmVjdGl2ZXMvYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFlLEtBQUssRUFBNEIsTUFBTSxlQUFlLENBQUM7O0FBRXBHOzs7OztHQUtHO0FBSUgsTUFBTSxPQUFPLHdCQUF3QjtJQUluQyxZQUNTLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBSnZCLCtGQUErRjtRQUN0RixVQUFLLEdBQUcsQ0FBQyxDQUFDO0lBSWYsQ0FBQzs7cUhBTk0sd0JBQXdCO3lHQUF4Qix3QkFBd0I7MkZBQXhCLHdCQUF3QjtrQkFIcEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0JBQXNCO2lCQUNqQztpR0FHVSxLQUFLO3NCQUFiLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RCaW5kaW5nLCBJbnB1dCwgT25DaGFuZ2VzLCBTaW1wbGVDaGFuZ2VzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogVXNlIHRvIGFwcGx5IHNjYWxlIHRvIHRoZSBlbGVtZW50IGFuZCB0ZWxsIHRoZSBkcmFnIGFuZCByZXNpemUgZGlyZWN0aXZlcyB0byBhY2NvdW50IGZvciB0aGUgc2NhbGUgd2hlblxuICogQGV4YW1wbGUgPGRpdiB0ZnRBY2NvdW50Rm9yU2NhbGUgW3NjYWxlXT1cIjIuNVwiPiA8ZGl2IHRmdERyYWdnYWJsZT4gPC9kaXY+IDwvZGl2PlxuICogQG5vdGUgaWYgYGRyYWdSb290YCBpcyB1c2VkIHRoaXMgZGlyZWN0aXZlIHNob3VsZCBiZSB1c2VkIG9uIHRoZSBzYW1lIGVsZW1lbnQgdG8gZW5zdXJlIHRoYXQgdGhlIGRyYWdcbiAqIGVsZW1lbnQgYWNjb3VudHMgZm9yIHNjYWxlXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1t0ZnRBY2NvdW50Rm9yU2NhbGVdJ1xufSlcbmV4cG9ydCBjbGFzcyBBY2NvdW50Rm9yU2NhbGVEaXJlY3RpdmUge1xuICAvLyB0aGlzIHNldHVwIGFsbG93cyBjb25zdW1lcnMgdG8gc2V0IHgsIHkgc2NhbGUgaW5kZXBlbmRlbnRseSBvciBqdXN0IHNldCB0aGVtIGJvdGggd2l0aCBzY2FsZVxuICBASW5wdXQoKSBzY2FsZSA9IDE7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGVsOiBFbGVtZW50UmVmXG4gICkgeyB9XG59XG4iXX0=

package/esm2020/lib/directives/apply-scale.directive.mjs

@@ -0,0 +1,28 @@
+import { Directive, ElementRef, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ApplyScaleDirective {
+    constructor(el) {
+        this.el = el;
+        this._scale = 1;
+    }
+    // this setup allows consumers to set x, y scale independently or just set them both with scale
+    set scale(val) {
+        this._scale;
+        this.fontSize = `${val}px`;
+    }
+    ;
+}
+ApplyScaleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: ApplyScaleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ApplyScaleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: ApplyScaleDirective, selector: "[tftApplyScale]", inputs: { scale: "scale" }, host: { properties: { "style.fontSize": "this.fontSize" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: ApplyScaleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftApplyScale]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scale: [{
+                type: Input
+            }], fontSize: [{
+                type: HostBinding,
+                args: ['style.fontSize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwbHktc2NhbGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL2RpcmVjdGl2ZXMvYXBwbHktc2NhbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzFFLE1BQU0sT0FBTyxtQkFBbUI7SUFXOUIsWUFDUyxFQUFjO1FBQWQsT0FBRSxHQUFGLEVBQUUsQ0FBWTtRQVZ2QixXQUFNLEdBQUcsQ0FBQyxDQUFDO0lBV1AsQ0FBQztJQVZKLCtGQUErRjtJQUNoRyxJQUFhLEtBQUssQ0FBQyxHQUFXO1FBQzVCLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDWixJQUFJLENBQUMsUUFBUSxHQUFHLEdBQUcsR0FBRyxJQUFJLENBQUM7SUFDN0IsQ0FBQztJQUFBLENBQUM7O2dIQVBTLG1CQUFtQjtvR0FBbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGlCQUFpQjtpQkFDNUI7aUdBS2MsS0FBSztzQkFBakIsS0FBSztnQkFLeUIsUUFBUTtzQkFBdEMsV0FBVzt1QkFBQyxnQkFBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RCaW5kaW5nLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbdGZ0QXBwbHlTY2FsZV0nXG59KVxuZXhwb3J0IGNsYXNzIEFwcGx5U2NhbGVEaXJlY3RpdmUge1xuXG4gIF9zY2FsZSA9IDE7XG4gICAvLyB0aGlzIHNldHVwIGFsbG93cyBjb25zdW1lcnMgdG8gc2V0IHgsIHkgc2NhbGUgaW5kZXBlbmRlbnRseSBvciBqdXN0IHNldCB0aGVtIGJvdGggd2l0aCBzY2FsZVxuICBASW5wdXQoKSBzZXQgc2NhbGUodmFsOiBudW1iZXIpe1xuICAgIHRoaXMuX3NjYWxlO1xuICAgIHRoaXMuZm9udFNpemUgPSBgJHt2YWx9cHhgO1xuICB9O1xuXG4gIEBIb3N0QmluZGluZygnc3R5bGUuZm9udFNpemUnKSBmb250U2l6ZTogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBlbDogRWxlbWVudFJlZlxuICApIHsgfVxufVxuIl19

package/esm2020/lib/directives/auto-scroll.directive.mjs

@@ -0,0 +1,56 @@
+import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { scan, shareReplay } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+;
+/**
+ * Use to apply scale to the element and tell the drag and resize directives to account for the scale when
+ * @example <div tftAccountForScale [scale]="2.5"> <div tftDraggable> </div> </div>
+ * @note if `dragRoot` is used this directive should be used on the same element to ensure that the drag
+ * element accounts for scale
+ */
+export class AutoScrollDirective {
+    constructor(el) {
+        this.el = el;
+        /**
+         * Limit minimum time between scroll events in milliseconds
+         */
+        this.autoScrollConfig = {
+            margin: 50,
+            distance: 3,
+            interval: 50,
+            speed: 300,
+            enabled: true
+        };
+        this.scrollDeltaObserver = new Subject();
+        const { scrollTop, scrollLeft } = el.nativeElement;
+        this.scrollSubject = new BehaviorSubject({ scrollTop, scrollLeft });
+        this.scrollObserver = this.scrollSubject.pipe(scan((previous, current) => {
+            const scrollTop = current.scrollTop - previous.scrollTop;
+            const scrollLeft = current.scrollLeft - previous.scrollLeft;
+            this.scrollDeltaObserver.next({ scrollTop, scrollLeft });
+            return current;
+        }), shareReplay(1));
+        this.scrollObserver.subscribe();
+    }
+    // this setup allows consumers to set x, y scale independently or just set them both with scale
+    scroll(scrollEvent) {
+        const target = scrollEvent.target;
+        const { scrollTop, scrollLeft } = target;
+        this.scrollSubject.next({ scrollTop, scrollLeft });
+    }
+}
+AutoScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: AutoScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AutoScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: AutoScrollDirective, selector: "[tftAutoScroll]", inputs: { autoScrollConfig: "autoScrollConfig" }, host: { listeners: { "scroll": "scroll($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: AutoScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftAutoScroll]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { autoScrollConfig: [{
+                type: Input
+            }], scroll: [{
+                type: HostListener,
+                args: ['scroll', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1zY3JvbGwuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL2RpcmVjdGl2ZXMvYXV0by1zY3JvbGwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0UsT0FBTyxFQUFFLGVBQWUsRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDNUQsT0FBTyxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFFVyxDQUFDO0FBQy9EOzs7OztHQUtHO0FBSUgsTUFBTSxPQUFPLG1CQUFtQjtJQXNCOUIsWUFDUyxFQUFjO1FBQWQsT0FBRSxHQUFGLEVBQUUsQ0FBWTtRQXRCdkI7O1dBRUc7UUFDTSxxQkFBZ0IsR0FBRztZQUMxQixNQUFNLEVBQUUsRUFBRTtZQUNWLFFBQVEsRUFBRSxDQUFDO1lBQ1gsUUFBUSxFQUFFLEVBQUU7WUFDWixLQUFLLEVBQUUsR0FBRztZQUNWLE9BQU8sRUFBRSxJQUFJO1NBQ2QsQ0FBQztRQUdPLHdCQUFtQixHQUFHLElBQUksT0FBTyxFQUFnQixDQUFDO1FBWXpELE1BQU0sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEdBQUksRUFBRSxDQUFDLGFBQTZCLENBQUM7UUFDcEUsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLGVBQWUsQ0FBQyxFQUFDLFNBQVMsRUFBRSxVQUFVLEVBQUMsQ0FBQyxDQUFDO1FBQ2xFLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQzNDLElBQUksQ0FBQyxDQUFDLFFBQVEsRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUN6QixNQUFNLFNBQVMsR0FBRyxPQUFPLENBQUMsU0FBUyxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUM7WUFDekQsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLFVBQVUsR0FBRyxRQUFRLENBQUMsVUFBVSxDQUFDO1lBQzVELElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsRUFBQyxTQUFTLEVBQUUsVUFBVSxFQUFDLENBQUMsQ0FBQztZQUN2RCxPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDLENBQUMsRUFDRixXQUFXLENBQUMsQ0FBQyxDQUFDLENBQ2YsQ0FBQTtRQUNELElBQUksQ0FBQyxjQUFjLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDbEMsQ0FBQztJQXZCRCwrRkFBK0Y7SUFDM0QsTUFBTSxDQUFDLFdBQWtCO1FBQzNELE1BQU0sTUFBTSxHQUFJLFdBQVcsQ0FBQyxNQUFzQixDQUFDO1FBQ25ELE1BQU0sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEdBQUcsTUFBTSxDQUFDO1FBQ3pDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEVBQUMsU0FBUyxFQUFFLFVBQVUsRUFBQyxDQUFDLENBQUE7SUFDbEQsQ0FBQzs7Z0hBbkJVLG1CQUFtQjtvR0FBbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGlCQUFpQjtpQkFDNUI7aUdBS1UsZ0JBQWdCO3NCQUF4QixLQUFLO2dCQVc4QixNQUFNO3NCQUF6QyxZQUFZO3VCQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSG9zdExpc3RlbmVyLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0LCBPYnNlcnZhYmxlLCBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBzY2FuLCBzaGFyZVJlcGxheSB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcblxuaW50ZXJmYWNlIFNjcm9sbE9iamVjdCB7c2Nyb2xsVG9wOiBudW1iZXIsIHNjcm9sbExlZnQ6IG51bWJlcn07XG4vKipcbiAqIFVzZSB0byBhcHBseSBzY2FsZSB0byB0aGUgZWxlbWVudCBhbmQgdGVsbCB0aGUgZHJhZyBhbmQgcmVzaXplIGRpcmVjdGl2ZXMgdG8gYWNjb3VudCBmb3IgdGhlIHNjYWxlIHdoZW5cbiAqIEBleGFtcGxlIDxkaXYgdGZ0QWNjb3VudEZvclNjYWxlIFtzY2FsZV09XCIyLjVcIj4gPGRpdiB0ZnREcmFnZ2FibGU+IDwvZGl2PiA8L2Rpdj5cbiAqIEBub3RlIGlmIGBkcmFnUm9vdGAgaXMgdXNlZCB0aGlzIGRpcmVjdGl2ZSBzaG91bGQgYmUgdXNlZCBvbiB0aGUgc2FtZSBlbGVtZW50IHRvIGVuc3VyZSB0aGF0IHRoZSBkcmFnXG4gKiBlbGVtZW50IGFjY291bnRzIGZvciBzY2FsZVxuICovXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbdGZ0QXV0b1Njcm9sbF0nXG59KVxuZXhwb3J0IGNsYXNzIEF1dG9TY3JvbGxEaXJlY3RpdmUge1xuICAvKipcbiAgICogTGltaXQgbWluaW11bSB0aW1lIGJldHdlZW4gc2Nyb2xsIGV2ZW50cyBpbiBtaWxsaXNlY29uZHNcbiAgICovXG4gIEBJbnB1dCgpIGF1dG9TY3JvbGxDb25maWcgPSB7XG4gICAgbWFyZ2luOiA1MCxcbiAgICBkaXN0YW5jZTogMyxcbiAgICBpbnRlcnZhbDogNTAsXG4gICAgc3BlZWQ6IDMwMCxcbiAgICBlbmFibGVkOiB0cnVlXG4gIH07XG4gIHByaXZhdGUgc2Nyb2xsU3ViamVjdDogQmVoYXZpb3JTdWJqZWN0PFNjcm9sbE9iamVjdD47XG4gIHJlYWRvbmx5IHNjcm9sbE9ic2VydmVyOiBPYnNlcnZhYmxlPFNjcm9sbE9iamVjdD47XG4gIHJlYWRvbmx5IHNjcm9sbERlbHRhT2JzZXJ2ZXIgPSBuZXcgU3ViamVjdDxTY3JvbGxPYmplY3Q+KCk7XG4gIC8vIHRoaXMgc2V0dXAgYWxsb3dzIGNvbnN1bWVycyB0byBzZXQgeCwgeSBzY2FsZSBpbmRlcGVuZGVudGx5IG9yIGp1c3Qgc2V0IHRoZW0gYm90aCB3aXRoIHNjYWxlXG4gIEBIb3N0TGlzdGVuZXIoJ3Njcm9sbCcsIFsnJGV2ZW50J10pIHNjcm9sbChzY3JvbGxFdmVudDogRXZlbnQpIHtcbiAgICBjb25zdCB0YXJnZXQgPSAoc2Nyb2xsRXZlbnQudGFyZ2V0IGFzIEhUTUxFbGVtZW50KTtcbiAgICBjb25zdCB7IHNjcm9sbFRvcCwgc2Nyb2xsTGVmdCB9ID0gdGFyZ2V0O1xuICAgIHRoaXMuc2Nyb2xsU3ViamVjdC5uZXh0KHtzY3JvbGxUb3AsIHNjcm9sbExlZnR9KVxuICB9XG5cblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgZWw6IEVsZW1lbnRSZWZcbiAgKSB7XG4gICAgY29uc3QgeyBzY3JvbGxUb3AsIHNjcm9sbExlZnQgfSA9IChlbC5uYXRpdmVFbGVtZW50IGFzIEhUTUxFbGVtZW50KTtcbiAgICB0aGlzLnNjcm9sbFN1YmplY3QgPSBuZXcgQmVoYXZpb3JTdWJqZWN0KHtzY3JvbGxUb3AsIHNjcm9sbExlZnR9KTtcbiAgICB0aGlzLnNjcm9sbE9ic2VydmVyID0gdGhpcy5zY3JvbGxTdWJqZWN0LnBpcGUoXG4gICAgICBzY2FuKChwcmV2aW91cywgY3VycmVudCkgPT4ge1xuICAgICAgICBjb25zdCBzY3JvbGxUb3AgPSBjdXJyZW50LnNjcm9sbFRvcCAtIHByZXZpb3VzLnNjcm9sbFRvcDtcbiAgICAgICAgY29uc3Qgc2Nyb2xsTGVmdCA9IGN1cnJlbnQuc2Nyb2xsTGVmdCAtIHByZXZpb3VzLnNjcm9sbExlZnQ7XG4gICAgICAgIHRoaXMuc2Nyb2xsRGVsdGFPYnNlcnZlci5uZXh0KHtzY3JvbGxUb3AsIHNjcm9sbExlZnR9KTtcbiAgICAgICAgcmV0dXJuIGN1cnJlbnQ7XG4gICAgICB9KSxcbiAgICAgIHNoYXJlUmVwbGF5KDEpLFxuICAgIClcbiAgICB0aGlzLnNjcm9sbE9ic2VydmVyLnN1YnNjcmliZSgpO1xuICB9XG5cbn1cbiJdfQ==

package/esm2020/lib/directives/drag-preview.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, InjectionToken, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export const TFT_DRAG_PREVIEW = new InjectionToken('DragPreviewDirective');
+export class DragPreviewDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+DragPreviewDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DragPreviewDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DragPreviewDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: DragPreviewDirective, selector: "ng-template[tftDragPreview]", inputs: { dragData: "dragData" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DragPreviewDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'ng-template[tftDragPreview]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { dragData: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1wcmV2aWV3LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvaW50ZXJhY3Qvc3JjL2xpYi9kaXJlY3RpdmVzL2RyYWctcHJldmlldy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxjQUFjLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFFNUUsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQXVCLHNCQUFzQixDQUFDLENBQUM7QUFNakcsTUFBTSxPQUFPLG9CQUFvQjtJQUcvQixZQUFtQixXQUEyQjtRQUEzQixnQkFBVyxHQUFYLFdBQVcsQ0FBZ0I7SUFBSSxDQUFDOztpSEFIeEMsb0JBQW9CO3FHQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFKaEMsU0FBUzttQkFBQztvQkFDVCw4REFBOEQ7b0JBQzlELFFBQVEsRUFBRSw2QkFBNkI7aUJBQ3ZDO2tHQUdTLFFBQVE7c0JBQWhCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSW5qZWN0aW9uVG9rZW4sIElucHV0LCBUZW1wbGF0ZVJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBURlRfRFJBR19QUkVWSUVXID0gbmV3IEluamVjdGlvblRva2VuPERyYWdQcmV2aWV3RGlyZWN0aXZlPignRHJhZ1ByZXZpZXdEaXJlY3RpdmUnKTtcblxuQERpcmVjdGl2ZSh7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvZGlyZWN0aXZlLXNlbGVjdG9yXG4gIHNlbGVjdG9yOiAnbmctdGVtcGxhdGVbdGZ0RHJhZ1ByZXZpZXddJyxcbiB9KVxuZXhwb3J0IGNsYXNzIERyYWdQcmV2aWV3RGlyZWN0aXZlPFQgPSBhbnk+IHtcblxuICBASW5wdXQoKSBkcmFnRGF0YTogVDtcbiAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxUPikgeyB9XG59XG4iXX0=

package/esm2020/lib/directives/drag-root.directive.mjs

@@ -0,0 +1,32 @@
+import { AccountForScaleDirective } from './account-for-scale.directive';
+import { Directive, ElementRef, Optional, Self } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./account-for-scale.directive";
+/**
+ * Use this directive to select which element to attach the element to while dragging
+ * @example <div tftDragRoot><div tftDraggable> </div> </div>
+ * @note this directive will overwrite any style transformations (e.g. transform: scale(2); )
+ */
+export class DragRootDirective {
+    constructor(el, 
+    // This is used when passing a dragRoot as in input to a draggable element that not a child of that dragRoot
+    // It allows the the interact service to check if the drag root has some scaling applied to it and account for it when the component is dragged
+    account_for_scale_dir) {
+        this.el = el;
+        this.account_for_scale_dir = account_for_scale_dir;
+    }
+}
+DragRootDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DragRootDirective, deps: [{ token: i0.ElementRef }, { token: i1.AccountForScaleDirective, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+DragRootDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: DragRootDirective, selector: "[tftDragRoot]", exportAs: ["tftDragRoot"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DragRootDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftDragRoot]',
+                    exportAs: 'tftDragRoot'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.AccountForScaleDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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 {
+    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();
+    }
+    // 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;
+    }
+    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);
+        });
+    }
+}
+DraggableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", 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 });
+DraggableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", 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: "14.0.1", 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: function () { return [{ 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"]}