@tft/interact 13.0.0 → 15.0.0

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

@@ -0,0 +1,228 @@
+import { Directive, ElementRef, Input, Optional, SkipSelf, Output, EventEmitter, Renderer2, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import interact from 'interactjs';
+import { InteractService } from '../services/interact.service';
+import { DraggableDirective } from './draggable.directive';
+import { DropzoneDirective } from './dropzone.directive';
+import { DragRootDirective } from './drag-root.directive';
+import { AccountForScaleDirective } from './account-for-scale.directive';
+import { DEFAULT_REGISTRY_ID } from '../models';
+import { AutoScrollDirective } from './auto-scroll.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/interact.service";
+import * as i2 from "./drag-root.directive";
+import * as i3 from "./account-for-scale.directive";
+import * as i4 from "./draggable.directive";
+import * as i5 from "./dropzone.directive";
+import * as i6 from "./auto-scroll.directive";
+/** @dynamic */
+export class ResizableDirective {
+    get scale() {
+        return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale;
+    }
+    constructor(el, _document, interactService, renderer, drag_root_dir, account_for_scale_dir, draggable_dir, dropzone_dir, auto_scroll_dir) {
+        this.el = el;
+        this._document = _document;
+        this.interactService = interactService;
+        this.renderer = renderer;
+        this.drag_root_dir = drag_root_dir;
+        this.account_for_scale_dir = account_for_scale_dir;
+        this.draggable_dir = draggable_dir;
+        this.dropzone_dir = dropzone_dir;
+        this.auto_scroll_dir = auto_scroll_dir;
+        this.enableResizeDefault = true;
+        // TODO: should this be an input with default or should consuming user set display in styles each time
+        this.position = 'absolute';
+        this.resizeDisabled = false;
+        this.resizeStart = new EventEmitter();
+        this.resizeMove = new EventEmitter();
+        this.resizeInertiaStart = new EventEmitter();
+        this.resizeEnd = new EventEmitter();
+        this.defaultConfig = {
+            edges: { left: true, right: true, bottom: true, top: true }
+        };
+        this.activeEdges = { left: false, right: false, top: false, bottom: false };
+        this.dragRootEl = drag_root_dir?.el?.nativeElement || this._document.body;
+    }
+    ngOnInit() {
+        this.addResizePropertiesToElement(this.el.nativeElement);
+        // we check for a dropzone, we use its id as the registry id if there is on
+        // otherwise, we use DEFAULT_REGISTRY_ID as a registry id. This allows us to keep our interactable
+        // drag state organized by dropzones.
+        this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;
+        this.interactableId = this.draggable_dir?.interactableId || this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);
+        this.interactable = this.initiateResizeEvents({ ...this.defaultConfig, ...this.resizeConfig }, this.el.nativeElement);
+        this.alignDimensionsWithInputs(this.width, this.height);
+        this.interactableSubscription = this.interactService
+            .getInteractableState(this.interactableId, this.registryId)
+            .subscribe();
+    }
+    ngOnChanges(changes) {
+        if ((changes.resizeConfig || changes.resizeDisabled) && this.interactable) {
+            this.interactable.resizable({ ...this.resizeConfig, enabled: !this.resizeDisabled, });
+        }
+        if (changes.width || changes.height) {
+            this.alignDimensionsWithInputs(this.width, this.height);
+        }
+    }
+    ngOnDestroy() {
+        this.interactableSubscription.unsubscribe();
+        this.interactService.destroyInteractable(this.interactableId, this.registryId);
+    }
+    resizeListener(event) {
+        const element = this.el.nativeElement;
+        const scale = this.scale;
+        const { deltaRect } = event;
+        const deltaX = deltaRect.left / scale;
+        const deltaY = deltaRect.top / scale;
+        // We get the width and height directly from the native element because
+        // the event dimension can get out of sync when resizing with autoScroll
+        const rect = element.getBoundingClientRect();
+        const width = (rect.width + deltaRect.width) / scale;
+        const height = (rect.height + deltaRect.height) / scale;
+        this.interactService.updateSize(this.interactableId, this.registryId, { deltaX, deltaY, width, height }, this.el.nativeElement);
+    }
+    /**
+     *  hook elements into interacts resize event listeners
+     *  we spread the configs so that the consuming component only overwrites the
+     *  pieces that it explicitly indicates
+     * @param resizeConfig
+     * @param nativeElement
+     */
+    initiateResizeEvents(resizeConfig, nativeElement) {
+        // TODO: This should try and get interactable from tft_draggable if it exists
+        const defaultResizeConfig = {
+            ...resizeConfig,
+            enabled: !this.resizeDisabled,
+            ...(this.auto_scroll_dir && {
+                autoScroll: {
+                    ...this.auto_scroll_dir.autoScrollConfig,
+                    container: this.auto_scroll_dir.el.nativeElement
+                }
+            })
+        };
+        const interactable = this.draggable_dir?.interactable || interact(nativeElement);
+        return interactable.resizable(defaultResizeConfig)
+            .on('resizestart', (event) => {
+            this.activeEdges = event.edges;
+            if (this.auto_scroll_dir) {
+                this.subscribeToScrollEvents();
+            }
+            this.resizeStart.emit(this.mapResizeEvent(event));
+        })
+            .on('resizemove', (event) => {
+            if (this.enableResizeDefault) {
+                this.resizeListener(event);
+            }
+            const mappedEvent = this.mapResizeEvent(event);
+            this.resizeMove.emit(mappedEvent);
+        })
+            .on('resizeinertiastart', (event) => this.resizeInertiaStart.emit(this.mapResizeEvent(event)))
+            .on('resizeend', (event) => {
+            if (this.auto_scroll_dir) {
+                this.scrollEventsSubscription.unsubscribe();
+            }
+            this.activeEdges = { left: false, right: false, top: false, bottom: false };
+            this.resizeEnd.emit(this.mapResizeEvent(event));
+        });
+    }
+    mapResizeEvent(event) {
+        const target = this.el.nativeElement;
+        const relatedTarget = this.draggable_dir?.dropzone_dir?.el.nativeElement;
+        const scale = this.scale;
+        const positionInDropTarget = target && relatedTarget
+            ? this.interactService.calculatePositionInElement(relatedTarget, target, scale)
+            : null;
+        return {
+            interactEvent: event,
+            resizeRef: this,
+            dragRef: this.draggable_dir,
+            dragOrigin: this.dropzone_dir,
+            dropTarget: this.el.nativeElement.dropTarget,
+            positionInDropTarget,
+            size: {
+                width: target.clientWidth / scale,
+                height: target.clientHeight / scale
+            }
+        };
+    }
+    alignDimensionsWithInputs(width, height) {
+        this.interactService.updateSize(this.interactableId, this.registryId, { deltaX: 0, deltaY: 0, width, height }, this.el.nativeElement);
+    }
+    addResizePropertiesToElement(nativeElement) {
+        this.renderer.setProperty(nativeElement, 'resizeRef', this);
+    }
+    subscribeToScrollEvents() {
+        this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({ scrollLeft, scrollTop }) => {
+            const scale = this.scale;
+            const target = this.el.nativeElement;
+            const { width: prevWidth, height: prevHeight } = target.getBoundingClientRect();
+            const deltaHeight = scrollTop * (this.activeEdges.top ? -1 : this.activeEdges.bottom ? 1 : 0);
+            const deltaWidth = scrollLeft * (this.activeEdges.left ? -1 : this.activeEdges.right ? 1 : 0);
+            const height = (prevHeight + deltaHeight) / scale;
+            const width = (prevWidth + deltaWidth) / scale;
+            const deltaX = this.activeEdges.left ? (scrollLeft / scale) : 0;
+            const deltaY = this.activeEdges.top ? (scrollTop / scale) : 0;
+            this.interactService.updateSize(this.interactableId, this.registryId, { deltaX, deltaY, width, height }, this.el.nativeElement);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: i1.InteractService }, { token: i0.Renderer2 }, { token: i2.DragRootDirective, optional: true }, { token: i3.AccountForScaleDirective, optional: true }, { token: i4.DraggableDirective, optional: true }, { token: i5.DropzoneDirective, optional: true, skipSelf: true }, { token: i6.AutoScrollDirective, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.9", type: ResizableDirective, selector: "[tftResizable]", inputs: { enableResizeDefault: "enableResizeDefault", position: "position", resizeConfig: "resizeConfig", interactableId: "interactableId", width: "width", height: "height", resizeDisabled: "resizeDisabled" }, outputs: { resizeStart: "resizeStart", resizeMove: "resizeMove", resizeInertiaStart: "resizeInertiaStart", resizeEnd: "resizeEnd" }, host: { properties: { "style.touchAction": "this.resizeDisabled ? \"auto\" : \"none\"", "style.position": "position", "style.boxSizing": "\"border-box\"" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: ResizableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tftResizable]',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        // prevents touch events from colliding with with mouse events
+                        // on touch screen
+                        '[style.touchAction]': 'this.resizeDisabled ? "auto" : "none"',
+                        // default to absolute here to accommodate likely use cases
+                        // consuming component can easily over ride with position input
+                        '[style.position]': 'position',
+                        // follows interactjs suggested practices
+                        '[style.boxSizing]': '"border-box"',
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.InteractService }, { type: i0.Renderer2 }, { type: i2.DragRootDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i3.AccountForScaleDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i4.DraggableDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i5.DropzoneDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i6.AutoScrollDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }], propDecorators: { enableResizeDefault: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], resizeConfig: [{
+                type: Input
+            }], interactableId: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], resizeDisabled: [{
+                type: Input
+            }], resizeStart: [{
+                type: Output
+            }], resizeMove: [{
+                type: Output
+            }], resizeInertiaStart: [{
+                type: Output
+            }], resizeEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable.directive.js","sourceRoot":"","sources":["../../../../../../libs/interact/src/lib/directives/resizable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnInit, OnDestroy, ElementRef, Input, Optional, SkipSelf, Output, EventEmitter, OnChanges, SimpleChanges, Renderer2, Inject} from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport interact from 'interactjs';\nimport { InteractService } from '../services/interact.service';\nimport { ResizableOptions, ResizeEvent, Interactable } from '@interactjs/types/index';\nimport { Subscription } from 'rxjs';\nimport { DraggableDirective } from './draggable.directive';\nimport { DropzoneDirective } from './dropzone.directive';\nimport { DragRootDirective } from './drag-root.directive';\nimport { AccountForScaleDirective } from './account-for-scale.directive';\nimport { NgResizeEvent, TftResizeEvent, DEFAULT_REGISTRY_ID, TftDragElement } from '../models';\nimport { AutoScrollDirective } from './auto-scroll.directive';\n\ninterface ActiveEdges {\n  top: boolean;\n  bottom: boolean;\n  left: boolean;\n  right: boolean;\n}\n/** @dynamic */\n@Directive({\n  selector: '[tftResizable]',\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    // prevents touch events from colliding with with mouse events\n    // on touch screen\n    '[style.touchAction]': 'this.resizeDisabled ? \"auto\" : \"none\"',\n    // default to absolute here to accommodate likely use cases\n    // consuming component can easily over ride with position input\n    '[style.position]': 'position',\n    // follows interactjs suggested practices\n    '[style.boxSizing]': '\"border-box\"',\n\n  }\n})\nexport class ResizableDirective implements OnInit, OnDestroy, OnChanges {\n\n  @Input() enableResizeDefault = true;\n  // TODO: should this be an input with default or should consuming user set display in styles each time\n  @Input() position = 'absolute';\n  @Input() resizeConfig: Partial<Interact.OrBoolean<ResizableOptions>>;\n  @Input() interactableId: string;\n\n  @Input() width: number;\n  @Input() height: number;\n  @Input() resizeDisabled = false;\n\n  @Output() resizeStart = new EventEmitter<TftResizeEvent>();\n  @Output() resizeMove = new EventEmitter<TftResizeEvent>();\n  @Output() resizeInertiaStart = new EventEmitter<TftResizeEvent>();\n  @Output() resizeEnd = new EventEmitter<TftResizeEvent>();\n\n  defaultConfig: Partial<Interact.OrBoolean<ResizableOptions>> = {\n    edges: { left: true, right: true, bottom: true, top: true }\n  };\n  registryId: string;\n  interactable: Interactable;\n  // The\n  dragRootEl: HTMLElement;\n\n  private activeEdges: ActiveEdges = {left: false, right: false, top: false, bottom: false}\n  private interactableSubscription: Subscription;\n  private scrollEventsSubscription: Subscription;\n\n  get scale(): number {\n    return this.account_for_scale_dir?.scale || this.drag_root_dir?.account_for_scale_dir?.scale;\n  }\n\n  constructor(\n    public el: ElementRef,\n    @Inject(DOCUMENT) private _document: Document,\n    private interactService: InteractService,\n    private renderer: Renderer2,\n    @Optional() private drag_root_dir?: DragRootDirective,\n    @Optional() public account_for_scale_dir?: AccountForScaleDirective,\n    @Optional() private draggable_dir?: DraggableDirective,\n    @Optional() @SkipSelf() private dropzone_dir?: DropzoneDirective,\n    @Optional() @SkipSelf() public auto_scroll_dir?: AutoScrollDirective\n\n\n  ) {\n    this.dragRootEl = (drag_root_dir?.el?.nativeElement as HTMLElement) || this._document.body;\n  }\n\n  ngOnInit() {\n    this.addResizePropertiesToElement(this.el.nativeElement);\n\n    // we check for a dropzone, we use its id as the registry id if there is on\n    // otherwise, we use DEFAULT_REGISTRY_ID as a registry id. This allows us to keep our interactable\n    // drag state organized by dropzones.\n    this.registryId = this.dropzone_dir?.dropzoneId || DEFAULT_REGISTRY_ID;\n\n    this.interactableId = this.draggable_dir?.interactableId || this.interactService.addDraggableToRegistry(this.registryId, this.interactableId);\n\n    this.interactable = this.initiateResizeEvents(\n      {...this.defaultConfig, ...this.resizeConfig },\n      this.el.nativeElement\n    );\n\n    this.alignDimensionsWithInputs(this.width, this.height);\n\n    this.interactableSubscription = this.interactService\n      .getInteractableState(this.interactableId, this.registryId)\n      .subscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if ((changes.resizeConfig || changes.resizeDisabled) && this.interactable) {\n      this.interactable.resizable({...this.resizeConfig, enabled: !this.resizeDisabled,});\n    }\n    if (changes.width || changes.height) {\n      this.alignDimensionsWithInputs(this.width, this.height);\n    }\n  }\n\n  ngOnDestroy() {\n    this.interactableSubscription.unsubscribe();\n    this.interactService.destroyInteractable(this.interactableId, this.registryId);\n  }\n\n  resizeListener(event: ResizeEvent) {\n    const element: TftDragElement = this.el.nativeElement;\n    const scale = this.scale;\n    const {deltaRect} = event;\n    const deltaX = deltaRect.left/scale;\n    const deltaY = deltaRect.top/scale;\n    // We get the width and height directly from the native element because\n    // the event dimension can get out of sync when resizing with autoScroll\n    const rect = element.getBoundingClientRect();\n    const width = (rect.width + deltaRect.width)/scale;\n    const height = (rect.height + deltaRect.height)/scale;\n\n    this.interactService.updateSize(\n      this.interactableId,\n      this.registryId,\n      {deltaX, deltaY, width, height},\n      this.el.nativeElement\n    );\n  }\n  /**\n   *  hook elements into interacts resize event listeners\n   *  we spread the configs so that the consuming component only overwrites the\n   *  pieces that it explicitly indicates\n   * @param resizeConfig\n   * @param nativeElement\n   */\n  initiateResizeEvents(resizeConfig: Partial<Interact.OrBoolean<ResizableOptions>>, nativeElement: TftDragElement) {\n    // TODO: This should try and get interactable from tft_draggable if it exists\n    const defaultResizeConfig = {\n      ...resizeConfig,\n      enabled: !this.resizeDisabled,\n      ...(this.auto_scroll_dir && {\n        autoScroll: {\n          ...this.auto_scroll_dir.autoScrollConfig,\n          container: this.auto_scroll_dir.el.nativeElement as HTMLElement\n        }\n      })\n    };\n    const interactable = this.draggable_dir?.interactable || interact(nativeElement);\n    return interactable.resizable(defaultResizeConfig)\n      .on('resizestart', (event: NgResizeEvent) => {\n        this.activeEdges = event.edges as ActiveEdges;\n        if (this.auto_scroll_dir) {\n          this.subscribeToScrollEvents();\n        }\n        this.resizeStart.emit(this.mapResizeEvent(event))\n      })\n      .on('resizemove',  (event: NgResizeEvent) => {\n        if (this.enableResizeDefault) {\n          this.resizeListener(event)\n        }\n        const mappedEvent = this.mapResizeEvent(event);\n        this.resizeMove.emit(mappedEvent)\n      })\n      .on('resizeinertiastart', (event: NgResizeEvent) => this.resizeInertiaStart.emit(this.mapResizeEvent(event)))\n      .on('resizeend', (event: NgResizeEvent) => {\n        if (this.auto_scroll_dir) {\n          this.scrollEventsSubscription.unsubscribe();\n        }\n        this.activeEdges = {left: false, right: false, top: false, bottom: false}\n\n        this.resizeEnd.emit(this.mapResizeEvent(event));\n      });\n  }\n\n  mapResizeEvent(event: NgResizeEvent ): TftResizeEvent {\n    const target  = this.el.nativeElement as TftDragElement;\n    const relatedTarget = this.draggable_dir?.dropzone_dir?.el.nativeElement;\n    const scale = this.scale;\n    const positionInDropTarget = target && relatedTarget\n      ? this.interactService.calculatePositionInElement(relatedTarget, target, scale)\n      : null;\n    return {\n      interactEvent: event,\n      resizeRef: this,\n      dragRef: this.draggable_dir,\n      dragOrigin: this.dropzone_dir,\n      dropTarget: this.el.nativeElement.dropTarget,\n      positionInDropTarget,\n      size: {\n        width: target.clientWidth / scale,\n        height: target.clientHeight / scale\n      }\n    }\n  }\n\n  alignDimensionsWithInputs(width: number, height: number) {\n    this.interactService.updateSize(\n      this.interactableId,\n      this.registryId,\n      {deltaX: 0, deltaY: 0, width, height},\n      this.el.nativeElement\n    );\n  }\n\n  addResizePropertiesToElement(nativeElement: TftDragElement) {\n    this.renderer.setProperty(nativeElement, 'resizeRef', this);\n  }\n\n  subscribeToScrollEvents() {\n    this.scrollEventsSubscription = this.auto_scroll_dir.scrollDeltaObserver.subscribe(({scrollLeft, scrollTop}) => {\n      const scale = this.scale;\n      const target = this.el.nativeElement as HTMLElement;\n      const {width: prevWidth, height: prevHeight} = target.getBoundingClientRect();\n\n      const deltaHeight = scrollTop * (this.activeEdges.top ? -1 : this.activeEdges.bottom ? 1 : 0);\n      const deltaWidth = scrollLeft * (this.activeEdges.left ? -1 : this.activeEdges.right ? 1 : 0);\n\n      const height = (prevHeight + deltaHeight) / scale;\n      const width = (prevWidth + deltaWidth) / scale;\n      const deltaX = this.activeEdges.left ? (scrollLeft / scale) : 0;\n      const deltaY = this.activeEdges.top ? (scrollTop / scale) : 0;\n      this.interactService.updateSize(\n        this.interactableId,\n        this.registryId,\n        {deltaX, deltaY, width, height},\n        this.el.nativeElement as HTMLElement\n      );\n    });\n  }\n}\n"]}

package/esm2022/lib/interact.module.mjs

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

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

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

package/{esm2020 → esm2022}/lib/models/interact.mjs

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

package/{esm2020 → esm2022}/lib/pipes/array-of-n.pipe.mjs

@@ -1,22 +1,22 @@
-import { Pipe } from '@angular/core';
-import * as i0 from "@angular/core";
-export class ArrayOfNPipe {
-    /**
-     *
-     * @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, max) {
-        const length = ((max && max < n) || n === Infinity) ? max : n;
-        return new Array(length).fill(length).map((x, i) => i);
-    }
-}
-ArrayOfNPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-ArrayOfNPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, name: "arrayOfN" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'arrayOfN'
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktb2Ytbi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL3BpcGVzL2FycmF5LW9mLW4ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFLcEQsTUFBTSxPQUFPLFlBQVk7SUFFdkI7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxDQUFTLEVBQUUsR0FBVztRQUM5QixNQUFNLE1BQU0sR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzlELE9BQU8sSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBQyxDQUFDLEVBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7O3lHQVZVLFlBQVk7dUdBQVosWUFBWTsyRkFBWixZQUFZO2tCQUh4QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxVQUFVO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYXJyYXlPZk4nXG59KVxuZXhwb3J0IGNsYXNzIEFycmF5T2ZOUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIC8qKlxuICAgKiBcbiAgICogQHBhcmFtIG4gdGhlIG51bWJlciB0byBtYWtlIGFuIGFycmF5IG9mIFxuICAgKiBAcGFyYW0gbWF4IHRoZSBtYXggbGVuZ3RoIG9mIHRoZSBhcnJheSAodXNlZnVsIGZvciBsaW1pdGluZyByZW5kZXJpbmcgaW4gbmdGb3IgbG9vcClcbiAgICovXG4gIHRyYW5zZm9ybShuOiBudW1iZXIsIG1heDogbnVtYmVyKTogYW55IHtcbiAgICBjb25zdCBsZW5ndGggPSAoKG1heCAmJiBtYXggPCBuKSB8fCBuID09PSBJbmZpbml0eSkgPyBtYXggOiBuO1xuICAgIHJldHVybiBuZXcgQXJyYXkobGVuZ3RoKS5maWxsKGxlbmd0aCkubWFwKCh4LGkpPT4gaSk7IFxuICB9XG5cbn1cbiJdfQ==
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ArrayOfNPipe {
+    /**
+     *
+     * @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, max) {
+        const length = ((max && max < n) || n === Infinity) ? max : n;
+        return new Array(length).fill(length).map((x, i) => i);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: ArrayOfNPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.0.9", ngImport: i0, type: ArrayOfNPipe, name: "arrayOfN" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: ArrayOfNPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayOfN'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktb2Ytbi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL3BpcGVzL2FycmF5LW9mLW4ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFLcEQsTUFBTSxPQUFPLFlBQVk7SUFFdkI7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxDQUFTLEVBQUUsR0FBVztRQUM5QixNQUFNLE1BQU0sR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzlELE9BQU8sSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBQyxDQUFDLEVBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7OEdBVlUsWUFBWTs0R0FBWixZQUFZOzsyRkFBWixZQUFZO2tCQUh4QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxVQUFVO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYXJyYXlPZk4nXG59KVxuZXhwb3J0IGNsYXNzIEFycmF5T2ZOUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIC8qKlxuICAgKiBcbiAgICogQHBhcmFtIG4gdGhlIG51bWJlciB0byBtYWtlIGFuIGFycmF5IG9mIFxuICAgKiBAcGFyYW0gbWF4IHRoZSBtYXggbGVuZ3RoIG9mIHRoZSBhcnJheSAodXNlZnVsIGZvciBsaW1pdGluZyByZW5kZXJpbmcgaW4gbmdGb3IgbG9vcClcbiAgICovXG4gIHRyYW5zZm9ybShuOiBudW1iZXIsIG1heDogbnVtYmVyKTogYW55IHtcbiAgICBjb25zdCBsZW5ndGggPSAoKG1heCAmJiBtYXggPCBuKSB8fCBuID09PSBJbmZpbml0eSkgPyBtYXggOiBuO1xuICAgIHJldHVybiBuZXcgQXJyYXkobGVuZ3RoKS5maWxsKGxlbmd0aCkubWFwKCh4LGkpPT4gaSk7IFxuICB9XG5cbn1cbiJdfQ==

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

@@ -1,2 +1,2 @@
-export * from './array-of-n.pipe';
+export * from './array-of-n.pipe';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXJyYXktb2Ytbi5waXBlJzsiXX0=