@tft/interact 12.4.0 → 12.5.0

package/fesm2015/tft-interact.js

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Pipe, Injectable, RendererFactory2, NgZone, EventEmitter, Directive, ElementRef, Renderer2, Input, Output, InjectionToken, TemplateRef, HostBinding, Optional, Self, ViewContainerRef, Inject, SkipSelf, ContentChild, NgModule } from '@angular/core';
+import { Pipe, InjectionToken, Injectable, RendererFactory2, NgZone, Optional, Inject, Directive, ElementRef, Input, EventEmitter, Renderer2, Output, TemplateRef, Self, ViewContainerRef, SkipSelf, ContentChild, HostBinding, NgModule } from '@angular/core';
 import { DOCUMENT, CommonModule } from '@angular/common';
 import interact from 'interactjs';
 import { BehaviorSubject, combineLatest } from 'rxjs';
@@ -22,6 +22,7 @@ ArrayOfNPipe.decorators = [
             },] }
 ];
 
+const INTERACT_ROOT_CONFIG = new InjectionToken('INTERACT_ROOT_CONFIG_PARAMS');
 const DEFAULT_REGISTRY_ID = 'DEFAULT';
 /**
  * Default initial value for Delta BehaviorSubject
@@ -49,14 +50,17 @@ const defaultPosition = {
 };
 
 class InteractService {
-    constructor(rendererFactory, ngZone) {
+    constructor(rendererFactory, ngZone, rootConfig) {
         this.rendererFactory = rendererFactory;
         this.ngZone = ngZone;
+        this.rootConfig = rootConfig;
         this._interactableIndex = 0;
         this._dropzoneIndex = 0;
         // TODO: consider using Map here
         this.dragRegistrySystem = {};
+        this.cssUnit = 'px';
         this.renderer = this.rendererFactory.createRenderer(null, null);
+        this.cssUnit = (rootConfig === null || rootConfig === void 0 ? void 0 : rootConfig.cssDimensionUnit) || 'px';
     }
     addDeltaToPosition(delta, position) {
         return {
@@ -164,8 +168,8 @@ class InteractService {
         this.dragRegistrySystem[registryId][interactId].size$.next({ deltaX, deltaY, width, height, targetElement });
     }
     interactableExistOnRegistry(interactId, registryId = DEFAULT_REGISTRY_ID) {
-        return this.dragRegistrySystem.hasOwnProperty(registryId)
-            && this.dragRegistrySystem[registryId].hasOwnProperty(interactId);
+        // eslint-disable-next-line no-prototype-builtins
+        return this.dragRegistrySystem.hasOwnProperty(registryId) && this.dragRegistrySystem[registryId].hasOwnProperty(interactId);
     }
     /**
      * Uses renderer to set width and height of angular component
@@ -179,14 +183,16 @@ class InteractService {
             return;
         const accountForScaleDirective = (_a = target.resizeRef) === null || _a === void 0 ? void 0 : _a.account_for_scale_dir;
         if (accountForScaleDirective) {
-            const { scaleX, scaleY } = accountForScaleDirective;
-            const scaledWidth = width / scaleX;
-            const scaledHeight = height / scaleY;
-            this.renderer.setStyle(target, 'width', `${scaledWidth}px`);
-            this.renderer.setStyle(target, 'height', `${scaledHeight}px`);
+            const { scale } = accountForScaleDirective;
+            const scaledWidth = width / scale;
+            const scaledHeight = height / scale;
+            this.renderer.setStyle(target, 'width', `${scaledWidth}${this.cssUnit}`);
+            this.renderer.setStyle(target, 'height', `${scaledHeight}${this.cssUnit}`);
+        }
+        else {
+            this.renderer.setStyle(target, 'width', `${width}${this.cssUnit}`);
+            this.renderer.setStyle(target, 'height', `${height}${this.cssUnit}`);
         }
-        this.renderer.setStyle(target, 'width', `${width}px`);
-        this.renderer.setStyle(target, 'height', `${height}px`);
     }
     /**
      * Uses renderer to set position of angular component
@@ -195,17 +201,19 @@ class InteractService {
      * @param target the element to transform
      */
     setElementTransform(x, y, position) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         if (!(position === null || position === void 0 ? void 0 : position.targetElement))
             return;
