@tft/interact 17.0.0 → 21.0.0

package/types/tft-interact.d.ts

@@ -0,0 +1,506 @@
+import * as i0 from '@angular/core';
+import { RendererFactory2, NgZone, ElementRef, OnInit, OnChanges, EventEmitter, Renderer2, SimpleChanges, TemplateRef, InjectionToken, OnDestroy, AfterViewInit, ViewContainerRef, PipeTransform, ModuleWithProviders, EmbeddedViewRef } from '@angular/core';
+import * as _interactjs_core_Interactable from '@interactjs/core/Interactable';
+import * as _tft_interact from '@tft/interact';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { DropzoneOptions, Interactable, DraggableOptions, ResizableOptions, ResizeEvent, GesturableOptions } from '@interactjs/types/index';
+import { Point, DropEvent, Interactable as Interactable$1, ResizeEvent as ResizeEvent$1, DragEvent, GestureEvent } from '@interactjs/types';
+import * as i11 from '@angular/common';
+
+declare class InteractService {
+    private rendererFactory;
+    private ngZone;
+    rootConfig: any;
+    private _interactableIndex;
+    private _dropzoneIndex;
+    private renderer;
+    readonly dragRegistrySystem: {
+        [key: string]: InteractableRegistry;
+    };
+    private cssUnit;
+    constructor(rendererFactory: RendererFactory2, ngZone: NgZone, rootConfig: any);
+    addDeltaToPosition(delta: Delta, position: Position): {
+        x: number;
+        y: number;
+        targetElement: TftDragElement;
+    };
+    addRegistryToSystem(customRegistryId?: string | null): string;
+    addDraggableToRegistry(customRegistryId?: any, interactableId?: string | null): string;
+    destroyInteractable(interactableId: string, registryId?: string): void;
+    subscribeToInteractable(interactableId: string, registryId?: string): _tft_interact.InteractableSystem;
+    createInteractableState(initialPosition: Position, initialSize: Size, initialDelta: Delta): {
+        deltas$: BehaviorSubject<Delta>;
+        position$: BehaviorSubject<Position>;
+        size$: BehaviorSubject<{
+            deltaX: number | null;
+            deltaY: number | null;
+            targetElement: TftDragElement | null;
+            width: number | null;
+            height: number | null;
+        }>;
+        interactable$: Observable<TftCoords>;
+    };
+    createInteractableId(customInteractableId?: string | null): string;
+    createDropzoneId(index: number): string;
+    getInteractableState(interactableId: string, registryId?: string): Observable<TftCoords>;
+    updateDeltas(interactId: string, registryId: string, { deltaX, deltaY }: {
+        deltaX: any;
+        deltaY: any;
+    }, targetElement: any): void;
+    updatePosition(interactId: string, registryId: string, { x, y }: {
+        x: number;
+        y: number;
+    }, targetElement: any): void;
+    updateSize(interactId: string, registryId: string, { deltaX, deltaY, width, height }: {
+        deltaX: any;
+        deltaY: any;
+        width: any;
+        height: any;
+    }, targetElement: any): void;
+    interactableExistOnRegistry(interactId: string, registryId?: string): boolean;
+    /**
+     * Uses renderer to set width and height of angular component
+     * @param width the desired width of component
+     * @param height the desired height of component
+     * @param target the element to transform
+     */
+    setElementSize(width: number, height: number, target: TftResizeElement): void;
+    /**
+     * Uses renderer to set position of angular component
+     * @param x position on x axis
+     * @param y position on y axis
+     * @param target the element to transform
+     */
+    setElementTransform(x: number, y: number, position: Position): void;
+    /**
+     * Generates a translate string for the x and y arguments passed to
+     * be passed to css transform
+     * @param x the position along the x axis
+     * @param y the position along the y axis
+     */
+    createTransformString(x: number, y: number): string;
+    calculatePositionInElement(zoneElement: Interact.Element, dragElement: TftDragElement, scale?: number): {
+        x: number;
+        y: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractService>;
+}
+
+/**
+ * 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
+ */
+declare class AccountForScaleDirective {
+    el: ElementRef;
+    scale: number;
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountForScaleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccountForScaleDirective, "[tftAccountForScale]", never, { "scale": { "alias": "scale"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+type PositionOption = 'relative' | 'absolute' | 'fixed' | 'static' | 'sticky' | 'unset' | 'inherit' | 'initial' | 'revert';
+declare class DropzoneDirective implements OnInit, OnChanges {
+    el: ElementRef;
+    private renderer;
+    private interactService;
+    private account_for_scale_dir?;
+    dropzoneId: string;
+    dropzoneConfig: DropzoneOptions;
+    dropzoneData: any;
+    position: PositionOption;
+    dropActivate: EventEmitter<TftDropEvent>;
+    dragEnter: EventEmitter<TftDropEvent>;
+    dragLeave: EventEmitter<TftDropEvent>;
+    dragDrop: EventEmitter<TftDropEvent>;
+    dropzone: Interactable;
+    get scale(): number;
+    constructor(el: ElementRef, renderer: Renderer2, interactService: InteractService, account_for_scale_dir?: AccountForScaleDirective);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+    * 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: any, dropzoneConfig: DropzoneOptions): _interactjs_core_Interactable.Interactable;
+    /**
+     * 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: NgDropEvent): TftDropEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropzoneDirective, "[tftDropzone]", never, { "dropzoneId": { "alias": "dropzoneId"; "required": false; }; "dropzoneConfig": { "alias": "dropzoneConfig"; "required": false; }; "dropzoneData": { "alias": "dropzoneData"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "dropActivate": "dropActivate"; "dragEnter": "dragEnter"; "dragLeave": "dragLeave"; "dragDrop": "dragDrop"; }, never, never, false, never>;
+}
+
+declare const TFT_DRAG_PREVIEW: InjectionToken<DragPreviewDirective<any>>;
+declare class DragPreviewDirective<T = any> {
+    templateRef: TemplateRef<T>;
+    dragData: T;
+    constructor(templateRef: TemplateRef<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragPreviewDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragPreviewDirective<any>, "ng-template[tftDragPreview]", never, { "dragData": { "alias": "dragData"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * 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); )
+ */
+declare class DragRootDirective {
+    el: ElementRef;
+    account_for_scale_dir?: AccountForScaleDirective;
+    constructor(el: ElementRef, account_for_scale_dir?: AccountForScaleDirective);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragRootDirective, [null, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragRootDirective, "[tftDragRoot]", ["tftDragRoot"], {}, {}, never, never, false, never>;
+}
+
+interface ScrollObject {
+    scrollTop: number;
+    scrollLeft: number;
+}
+/**
+ * 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
+ */
+declare class AutoScrollDirective {
+    el: ElementRef;
+    /**
+     * Limit minimum time between scroll events in milliseconds
+     */
+    autoScrollConfig: {
+        margin: number;
+        distance: number;
+        interval: number;
+        speed: number;
+        enabled: boolean;
+    };
+    private scrollSubject;
+    readonly scrollObserver: Observable<ScrollObject>;
+    readonly scrollDeltaObserver: Subject<ScrollObject>;
+    scroll(scrollEvent: Event): void;
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoScrollDirective, "[tftAutoScroll]", never, { "autoScrollConfig": { "alias": "autoScrollConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** @dynamic */
+declare class DraggableDirective<D = any> implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    el: ElementRef;
+    private interactService;
+    private renderer;
+    private _viewContainerRef;
+    private _document;
+    account_for_scale_dir?: AccountForScaleDirective;
+    dropzone_dir?: DropzoneDirective;
+    drag_root_dir?: DragRootDirective;
+    auto_scroll_dir?: AutoScrollDirective;
+    x: number;
+    y: number;
+    dragZIndex: number;
+    /** zIndex while at rest */
+    zIndex: number;
+    interactableId: string;
+    dragData: D;
+    enableDragDefault: boolean;
+    /**
+     * @deprecated replaced by 'dragDisabled' property, please migrate before v13
+     */
+    disabled: boolean;
+    dragDisabled: boolean;
+    dragConfig: Partial<Interact.OrBoolean<DraggableOptions>>;
+    showPlaceholder: boolean;
+    /**
+     * The element we want to prepend the drag element to.
+     * Use `tftDragRoot` directive on a parent element to set custom root element
+     *  @default document.body
+     */
+    dragRoot: DragRootDirective;
+    private dragRootEl;
+    dragStart: EventEmitter<TftDragEvent>;
+    dragMove: EventEmitter<TftDragEvent>;
+    dragInertiaStart: EventEmitter<TftDragEvent>;
+    dragEnd: EventEmitter<TftDragEvent>;
+    _previewTemplate: DragPreviewDirective;
+    interactableState: Observable<TftCoords>;
+    interactable: Interactable;
+    private registryId;
+    private interactableSubscription;
+    private scrollEventsSubscription;
+    previewRef: TftDragElement;
+    get scale(): number;
+    constructor(el: ElementRef, interactService: InteractService, renderer: Renderer2, _viewContainerRef: ViewContainerRef, _document: Document, account_for_scale_dir?: AccountForScaleDirective, dropzone_dir?: DropzoneDirective, drag_root_dir?: DragRootDirective, auto_scroll_dir?: AutoScrollDirective);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setDragConfig(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    dragMoveListener(event: NgDragEvent, element: Interact.Element): void;
+    setDragStyles(dragElement: HTMLElement): void;
+    addDragPropertiesToElement(nativeElement: TftDragElement): void;
+    mapDragEvent(event: NgDragEvent): TftDragEvent;
+    setPosition(x: number, y: number): void;
+    alignPositionWithInputs(x: number, y: number): void;
+    isValidPosition(x: number, y: number): boolean;
+    isNumeric(num: number): boolean;
+    initiateDragEvents(dragConfig: Partial<Interact.OrBoolean<DraggableOptions>>, nativeElement: HTMLElement): _interactjs_core_Interactable.Interactable;
+    subscribeToScrollEvents(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective<any>, [null, null, null, null, null, { optional: true; }, { optional: true; skipSelf: true; }, { optional: true; skipSelf: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective<any>, "[tftDraggable]", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "dragZIndex": { "alias": "dragZIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "interactableId": { "alias": "interactableId"; "required": false; }; "dragData": { "alias": "dragData"; "required": false; }; "enableDragDefault": { "alias": "enableDragDefault"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; }; "dragConfig": { "alias": "dragConfig"; "required": false; }; "showPlaceholder": { "alias": "showPlaceholder"; "required": false; }; "dragRoot": { "alias": "dragRoot"; "required": false; }; }, { "dragStart": "dragStart"; "dragMove": "dragMove"; "dragInertiaStart": "dragInertiaStart"; "dragEnd": "dragEnd"; }, ["_previewTemplate"], never, false, never>;
+}
+
+/** @dynamic */
+declare class ResizableDirective implements OnInit, OnDestroy, OnChanges {
+    el: ElementRef;
+    private _document;
+    private interactService;
+    private renderer;
+    private drag_root_dir?;
+    account_for_scale_dir?: AccountForScaleDirective;
+    private draggable_dir?;
+    private dropzone_dir?;
+    auto_scroll_dir?: AutoScrollDirective;
+    enableResizeDefault: boolean;
+    position: string;
+    resizeConfig: Partial<Interact.OrBoolean<ResizableOptions>>;
+    interactableId: string;
+    width: number;
+    height: number;
+    resizeDisabled: boolean;
+    resizeStart: EventEmitter<TftResizeEvent>;
+    resizeMove: EventEmitter<TftResizeEvent>;
+    resizeInertiaStart: EventEmitter<TftResizeEvent>;
+    resizeEnd: EventEmitter<TftResizeEvent>;
+    defaultConfig: Partial<Interact.OrBoolean<ResizableOptions>>;
+    registryId: string;
+    interactable: Interactable;
+    dragRootEl: HTMLElement;
+    private activeEdges;
+    private interactableSubscription;
+    private scrollEventsSubscription;
+    get scale(): number;
+    constructor(el: ElementRef, _document: Document, interactService: InteractService, renderer: Renderer2, drag_root_dir?: DragRootDirective, account_for_scale_dir?: AccountForScaleDirective, draggable_dir?: DraggableDirective, dropzone_dir?: DropzoneDirective, auto_scroll_dir?: AutoScrollDirective);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    resizeListener(event: ResizeEvent): void;
+    /**
+     *  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: Partial<Interact.OrBoolean<ResizableOptions>>, nativeElement: TftDragElement): _interactjs_core_Interactable.Interactable;
+    mapResizeEvent(event: NgResizeEvent): TftResizeEvent;
+    alignDimensionsWithInputs(width: number, height: number): void;
+    addResizePropertiesToElement(nativeElement: TftDragElement): void;
+    subscribeToScrollEvents(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDirective, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; skipSelf: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDirective, "[tftResizable]", never, { "enableResizeDefault": { "alias": "enableResizeDefault"; "required": false; }; "position": { "alias": "position"; "required": false; }; "resizeConfig": { "alias": "resizeConfig"; "required": false; }; "interactableId": { "alias": "interactableId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "resizeDisabled": { "alias": "resizeDisabled"; "required": false; }; }, { "resizeStart": "resizeStart"; "resizeMove": "resizeMove"; "resizeInertiaStart": "resizeInertiaStart"; "resizeEnd": "resizeEnd"; }, never, never, false, never>;
+}
+
+/** @dynamic */
+declare class GesturableDirective<D = any> implements OnInit, OnChanges {
+    el: ElementRef;
+    private draggable_dir?;
+    gesturableId: string;
+    gestureDisabled: boolean;
+    gestureConfig: Partial<Interact.OrBoolean<DraggableOptions>>;
+    gestureStart: EventEmitter<TftGestureEvent>;
+    gestureMove: EventEmitter<TftGestureEvent>;
+    gestureEnd: EventEmitter<TftGestureEvent>;
+    interactableState: Observable<TftCoords>;
+    interactable: Interactable;
+    constructor(el: ElementRef, draggable_dir?: DraggableDirective);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setGestureConfig(): void;
+    initiateGestureEvents(gestureConfig: Partial<Interact.OrBoolean<GesturableOptions>>, nativeElement: HTMLElement): _interactjs_core_Interactable.Interactable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GesturableDirective<any>, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GesturableDirective<any>, "[tftGesturable]", never, { "gesturableId": { "alias": "gesturableId"; "required": false; }; "gestureDisabled": { "alias": "gestureDisabled"; "required": false; }; "gestureConfig": { "alias": "gestureConfig"; "required": false; }; }, { "gestureStart": "gestureStart"; "gestureMove": "gestureMove"; "gestureEnd": "gestureEnd"; }, never, never, false, never>;
+}
+
+declare class ApplyScaleDirective {
+    el: ElementRef;
+    _scale: number;
+    set scale(val: number);
+    fontSize: string;
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyScaleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ApplyScaleDirective, "[tftApplyScale]", never, { "scale": { "alias": "scale"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+type CssDimensionUnit = 'px' | 'em';
+interface InteractRootConfig {
+    cssDimensionUnit: CssDimensionUnit;
+}
+declare const INTERACT_ROOT_CONFIG: InjectionToken<InteractRootConfig>;
+declare const DEFAULT_REGISTRY_ID = "DEFAULT";
+/**
+ * Default initial value for Delta BehaviorSubject
+ */
+declare const defaultDelta: Delta;
+/**
+ * Default initial value for Size BehaviorSubject
+ */
+declare const defaultSize: Size;
+/**
+ * Default initial value for Position BehaviorSubject
+ */
+declare const defaultPosition: Position;
+/**
+ * The shape of the state/events/behavior system for each dropzone
+ * and the DEFAULT_REGISTRY_ID system (for drop components initialized outside
+ * of a dropzone).
+ */
+interface InteractableSystem {
+    deltas$: BehaviorSubject<Delta>;
+    position$: BehaviorSubject<Position>;
+    size$: BehaviorSubject<Size & Delta>;
+    interactable$: Observable<TftCoords>;
+}
+/**
+ * The key map of InteractableSystems. One for the drag components
+ * that originated outside of a dropzone, plus one for each dropzone.
+ */
+interface InteractableRegistry {
+    [key: string]: InteractableSystem;
+}
+/**
+ * HTMLElement with helpful drag directives attached to facilitate moving drag data between dropzones
+ */
+type TftDragElement = HTMLElement & {
+    dragRef?: DraggableDirective;
+    dragOrigin?: DropzoneDirective;
+    dropTarget?: DropzoneDirective;
+};
+/**
+ * HTMLElement with helpful drag directives attached to facilitate moving drag data between dropzones
+ */
+type TftResizeElement = HTMLElement & {
+    resizeRef?: ResizableDirective;
+};
+/**
+ * Extends the interact drop events by adding reference to the dropped components drag
+ * directive to the html element. This gives the dropzone access to things like data
+ * and parent dropzone of the dropped component.
+ */
+type NgDropEvent = DropEvent & {
+    draggable: Interactable$1 & {
+        target: TftDragElement;
+    };
+    relatedTarget: TftDragElement;
+};
+/**
+ * Extends the interact resize events by adding a reference to the dragRef
+ * directive to the html element.
+ */
+type NgResizeEvent = ResizeEvent$1 & {
+    draggable: Interactable$1 & {
+        target: TftDragElement;
+    };
+};
+/**
+ * We extend the interact DragEvent a little here, adding to the target element references for:
+ *  - the component we are dragging (dragRef)
+ *  - the dropzone component where the drag component originated (dragOrigin)
+ *  - the dropzone component that it was dropped in (dropTarget)
+ * This helps us to pass references to directive classes as events like dragenter and drag exit happens.
+ * We use these references to emit a (mostly) consistent event across drag, drop, resize event.
+ */
+type NgDragEvent = DragEvent & {
+    dropzone: {
+        target: HTMLElement;
+    };
+    target: TftDragElement;
+};
+/**
+ * Event emitted when resizing, dragging, dropping
+ */
+interface TftInteractableEvent {
+    dragRef: DraggableDirective;
+    dragOrigin?: DropzoneDirective;
+    dropTarget?: DropzoneDirective;
+    positionInDropTarget: Point;
+}
+/**
+ * Event emitted on drop
+ */
+interface TftDropEvent extends TftInteractableEvent {
+    interactEvent: NgDropEvent;
+}
+/**
+ * Event emitted on drag
+ */
+interface TftDragEvent extends TftInteractableEvent {
+    interactEvent: NgDragEvent;
+}
+/**
+ * Event emitted on resize
+ */
+interface TftResizeEvent extends TftInteractableEvent {
+    interactEvent: ResizeEvent$1;
+    resizeRef: ResizableDirective;
+    size: {
+        width: number;
+        height: number;
+    };
+}
+type TftCoords = Delta & Position & Size;
+interface Delta {
+    deltaX: number | null;
+    deltaY: number | null;
+    targetElement: TftDragElement | null;
+}
+interface Position {
+    x: number | null;
+    y: number | null;
+    targetElement: TftDragElement | null;
+}
+interface Size {
+    width: number | null;
+    height: number | null;
+    targetElement: TftResizeElement | null;
+}
+interface TftGestureEvent {
+    gestureRef: GesturableDirective;
+    interactEvent: GestureEvent;
+}
+
+declare class ArrayOfNPipe implements PipeTransform {
+    /**
+     *
+     * @param n the number to make an array of
+     * @param max the max length of the array (useful for limiting rendering in ngFor loop)
+     */
+    transform(n: number, max: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayOfNPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayOfNPipe, "arrayOfN", false>;
+}
+
+declare class InteractModule {
+    static forRoot(config: InteractRootConfig): ModuleWithProviders<InteractModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InteractModule, [typeof DraggableDirective, typeof ResizableDirective, typeof DropzoneDirective, typeof GesturableDirective, typeof DragRootDirective, typeof AutoScrollDirective, typeof AccountForScaleDirective, typeof ApplyScaleDirective, typeof DragPreviewDirective, typeof ArrayOfNPipe], [typeof i11.CommonModule], [typeof DraggableDirective, typeof ResizableDirective, typeof DropzoneDirective, typeof GesturableDirective, typeof DragRootDirective, typeof AutoScrollDirective, typeof AccountForScaleDirective, typeof ApplyScaleDirective, typeof DragPreviewDirective, typeof ArrayOfNPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InteractModule>;
+}
+
+/** Gets the closest ancestor of an element that matches a selector. */
+declare function getClosestMatchingAncestor(element: HTMLElement, selector: string): HTMLElement;
+/**
+ * Create a copy of the HTML Element
+ */
+declare function cloneElement(element: HTMLElement): HTMLElement;
+/**
+ * Gets the root HTML element of an embedded view.
+ * If the root is not an HTML element it gets wrapped in one.
+ */
+declare function getRootNode(viewRef: EmbeddedViewRef<any>, _document: Document): HTMLElement;
+
+export { AccountForScaleDirective, ApplyScaleDirective, ArrayOfNPipe, AutoScrollDirective, DEFAULT_REGISTRY_ID, DragPreviewDirective, DragRootDirective, DraggableDirective, DropzoneDirective, GesturableDirective, INTERACT_ROOT_CONFIG, InteractModule, ResizableDirective, TFT_DRAG_PREVIEW, cloneElement, defaultDelta, defaultPosition, defaultSize, getClosestMatchingAncestor, getRootNode };
+export type { CssDimensionUnit, Delta, InteractRootConfig, InteractableRegistry, InteractableSystem, NgDragEvent, NgDropEvent, NgResizeEvent, Position, PositionOption, Size, TftCoords, TftDragElement, TftDragEvent, TftDropEvent, TftGestureEvent, TftInteractableEvent, TftResizeElement, TftResizeEvent };

package/esm2022/index.mjs

@@ -1,6 +0,0 @@
-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/esm2022/lib/directives/account-for-scale.directive.mjs

@@ -1,26 +0,0 @@
-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;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AccountForScaleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: AccountForScaleDirective, selector: "[tftAccountForScale]", inputs: { scale: "scale" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AccountForScaleDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[tftAccountForScale]'
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { scale: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL2RpcmVjdGl2ZXMvYWNjb3VudC1mb3Itc2NhbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFlLEtBQUssRUFBNEIsTUFBTSxlQUFlLENBQUM7O0FBRXBHOzs7OztHQUtHO0FBSUgsTUFBTSxPQUFPLHdCQUF3QjtJQUluQyxZQUNTLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBSnZCLCtGQUErRjtRQUN0RixVQUFLLEdBQUcsQ0FBQyxDQUFDO0lBSWYsQ0FBQzs4R0FOTSx3QkFBd0I7a0dBQXhCLHdCQUF3Qjs7MkZBQXhCLHdCQUF3QjtrQkFIcEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0JBQXNCO2lCQUNqQzsrRUFHVSxLQUFLO3NCQUFiLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RCaW5kaW5nLCBJbnB1dCwgT25DaGFuZ2VzLCBTaW1wbGVDaGFuZ2VzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogVXNlIHRvIGFwcGx5IHNjYWxlIHRvIHRoZSBlbGVtZW50IGFuZCB0ZWxsIHRoZSBkcmFnIGFuZCByZXNpemUgZGlyZWN0aXZlcyB0byBhY2NvdW50IGZvciB0aGUgc2NhbGUgd2hlblxuICogQGV4YW1wbGUgPGRpdiB0ZnRBY2NvdW50Rm9yU2NhbGUgW3NjYWxlXT1cIjIuNVwiPiA8ZGl2IHRmdERyYWdnYWJsZT4gPC9kaXY+IDwvZGl2PlxuICogQG5vdGUgaWYgYGRyYWdSb290YCBpcyB1c2VkIHRoaXMgZGlyZWN0aXZlIHNob3VsZCBiZSB1c2VkIG9uIHRoZSBzYW1lIGVsZW1lbnQgdG8gZW5zdXJlIHRoYXQgdGhlIGRyYWdcbiAqIGVsZW1lbnQgYWNjb3VudHMgZm9yIHNjYWxlXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1t0ZnRBY2NvdW50Rm9yU2NhbGVdJ1xufSlcbmV4cG9ydCBjbGFzcyBBY2NvdW50Rm9yU2NhbGVEaXJlY3RpdmUge1xuICAvLyB0aGlzIHNldHVwIGFsbG93cyBjb25zdW1lcnMgdG8gc2V0IHgsIHkgc2NhbGUgaW5kZXBlbmRlbnRseSBvciBqdXN0IHNldCB0aGVtIGJvdGggd2l0aCBzY2FsZVxuICBASW5wdXQoKSBzY2FsZSA9IDE7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGVsOiBFbGVtZW50UmVmXG4gICkgeyB9XG59XG4iXX0=

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

@@ -1,28 +0,0 @@
-import { Directive, ElementRef, HostBinding, Input } from '@angular/core';
-import * as i0 from "@angular/core";
-export class ApplyScaleDirective {
-    // 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`;
-    }
-    ;
-    constructor(el) {
-        this.el = el;
-        this._scale = 1;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ApplyScaleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: ApplyScaleDirective, selector: "[tftApplyScale]", inputs: { scale: "scale" }, host: { properties: { "style.fontSize": "this.fontSize" } }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ApplyScaleDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[tftApplyScale]'
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { scale: [{
-                type: Input
-            }], fontSize: [{
-                type: HostBinding,
-                args: ['style.fontSize']
-            }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwbHktc2NhbGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL2RpcmVjdGl2ZXMvYXBwbHktc2NhbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzFFLE1BQU0sT0FBTyxtQkFBbUI7SUFHN0IsK0ZBQStGO0lBQ2hHLElBQWEsS0FBSyxDQUFDLEdBQVc7UUFDNUIsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNaLElBQUksQ0FBQyxRQUFRLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQztJQUM3QixDQUFDO0lBQUEsQ0FBQztJQUlGLFlBQ1MsRUFBYztRQUFkLE9BQUUsR0FBRixFQUFFLENBQVk7UUFWdkIsV0FBTSxHQUFHLENBQUMsQ0FBQztJQVdQLENBQUM7OEdBYk0sbUJBQW1CO2tHQUFuQixtQkFBbUI7OzJGQUFuQixtQkFBbUI7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGlCQUFpQjtpQkFDNUI7K0VBS2MsS0FBSztzQkFBakIsS0FBSztnQkFLeUIsUUFBUTtzQkFBdEMsV0FBVzt1QkFBQyxnQkFBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RCaW5kaW5nLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbdGZ0QXBwbHlTY2FsZV0nXG59KVxuZXhwb3J0IGNsYXNzIEFwcGx5U2NhbGVEaXJlY3RpdmUge1xuXG4gIF9zY2FsZSA9IDE7XG4gICAvLyB0aGlzIHNldHVwIGFsbG93cyBjb25zdW1lcnMgdG8gc2V0IHgsIHkgc2NhbGUgaW5kZXBlbmRlbnRseSBvciBqdXN0IHNldCB0aGVtIGJvdGggd2l0aCBzY2FsZVxuICBASW5wdXQoKSBzZXQgc2NhbGUodmFsOiBudW1iZXIpe1xuICAgIHRoaXMuX3NjYWxlO1xuICAgIHRoaXMuZm9udFNpemUgPSBgJHt2YWx9cHhgO1xuICB9O1xuXG4gIEBIb3N0QmluZGluZygnc3R5bGUuZm9udFNpemUnKSBmb250U2l6ZTogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBlbDogRWxlbWVudFJlZlxuICApIHsgfVxufVxuIl19

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

@@ -1,56 +0,0 @@
-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 {
-    // 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 });
-    }
-    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();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AutoScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: AutoScrollDirective, selector: "[tftAutoScroll]", inputs: { autoScrollConfig: "autoScrollConfig" }, host: { listeners: { "scroll": "scroll($event)" } }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AutoScrollDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[tftAutoScroll]'
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { autoScrollConfig: [{
-                type: Input
-            }], scroll: [{
-                type: HostListener,
-                args: ['scroll', ['$event']]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,20 +0,0 @@
-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;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DragPreviewDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: DragPreviewDirective, selector: "ng-template[tftDragPreview]", inputs: { dragData: "dragData" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: DragPreviewDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: 'ng-template[tftDragPreview]',
-                }]
-        }], ctorParameters: () => [{ type: i0.TemplateRef }], propDecorators: { dragData: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1wcmV2aWV3LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvaW50ZXJhY3Qvc3JjL2xpYi9kaXJlY3RpdmVzL2RyYWctcHJldmlldy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxjQUFjLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFFNUUsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQXVCLHNCQUFzQixDQUFDLENBQUM7QUFNakcsTUFBTSxPQUFPLG9CQUFvQjtJQUcvQixZQUFtQixXQUEyQjtRQUEzQixnQkFBVyxHQUFYLFdBQVcsQ0FBZ0I7SUFBSSxDQUFDOzhHQUh4QyxvQkFBb0I7a0dBQXBCLG9CQUFvQjs7MkZBQXBCLG9CQUFvQjtrQkFKaEMsU0FBUzttQkFBQztvQkFDVCw4REFBOEQ7b0JBQzlELFFBQVEsRUFBRSw2QkFBNkI7aUJBQ3ZDO2dGQUdTLFFBQVE7c0JBQWhCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSW5qZWN0aW9uVG9rZW4sIElucHV0LCBUZW1wbGF0ZVJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBURlRfRFJBR19QUkVWSUVXID0gbmV3IEluamVjdGlvblRva2VuPERyYWdQcmV2aWV3RGlyZWN0aXZlPignRHJhZ1ByZXZpZXdEaXJlY3RpdmUnKTtcblxuQERpcmVjdGl2ZSh7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvZGlyZWN0aXZlLXNlbGVjdG9yXG4gIHNlbGVjdG9yOiAnbmctdGVtcGxhdGVbdGZ0RHJhZ1ByZXZpZXddJyxcbiB9KVxuZXhwb3J0IGNsYXNzIERyYWdQcmV2aWV3RGlyZWN0aXZlPFQgPSBhbnk+IHtcblxuICBASW5wdXQoKSBkcmFnRGF0YTogVDtcbiAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxUPikgeyB9XG59XG4iXX0=