-        if ((_b = (_a = position.targetElement) === null || _a === void 0 ? void 0 : _a.dragRef) === null || _b === void 0 ? void 0 : _b.account_for_scale_dir) {
-            const { scaleX, scaleY } = (_d = (_c = position.targetElement) === null || _c === void 0 ? void 0 : _c.dragRef) === null || _d === void 0 ? void 0 : _d.account_for_scale_dir;
-            this.renderer.setStyle(position.targetElement, 'left', `${x / scaleX}px`);
-            this.renderer.setStyle(position.targetElement, 'top', `${y / scaleY}px`);
+        const dragRef = (_a = position.targetElement) === null || _a === void 0 ? void 0 : _a.dragRef;
+        const accountForScaleDirective = (dragRef === null || dragRef === void 0 ? void 0 : dragRef.account_for_scale_dir) || ((_b = dragRef === null || dragRef === void 0 ? void 0 : dragRef.dragRoot) === null || _b === void 0 ? void 0 : _b.account_for_scale_dir);
+        if (accountForScaleDirective) {
+            const { scale } = accountForScaleDirective;
+            this.renderer.setStyle(position.targetElement, 'left', `${x / scale}${this.cssUnit}`);
+            this.renderer.setStyle(position.targetElement, 'top', `${y / scale}${this.cssUnit}`);
         }
         else {
-            this.renderer.setStyle(position.targetElement, 'left', `${x}px`);
-            this.renderer.setStyle(position.targetElement, 'top', `${y}px`);
+            this.renderer.setStyle(position.targetElement, 'left', `${x}${this.cssUnit}`);
+            this.renderer.setStyle(position.targetElement, 'top', `${y}${this.cssUnit}`);
         }
     }
     /**
@@ -215,32 +223,65 @@ class InteractService {
      * @param y the position along the y axis
      */
     createTransformString(x, y) {
-        return `translate3d(${x}px, ${y}px, 0)`;
+        return `translate3d(${x}${this.cssUnit}, ${y}${this.cssUnit}, 0)`;
     }
-    calculatePositionInElement(zoneElement, dragElement) {
+    calculatePositionInElement(zoneElement, dragElement, scale) {
         // TODO: this calculation may not cover a lot of scenarios, keep an eye out for possible improvements
         const zoneRect = zoneElement.getBoundingClientRect();
         const dragRect = dragElement.getBoundingClientRect();
-        return {
+        const position = scale
+            ? {
+                x: (dragRect.left - zoneRect.left) / scale || 1,
+                y: (dragRect.top - zoneRect.top) / scale || 1
+            } : {
             x: dragRect.left - zoneRect.left,
             y: dragRect.top - zoneRect.top
         };
+        // console.log({ y:position.y, drt:dragRect.top, zrt: zoneRect.top})
+        return position;
     }
 }
-InteractService.ɵprov = i0.ɵɵdefineInjectable({ factory: function InteractService_Factory() { return new InteractService(i0.ɵɵinject(i0.RendererFactory2), i0.ɵɵinject(i0.NgZone)); }, token: InteractService, providedIn: "root" });
+InteractService.ɵprov = i0.ɵɵdefineInjectable({ factory: function InteractService_Factory() { return new InteractService(i0.ɵɵinject(i0.RendererFactory2), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(INTERACT_ROOT_CONFIG, 8)); }, token: InteractService, providedIn: "root" });
 InteractService.decorators = [
     { type: Injectable, args: [{ providedIn: 'root' },] }
 ];
 InteractService.ctorParameters = () => [
     { type: RendererFactory2 },
-    { type: NgZone }
+    { type: NgZone },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INTERACT_ROOT_CONFIG,] }] }
 ];
 
+/**
+ * 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
+ */
+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.decorators = [
+    { type: Directive, args: [{
+                selector: '[tftAccountForScale]'
+            },] }
+];
+AccountForScaleDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+AccountForScaleDirective.propDecorators = {
+    scale: [{ type: Input }]
+};
+
 class DropzoneDirective {
-    constructor(el, renderer, interactService) {
+    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 = {};
         // proxies to pass interact events through to consumer of directive
         this.dropActivate = new EventEmitter();
@@ -290,11 +331,12 @@ class DropzoneDirective {
      * @param event the drop event emitted by interact, extended with extra fields we added to
      */
     mapDropzoneEvent(event) {
-        var _a, _b;
+        var _a, _b, _c;
         const zoneElement = event.target;
         const dragElement = (_b = (_a = event.relatedTarget) === null || _a === void 0 ? void 0 : _a.dragRef) === null || _b === void 0 ? void 0 : _b.previewRef;
+        const scale = ((_c = this.account_for_scale_dir) === null || _c === void 0 ? void 0 : _c.scale) || null;
         const positionInDropTarget = zoneElement && dragElement
-            ? this.interactService.calculatePositionInElement(zoneElement, dragElement)
+            ? this.interactService.calculatePositionInElement(zoneElement, dragElement, scale)
             : null;
         return {
             interactEvent: event,
@@ -316,7 +358,8 @@ DropzoneDirective.decorators = [
 DropzoneDirective.ctorParameters = () => [
     { type: ElementRef },
     { type: Renderer2 },
-    { type: InteractService }
+    { type: InteractService },
+    { type: AccountForScaleDirective, decorators: [{ type: Optional }] }
 ];
 DropzoneDirective.propDecorators = {
     dropzoneId: [{ type: Input }],
@@ -382,65 +425,24 @@ function getRootNode(viewRef, _document) {
     return wrapper;
 }
 
-/**
- * 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
- */
-class AccountForScaleDirective {
-    constructor(el) {
-        this.el = el;
-        this.scaleX = 1;
-        this.scaleY = 1;
-    }
-    // this setup allows consumers to set x, y scale independently or just set them both with scale
-    set scale(val) {
-        this.scaleY = val;
-        this.scaleX = val;
-    }
-    ;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    ngOnChanges(_changes) {
-        this.transform = `scaleX(${this.scaleX}) scaleY(${this.scaleY})`;
-    }
-}
-AccountForScaleDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[tftAccountForScale]'
-            },] }
-];
-AccountForScaleDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-AccountForScaleDirective.propDecorators = {
-    scale: [{ type: Input }],
-    scaleX: [{ type: Input }],
-    scaleY: [{ type: Input }],
-    transform: [{ type: HostBinding, args: ['style.transform',] }]
-};
-
 /**
  * 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); )
  */
 class DragRootDirective {
-    constructor(el, account_for_scale_dir) {
+    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 accounts for a bug where drag element is misaligned when using a drag root
-        // with a dropzone inside of it and a drag item inside the dropzone
-        // e.g <div tftDragRoot> <div tftDropzone> <div tftDraggable</div> </div> </div>
-        // TODO: This is a band-aid, root cause in misunderstood, it started after switching from
-        // using `translate3d` to top/left for positioning
-        if (!account_for_scale_dir) {
-            el.nativeElement.style.transform = 'scale(1)';
-        }
+        this.account_for_scale_dir = account_for_scale_dir;
     }
 }
 DragRootDirective.decorators = [
     { type: Directive, args: [{
-                selector: '[tftDragRoot]'
+                selector: '[tftDragRoot]',
+                exportAs: 'tftDragRoot'
             },] }
 ];
 DragRootDirective.ctorParameters = () => [
@@ -453,7 +455,6 @@ DragRootDirective.ctorParameters = () => [
 class DraggableDirective {
     // cache holding element to use as placeholder while dragging
     constructor(el, interactService, renderer, _viewContainerRef, _document, account_for_scale_dir, dropzone_dir, drag_root_dir) {
-        var _a;
         this.el = el;
         this.interactService = interactService;
         this.renderer = renderer;
@@ -476,14 +477,14 @@ class DraggableDirective {
         this.dragMove = new EventEmitter();
         this.dragInertiaStart = new EventEmitter();
         this.dragEnd = new EventEmitter();
-        this.dragRoot = ((_a = drag_root_dir === null || drag_root_dir === void 0 ? void 0 : drag_root_dir.el) === null || _a === void 0 ? void 0 : _a.nativeElement) || this._document.body;
     }
     ngOnInit() {
-        var _a;
+        var _a, _b, _c, _d, _e;
         this.interactable = this.initiateDragEvents(this.dragConfig, this.el.nativeElement);
+        this.dragRootEl = (((_b = (_a = this.dragRoot) === null || _a === void 0 ? void 0 : _a.el) === null || _b === void 0 ? void 0 : _b.nativeElement) || ((_d = (_c = this.drag_root_dir) === null || _c === void 0 ? void 0 : _c.el) === null || _d === void 0 ? void 0 : _d.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 = ((_a = this.dropzone_dir) === null || _a === void 0 ? void 0 : _a.dropzoneId) || DEFAULT_REGISTRY_ID;
+        this.registryId = ((_e = this.dropzone_dir) === null || _e === void 0 ? void 0 : _e.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);
@@ -539,7 +540,7 @@ class DraggableDirective {
     setDragStyles(dragElement) {
         this.renderer.setStyle(dragElement, 'touchAction', 'none');
         this.renderer.setStyle(dragElement, 'zIndex', this.dragZIndex);
-        this.renderer.setStyle(dragElement, 'position', 'fixed');
+        this.renderer.setStyle(dragElement, 'position', 'absolute');
     }
     addDragPropertiesToElement(nativeElement) {
         this.renderer.setProperty(nativeElement, 'dropTarget', this.dropzone_dir || null);
@@ -584,8 +585,9 @@ class DraggableDirective {
             const interaction = event.interaction;
             // check if we should append drag element to body
             if (this.enableDragDefault
-                && !!this.dropzone_dir
                 && interaction.pointerIsDown
+            // TODO: probably don't need following condition checks anymore remove by 2022
+            // && !!this.dropzone_dir
             // && !interaction.interacting()
             ) {
                 if (this._previewTemplate) {
@@ -597,8 +599,8 @@ class DraggableDirective {
                 }
                 this.addDragPropertiesToElement(this.previewRef);
                 this.setDragStyles(this.previewRef);
-                this.dragRoot.prepend(this.previewRef);
-                const { x, y } = this.interactService.calculatePositionInElement(this.dragRoot, nativeElement);
+                this.dragRootEl.prepend(this.previewRef);
+                const { x, y } = this.interactService.calculatePositionInElement(this.dragRootEl, nativeElement);
                 this.interactService.updatePosition(this.interactableId, this.registryId, { x, y }, this.previewRef);
                 if (!this.showPlaceholder) {
                     this.renderer.setStyle(this.el.nativeElement, 'display', 'none');
@@ -626,10 +628,9 @@ class DraggableDirective {
             this.renderer.setStyle(this.el.nativeElement, 'display', '');
             this.dragEnd.emit(mappedEvent);
             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
+                // we do this in a timeout, so that we don't remove before the dropzone can get the boundingElementRect
                 setTimeout(() => {
-                    this.dragRoot.removeChild(this.previewRef);
+                    this.dragRootEl.removeChild(this.previewRef);
                 });
             }
         });
@@ -652,7 +653,7 @@ DraggableDirective.ctorParameters = () => [
     { type: Renderer2 },
     { type: ViewContainerRef },
     { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: AccountForScaleDirective, decorators: [{ type: Optional }, { type: SkipSelf }] },
+    { type: AccountForScaleDirective, decorators: [{ type: Optional }] },
     { type: DropzoneDirective, decorators: [{ type: Optional }, { type: SkipSelf }] },
     { type: DragRootDirective, decorators: [{ type: Optional }, { type: SkipSelf }] }
 ];
@@ -668,6 +669,7 @@ DraggableDirective.propDecorators = {
     dragDisabled: [{ type: Input }],
     dragConfig: [{ type: Input }],
     showPlaceholder: [{ type: Input }],
+    dragRoot: [{ type: Input }],
     dragStart: [{ type: Output }],
     dragMove: [{ type: Output }],
     dragInertiaStart: [{ type: Output }],
@@ -774,7 +776,7 @@ class ResizableDirective {
     }
     mapResizeEvent(event) {
         var _a, _b;
-        const { target } = event;
+        const target = event.target;
         const relatedTarget = (_b = (_a = this.draggable_dir) === null || _a === void 0 ? void 0 : _a.dropzone_dir) === null || _b === void 0 ? void 0 : _b.el.nativeElement;
         const positionInDropTarget = target && relatedTarget
             ? this.interactService.calculatePositionInElement(relatedTarget, target)
@@ -910,6 +912,31 @@ GesturableDirective.propDecorators = {
     gestureEnd: [{ type: Output }]
 };
 
+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.decorators = [
+    { type: Directive, args: [{
+                selector: '[tftApplyScale]'
+            },] }
+];
+ApplyScaleDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+ApplyScaleDirective.propDecorators = {
+    scale: [{ type: Input }],
+    fontSize: [{ type: HostBinding, args: ['style.fontSize',] }]
+};
+
 const EXPORTS = [
     DraggableDirective,
     ResizableDirective,
@@ -917,14 +944,26 @@ const EXPORTS = [
     GesturableDirective,
     DragRootDirective,
     AccountForScaleDirective,
+    ApplyScaleDirective,
     DragPreviewDirective,
     ArrayOfNPipe,
 ];
 class InteractModule {
+    static forRoot(config) {
+        const defaultConfig = { cssDimensionUnit: 'px' };
+        return {
+            ngModule: InteractModule,
+            providers: [
+                { provide: INTERACT_ROOT_CONFIG, useValue: Object.assign(Object.assign({}, defaultConfig), config) },
+                InteractService
+            ]
+        };
+    }
 }
 InteractModule.decorators = [
     { type: NgModule, args: [{
                 imports: [CommonModule],
+                // providers: [{ provide: INTERACT_ROOT_CONFIG, useValue: 'px' }],
                 declarations: [
                     ...EXPORTS,
                 ],
@@ -938,5 +977,5 @@ InteractModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { AccountForScaleDirective, ArrayOfNPipe, DEFAULT_REGISTRY_ID, DragPreviewDirective, DragRootDirective, DraggableDirective, DropzoneDirective, GesturableDirective, InteractModule, ResizableDirective, TFT_DRAG_PREVIEW, cloneElement$1 as cloneElement, defaultDelta, defaultPosition, defaultSize, getClosestMatchingAncestor, getRootNode, DraggableDirective as ɵa, ResizableDirective as ɵb, DropzoneDirective as ɵc, GesturableDirective as ɵd, DragRootDirective as ɵe, AccountForScaleDirective as ɵf, DragPreviewDirective as ɵg, ArrayOfNPipe as ɵh };
+export { AccountForScaleDirective, ApplyScaleDirective, ArrayOfNPipe, DEFAULT_REGISTRY_ID, DragPreviewDirective, DragRootDirective, DraggableDirective, DropzoneDirective, GesturableDirective, INTERACT_ROOT_CONFIG, InteractModule, ResizableDirective, TFT_DRAG_PREVIEW, cloneElement$1 as cloneElement, defaultDelta, defaultPosition, defaultSize, getClosestMatchingAncestor, getRootNode, DraggableDirective as ɵa, ResizableDirective as ɵb, DropzoneDirective as ɵc, GesturableDirective as ɵd, DragRootDirective as ɵe, AccountForScaleDirective as ɵf, ApplyScaleDirective as ɵg, DragPreviewDirective as ɵh, ArrayOfNPipe as ɵi };
 //# sourceMappingURL=tft-interact.js.map