@swimlane/ngx-datatable 18.0.0 → 20.0.0-alpha-1

package/esm2020/lib/directives/long-press.directive.mjs

@@ -0,0 +1,117 @@
+import { Directive, Input, Output, EventEmitter, HostBinding, HostListener } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class LongPressDirective {
+    constructor() {
+        this.pressEnabled = true;
+        this.duration = 500;
+        this.longPressStart = new EventEmitter();
+        this.longPressing = new EventEmitter();
+        this.longPressEnd = new EventEmitter();
+        this.mouseX = 0;
+        this.mouseY = 0;
+    }
+    get press() {
+        return this.pressing;
+    }
+    get isLongPress() {
+        return this.isLongPressing;
+    }
+    onMouseDown(event) {
+        // don't do right/middle clicks
+        if (event.which !== 1 || !this.pressEnabled)
+            return;
+        // don't start drag if its on resize handle
+        const target = event.target;
+        if (target.classList.contains('resize-handle'))
+            return;
+        this.mouseX = event.clientX;
+        this.mouseY = event.clientY;
+        this.pressing = true;
+        this.isLongPressing = false;
+        const mouseup = fromEvent(document, 'mouseup');
+        this.subscription = mouseup.subscribe((ev) => this.onMouseup());
+        this.timeout = setTimeout(() => {
+            this.isLongPressing = true;
+            this.longPressStart.emit({
+                event,
+                model: this.pressModel
+            });
+            this.subscription.add(fromEvent(document, 'mousemove')
+                .pipe(takeUntil(mouseup))
+                .subscribe((mouseEvent) => this.onMouseMove(mouseEvent)));
+            this.loop(event);
+        }, this.duration);
+        this.loop(event);
+    }
+    onMouseMove(event) {
+        if (this.pressing && !this.isLongPressing) {
+            const xThres = Math.abs(event.clientX - this.mouseX) > 10;
+            const yThres = Math.abs(event.clientY - this.mouseY) > 10;
+            if (xThres || yThres) {
+                this.endPress();
+            }
+        }
+    }
+    loop(event) {
+        if (this.isLongPressing) {
+            this.timeout = setTimeout(() => {
+                this.longPressing.emit({
+                    event,
+                    model: this.pressModel
+                });
+                this.loop(event);
+            }, 50);
+        }
+    }
+    endPress() {
+        clearTimeout(this.timeout);
+        this.isLongPressing = false;
+        this.pressing = false;
+        this._destroySubscription();
+        this.longPressEnd.emit({
+            model: this.pressModel
+        });
+    }
+    onMouseup() {
+        this.endPress();
+    }
+    ngOnDestroy() {
+        this._destroySubscription();
+    }
+    _destroySubscription() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = undefined;
+        }
+    }
+}
+LongPressDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LongPressDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+LongPressDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: LongPressDirective, selector: "[long-press]", inputs: { pressEnabled: "pressEnabled", pressModel: "pressModel", duration: "duration" }, outputs: { longPressStart: "longPressStart", longPressing: "longPressing", longPressEnd: "longPressEnd" }, host: { listeners: { "mousedown": "onMouseDown($event)" }, properties: { "class.press": "this.press", "class.longpress": "this.isLongPress" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LongPressDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[long-press]' }]
+        }], propDecorators: { pressEnabled: [{
+                type: Input
+            }], pressModel: [{
+                type: Input
+            }], duration: [{
+                type: Input
+            }], longPressStart: [{
+                type: Output
+            }], longPressing: [{
+                type: Output
+            }], longPressEnd: [{
+                type: Output
+            }], press: [{
+                type: HostBinding,
+                args: ['class.press']
+            }], isLongPress: [{
+                type: HostBinding,
+                args: ['class.longpress']
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"long-press.directive.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/directives/long-press.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, Output, EventEmitter, HostBinding, HostListener, OnDestroy } from '@angular/core';\nimport { Observable, Subscription, fromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { MouseEvent } from '../events';\n\n@Directive({ selector: '[long-press]' })\nexport class LongPressDirective implements OnDestroy {\n  @Input() pressEnabled: boolean = true;\n  @Input() pressModel: any;\n  @Input() duration: number = 500;\n\n  @Output() longPressStart: EventEmitter<any> = new EventEmitter();\n  @Output() longPressing: EventEmitter<any> = new EventEmitter();\n  @Output() longPressEnd: EventEmitter<any> = new EventEmitter();\n\n  pressing: boolean;\n  isLongPressing: boolean;\n  timeout: any;\n  mouseX: number = 0;\n  mouseY: number = 0;\n\n  subscription: Subscription;\n\n  @HostBinding('class.press')\n  get press(): boolean {\n    return this.pressing;\n  }\n\n  @HostBinding('class.longpress')\n  get isLongPress(): boolean {\n    return this.isLongPressing;\n  }\n\n  @HostListener('mousedown', ['$event'])\n  onMouseDown(event: MouseEvent): void {\n    // don't do right/middle clicks\n    if (event.which !== 1 || !this.pressEnabled) return;\n\n    // don't start drag if its on resize handle\n    const target = <HTMLElement>event.target;\n    if (target.classList.contains('resize-handle')) return;\n\n    this.mouseX = event.clientX;\n    this.mouseY = event.clientY;\n\n    this.pressing = true;\n    this.isLongPressing = false;\n\n    const mouseup = fromEvent(document, 'mouseup');\n    this.subscription = mouseup.subscribe((ev: MouseEvent) => this.onMouseup());\n\n    this.timeout = setTimeout(() => {\n      this.isLongPressing = true;\n      this.longPressStart.emit({\n        event,\n        model: this.pressModel\n      });\n\n      this.subscription.add(\n        fromEvent(document, 'mousemove')\n          .pipe(takeUntil(mouseup))\n          .subscribe((mouseEvent: MouseEvent) => this.onMouseMove(mouseEvent))\n      );\n\n      this.loop(event);\n    }, this.duration);\n\n    this.loop(event);\n  }\n\n  onMouseMove(event: MouseEvent): void {\n    if (this.pressing && !this.isLongPressing) {\n      const xThres = Math.abs(event.clientX - this.mouseX) > 10;\n      const yThres = Math.abs(event.clientY - this.mouseY) > 10;\n\n      if (xThres || yThres) {\n        this.endPress();\n      }\n    }\n  }\n\n  loop(event: MouseEvent): void {\n    if (this.isLongPressing) {\n      this.timeout = setTimeout(() => {\n        this.longPressing.emit({\n          event,\n          model: this.pressModel\n        });\n        this.loop(event);\n      }, 50);\n    }\n  }\n\n  endPress(): void {\n    clearTimeout(this.timeout);\n    this.isLongPressing = false;\n    this.pressing = false;\n    this._destroySubscription();\n\n    this.longPressEnd.emit({\n      model: this.pressModel\n    });\n  }\n\n  onMouseup(): void {\n    this.endPress();\n  }\n\n  ngOnDestroy(): void {\n    this._destroySubscription();\n  }\n\n  private _destroySubscription(): void {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      this.subscription = undefined;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,136 @@
+import { Directive, Output, EventEmitter, ContentChildren, Inject } from '@angular/core';
+import { DraggableDirective } from './draggable.directive';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+export class OrderableDirective {
+    constructor(differs, document) {
+        this.document = document;
+        this.reorder = new EventEmitter();
+        this.targetChanged = new EventEmitter();
+        this.differ = differs.find({}).create();
+    }
+    ngAfterContentInit() {
+        // HACK: Investigate Better Way
+        this.updateSubscriptions();
+        this.draggables.changes.subscribe(this.updateSubscriptions.bind(this));
+    }
+    ngOnDestroy() {
+        this.draggables.forEach(d => {
+            d.dragStart.unsubscribe();
+            d.dragging.unsubscribe();
+            d.dragEnd.unsubscribe();
+        });
+    }
+    updateSubscriptions() {
+        const diffs = this.differ.diff(this.createMapDiffs());
+        if (diffs) {
+            const subscribe = ({ currentValue, previousValue }) => {
+                unsubscribe({ previousValue });
+                if (currentValue) {
+                    currentValue.dragStart.subscribe(this.onDragStart.bind(this));
+                    currentValue.dragging.subscribe(this.onDragging.bind(this));
+                    currentValue.dragEnd.subscribe(this.onDragEnd.bind(this));
+                }
+            };
+            const unsubscribe = ({ previousValue }) => {
+                if (previousValue) {
+                    previousValue.dragStart.unsubscribe();
+                    previousValue.dragging.unsubscribe();
+                    previousValue.dragEnd.unsubscribe();
+                }
+            };
+            diffs.forEachAddedItem(subscribe);
+            // diffs.forEachChangedItem(subscribe.bind(this));
+            diffs.forEachRemovedItem(unsubscribe);
+        }
+    }
+    onDragStart() {
+        this.positions = {};
+        let i = 0;
+        for (const dragger of this.draggables.toArray()) {
+            const elm = dragger.element;
+            const left = parseInt(elm.offsetLeft.toString(), 0);
+            this.positions[dragger.dragModel.prop] = {
+                left,
+                right: left + parseInt(elm.offsetWidth.toString(), 0),
+                index: i++,
+                element: elm
+            };
+        }
+    }
+    onDragging({ element, model, event }) {
+        const prevPos = this.positions[model.prop];
+        const target = this.isTarget(model, event);
+        if (target) {
+            if (this.lastDraggingIndex !== target.i) {
+                this.targetChanged.emit({
+                    prevIndex: this.lastDraggingIndex,
+                    newIndex: target.i,
+                    initialIndex: prevPos.index
+                });
+                this.lastDraggingIndex = target.i;
+            }
+        }
+        else if (this.lastDraggingIndex !== prevPos.index) {
+            this.targetChanged.emit({
+                prevIndex: this.lastDraggingIndex,
+                initialIndex: prevPos.index
+            });
+            this.lastDraggingIndex = prevPos.index;
+        }
+    }
+    onDragEnd({ element, model, event }) {
+        const prevPos = this.positions[model.prop];
+        const target = this.isTarget(model, event);
+        if (target) {
+            this.reorder.emit({
+                prevIndex: prevPos.index,
+                newIndex: target.i,
+                model
+            });
+        }
+        this.lastDraggingIndex = undefined;
+        element.style.left = 'auto';
+    }
+    isTarget(model, event) {
+        let i = 0;
+        const x = event.x || event.clientX;
+        const y = event.y || event.clientY;
+        const targets = this.document.elementsFromPoint(x, y);
+        for (const prop in this.positions) {
+            // current column position which throws event.
+            const pos = this.positions[prop];
+            // since we drag the inner span, we need to find it in the elements at the cursor
+            if (model.prop !== prop && targets.find((el) => el === pos.element)) {
+                return {
+                    pos,
+                    i
+                };
+            }
+            i++;
+        }
+    }
+    createMapDiffs() {
+        return this.draggables.toArray().reduce((acc, curr) => {
+            acc[curr.dragModel.$$id] = curr;
+            return acc;
+        }, {});
+    }
+}
+OrderableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: OrderableDirective, deps: [{ token: i0.KeyValueDiffers }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+OrderableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: OrderableDirective, selector: "[orderable]", outputs: { reorder: "reorder", targetChanged: "targetChanged" }, queries: [{ propertyName: "draggables", predicate: DraggableDirective, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: OrderableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[orderable]' }]
+        }], ctorParameters: function () { return [{ type: i0.KeyValueDiffers }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { reorder: [{
+                type: Output
+            }], targetChanged: [{
+                type: Output
+            }], draggables: [{
+                type: ContentChildren,
+                args: [DraggableDirective, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orderable.directive.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/directives/orderable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Output,\n  EventEmitter,\n  ContentChildren,\n  QueryList,\n  KeyValueDiffers,\n  AfterContentInit,\n  OnDestroy,\n  Inject\n} from '@angular/core';\nimport { DraggableDirective } from './draggable.directive';\nimport { DOCUMENT } from '@angular/common';\n\n@Directive({ selector: '[orderable]' })\nexport class OrderableDirective implements AfterContentInit, OnDestroy {\n  @Output() reorder: EventEmitter<any> = new EventEmitter();\n  @Output() targetChanged: EventEmitter<any> = new EventEmitter();\n\n  @ContentChildren(DraggableDirective, { descendants: true })\n  draggables: QueryList<DraggableDirective>;\n\n  positions: any;\n  differ: any;\n  lastDraggingIndex: number;\n\n  constructor(differs: KeyValueDiffers, @Inject(DOCUMENT) private document: any) {\n    this.differ = differs.find({}).create();\n  }\n\n  ngAfterContentInit(): void {\n    // HACK: Investigate Better Way\n    this.updateSubscriptions();\n    this.draggables.changes.subscribe(this.updateSubscriptions.bind(this));\n  }\n\n  ngOnDestroy(): void {\n    this.draggables.forEach(d => {\n      d.dragStart.unsubscribe();\n      d.dragging.unsubscribe();\n      d.dragEnd.unsubscribe();\n    });\n  }\n\n  updateSubscriptions(): void {\n    const diffs = this.differ.diff(this.createMapDiffs());\n\n    if (diffs) {\n      const subscribe = ({ currentValue, previousValue }: any) => {\n        unsubscribe({ previousValue });\n\n        if (currentValue) {\n          currentValue.dragStart.subscribe(this.onDragStart.bind(this));\n          currentValue.dragging.subscribe(this.onDragging.bind(this));\n          currentValue.dragEnd.subscribe(this.onDragEnd.bind(this));\n        }\n      };\n\n      const unsubscribe = ({ previousValue }: any) => {\n        if (previousValue) {\n          previousValue.dragStart.unsubscribe();\n          previousValue.dragging.unsubscribe();\n          previousValue.dragEnd.unsubscribe();\n        }\n      };\n\n      diffs.forEachAddedItem(subscribe);\n      // diffs.forEachChangedItem(subscribe.bind(this));\n      diffs.forEachRemovedItem(unsubscribe);\n    }\n  }\n\n  onDragStart(): void {\n    this.positions = {};\n\n    let i = 0;\n    for (const dragger of this.draggables.toArray()) {\n      const elm = dragger.element;\n      const left = parseInt(elm.offsetLeft.toString(), 0);\n      this.positions[dragger.dragModel.prop] = {\n        left,\n        right: left + parseInt(elm.offsetWidth.toString(), 0),\n        index: i++,\n        element: elm\n      };\n    }\n  }\n\n  onDragging({ element, model, event }: any): void {\n    const prevPos = this.positions[model.prop];\n    const target = this.isTarget(model, event);\n\n    if (target) {\n      if (this.lastDraggingIndex !== target.i) {\n        this.targetChanged.emit({\n          prevIndex: this.lastDraggingIndex,\n          newIndex: target.i,\n          initialIndex: prevPos.index\n        });\n        this.lastDraggingIndex = target.i;\n      }\n    } else if (this.lastDraggingIndex !== prevPos.index) {\n      this.targetChanged.emit({\n        prevIndex: this.lastDraggingIndex,\n        initialIndex: prevPos.index\n      });\n      this.lastDraggingIndex = prevPos.index;\n    }\n  }\n\n  onDragEnd({ element, model, event }: any): void {\n    const prevPos = this.positions[model.prop];\n\n    const target = this.isTarget(model, event);\n    if (target) {\n      this.reorder.emit({\n        prevIndex: prevPos.index,\n        newIndex: target.i,\n        model\n      });\n    }\n\n    this.lastDraggingIndex = undefined;\n    element.style.left = 'auto';\n  }\n\n  isTarget(model: any, event: any): any {\n    let i = 0;\n    const x = event.x || event.clientX;\n    const y = event.y || event.clientY;\n    const targets = this.document.elementsFromPoint(x, y);\n\n    for (const prop in this.positions) {\n      // current column position which throws event.\n      const pos = this.positions[prop];\n\n      // since we drag the inner span, we need to find it in the elements at the cursor\n      if (model.prop !== prop && targets.find((el: any) => el === pos.element)) {\n        return {\n          pos,\n          i\n        };\n      }\n\n      i++;\n    }\n  }\n\n  private createMapDiffs(): { [key: string]: DraggableDirective } {\n    return this.draggables.toArray().reduce((acc, curr) => {\n      acc[curr.dragModel.$$id] = curr;\n      return acc;\n    }, {});\n  }\n}\n"]}

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

@@ -0,0 +1,93 @@
+import { Directive, HostListener, Input, Output, EventEmitter } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class ResizeableDirective {
+    constructor(element, renderer) {
+        this.renderer = renderer;
+        this.resizeEnabled = true;
+        this.resize = new EventEmitter();
+        this.resizing = false;
+        this.element = element.nativeElement;
+    }
+    ngAfterViewInit() {
+        const renderer2 = this.renderer;
+        this.resizeHandle = renderer2.createElement('span');
+        if (this.resizeEnabled) {
+            renderer2.addClass(this.resizeHandle, 'resize-handle');
+        }
+        else {
+            renderer2.addClass(this.resizeHandle, 'resize-handle--not-resizable');
+        }
+        renderer2.appendChild(this.element, this.resizeHandle);
+    }
+    ngOnDestroy() {
+        this._destroySubscription();
+        if (this.renderer.destroyNode) {
+            this.renderer.destroyNode(this.resizeHandle);
+        }
+        else if (this.resizeHandle) {
+            this.renderer.removeChild(this.renderer.parentNode(this.resizeHandle), this.resizeHandle);
+        }
+    }
+    onMouseup() {
+        this.resizing = false;
+        if (this.subscription && !this.subscription.closed) {
+            this._destroySubscription();
+            this.resize.emit(this.element.clientWidth);
+        }
+    }
+    onMousedown(event) {
+        const isHandle = event.target.classList.contains('resize-handle');
+        const initialWidth = this.element.clientWidth;
+        const mouseDownScreenX = event.screenX;
+        if (isHandle) {
+            event.stopPropagation();
+            this.resizing = true;
+            const mouseup = fromEvent(document, 'mouseup');
+            this.subscription = mouseup.subscribe((ev) => this.onMouseup());
+            const mouseMoveSub = fromEvent(document, 'mousemove')
+                .pipe(takeUntil(mouseup))
+                .subscribe((e) => this.move(e, initialWidth, mouseDownScreenX));
+            this.subscription.add(mouseMoveSub);
+        }
+    }
+    move(event, initialWidth, mouseDownScreenX) {
+        const movementX = event.screenX - mouseDownScreenX;
+        const newWidth = initialWidth + movementX;
+        const overMinWidth = !this.minWidth || newWidth >= this.minWidth;
+        const underMaxWidth = !this.maxWidth || newWidth <= this.maxWidth;
+        if (overMinWidth && underMaxWidth) {
+            this.element.style.width = `${newWidth}px`;
+        }
+    }
+    _destroySubscription() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = undefined;
+        }
+    }
+}
+ResizeableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ResizeableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+ResizeableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: ResizeableDirective, selector: "[resizeable]", inputs: { resizeEnabled: "resizeEnabled", minWidth: "minWidth", maxWidth: "maxWidth" }, outputs: { resize: "resize" }, host: { listeners: { "mousedown": "onMousedown($event)" }, properties: { "class.resizeable": "resizeEnabled" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ResizeableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[resizeable]',
+                    host: {
+                        '[class.resizeable]': 'resizeEnabled'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { resizeEnabled: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], resize: [{
+                type: Output
+            }], onMousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizeable.directive.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/directives/resizeable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  HostListener,\n  Input,\n  Output,\n  EventEmitter,\n  OnDestroy,\n  AfterViewInit,\n  Renderer2\n} from '@angular/core';\nimport { Subscription, fromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n@Directive({\n  selector: '[resizeable]',\n  host: {\n    '[class.resizeable]': 'resizeEnabled'\n  }\n})\nexport class ResizeableDirective implements OnDestroy, AfterViewInit {\n  @Input() resizeEnabled: boolean = true;\n  @Input() minWidth: number;\n  @Input() maxWidth: number;\n\n  @Output() resize: EventEmitter<any> = new EventEmitter();\n\n  element: HTMLElement;\n  subscription: Subscription;\n  resizing: boolean = false;\n  private resizeHandle: HTMLElement;\n\n  constructor(element: ElementRef, private renderer: Renderer2) {\n    this.element = element.nativeElement;\n  }\n\n  ngAfterViewInit(): void {\n    const renderer2 = this.renderer;\n    this.resizeHandle = renderer2.createElement('span');\n    if (this.resizeEnabled) {\n      renderer2.addClass(this.resizeHandle, 'resize-handle');\n    } else {\n      renderer2.addClass(this.resizeHandle, 'resize-handle--not-resizable');\n    }\n    renderer2.appendChild(this.element, this.resizeHandle);\n  }\n\n  ngOnDestroy(): void {\n    this._destroySubscription();\n    if (this.renderer.destroyNode) {\n      this.renderer.destroyNode(this.resizeHandle);\n    } else if (this.resizeHandle) {\n      this.renderer.removeChild(this.renderer.parentNode(this.resizeHandle), this.resizeHandle);\n    }\n  }\n\n  onMouseup(): void {\n    this.resizing = false;\n\n    if (this.subscription && !this.subscription.closed) {\n      this._destroySubscription();\n      this.resize.emit(this.element.clientWidth);\n    }\n  }\n\n  @HostListener('mousedown', ['$event'])\n  onMousedown(event: MouseEvent): void {\n    const isHandle = (<HTMLElement>event.target).classList.contains('resize-handle');\n    const initialWidth = this.element.clientWidth;\n    const mouseDownScreenX = event.screenX;\n\n    if (isHandle) {\n      event.stopPropagation();\n      this.resizing = true;\n\n      const mouseup = fromEvent(document, 'mouseup');\n      this.subscription = mouseup.subscribe((ev: MouseEvent) => this.onMouseup());\n\n      const mouseMoveSub = fromEvent(document, 'mousemove')\n        .pipe(takeUntil(mouseup))\n        .subscribe((e: MouseEvent) => this.move(e, initialWidth, mouseDownScreenX));\n\n      this.subscription.add(mouseMoveSub);\n    }\n  }\n\n  move(event: MouseEvent, initialWidth: number, mouseDownScreenX: number): void {\n    const movementX = event.screenX - mouseDownScreenX;\n    const newWidth = initialWidth + movementX;\n\n    const overMinWidth = !this.minWidth || newWidth >= this.minWidth;\n    const underMaxWidth = !this.maxWidth || newWidth <= this.maxWidth;\n\n    if (overMinWidth && underMaxWidth) {\n      this.element.style.width = `${newWidth}px`;\n    }\n  }\n\n  private _destroySubscription() {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      this.subscription = undefined;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,63 @@
+import { Directive, Output, EventEmitter, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Visibility Observer Directive
+ *
+ * Usage:
+ *
+ * 		<div
+ * 			visibilityObserver
+ * 			(visible)="onVisible($event)">
+ * 		</div>
+ *
+ */
+export class VisibilityDirective {
+    constructor(element, zone) {
+        this.element = element;
+        this.zone = zone;
+        this.isVisible = false;
+        this.visible = new EventEmitter();
+    }
+    ngOnInit() {
+        this.runCheck();
+    }
+    ngOnDestroy() {
+        clearTimeout(this.timeout);
+    }
+    onVisibilityChange() {
+        // trigger zone recalc for columns
+        this.zone.run(() => {
+            this.isVisible = true;
+            this.visible.emit(true);
+        });
+    }
+    runCheck() {
+        const check = () => {
+            // https://davidwalsh.name/offsetheight-visibility
+            const { offsetHeight, offsetWidth } = this.element.nativeElement;
+            if (offsetHeight && offsetWidth) {
+                clearTimeout(this.timeout);
+                this.onVisibilityChange();
+            }
+            else {
+                clearTimeout(this.timeout);
+                this.zone.runOutsideAngular(() => {
+                    this.timeout = setTimeout(() => check(), 50);
+                });
+            }
+        };
+        this.timeout = setTimeout(() => check());
+    }
+}
+VisibilityDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: VisibilityDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+VisibilityDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: VisibilityDirective, selector: "[visibilityObserver]", outputs: { visible: "visible" }, host: { properties: { "class.visible": "this.isVisible" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: VisibilityDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[visibilityObserver]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { isVisible: [{
+                type: HostBinding,
+                args: ['class.visible']
+            }], visible: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ngx-datatable.module.mjs

@@ -0,0 +1,139 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ScrollbarHelper } from './services/scrollbar-helper.service';
+import { DimensionsHelper } from './services/dimensions-helper.service';
+import { ColumnChangesService } from './services/column-changes.service';
+import { DataTableFooterTemplateDirective } from './components/footer/footer-template.directive';
+import { VisibilityDirective } from './directives/visibility.directive';
+import { DraggableDirective } from './directives/draggable.directive';
+import { ResizeableDirective } from './directives/resizeable.directive';
+import { OrderableDirective } from './directives/orderable.directive';
+import { LongPressDirective } from './directives/long-press.directive';
+import { ScrollerComponent } from './components/body/scroller.component';
+import { DatatableComponent } from './components/datatable.component';
+import { DataTableColumnDirective } from './components/columns/column.directive';
+import { DataTableHeaderComponent } from './components/header/header.component';
+import { DataTableHeaderCellComponent } from './components/header/header-cell.component';
+import { DataTableBodyComponent } from './components/body/body.component';
+import { DataTableFooterComponent } from './components/footer/footer.component';
+import { DataTablePagerComponent } from './components/footer/pager.component';
+import { ProgressBarComponent } from './components/body/progress-bar.component';
+import { DataTableBodyRowComponent } from './components/body/body-row.component';
+import { DataTableRowWrapperComponent } from './components/body/body-row-wrapper.component';
+import { DatatableRowDetailDirective } from './components/row-detail/row-detail.directive';
+import { DatatableGroupHeaderDirective } from './components/body/body-group-header.directive';
+import { DatatableRowDetailTemplateDirective } from './components/row-detail/row-detail-template.directive';
+import { DataTableBodyCellComponent } from './components/body/body-cell.component';
+import { DataTableSelectionComponent } from './components/body/selection.component';
+import { DataTableColumnHeaderDirective } from './components/columns/column-header.directive';
+import { DataTableColumnCellDirective } from './components/columns/column-cell.directive';
+import { DataTableColumnCellTreeToggle } from './components/columns/tree.directive';
+import { DatatableFooterDirective } from './components/footer/footer.directive';
+import { DatatableGroupHeaderTemplateDirective } from './components/body/body-group-header-template.directive';
+import { DataTableSummaryRowComponent } from './components/body/summary/summary-row.component';
+import * as i0 from "@angular/core";
+export class NgxDatatableModule {
+    /**
+     * Configure global configuration via INgxDatatableConfig
+     * @param configuration
+     */
+    static forRoot(configuration) {
+        return {
+            ngModule: NgxDatatableModule,
+            providers: [{ provide: 'configuration', useValue: configuration }]
+        };
+    }
+}
+NgxDatatableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxDatatableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxDatatableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxDatatableModule, declarations: [DataTableFooterTemplateDirective,
+        VisibilityDirective,
+        DraggableDirective,
+        ResizeableDirective,
+        OrderableDirective,
+        LongPressDirective,
+        ScrollerComponent,
+        DatatableComponent,
+        DataTableColumnDirective,
+        DataTableHeaderComponent,
+        DataTableHeaderCellComponent,
+        DataTableBodyComponent,
+        DataTableFooterComponent,
+        DataTablePagerComponent,
+        ProgressBarComponent,
+        DataTableBodyRowComponent,
+        DataTableRowWrapperComponent,
+        DatatableRowDetailDirective,
+        DatatableGroupHeaderDirective,
+        DatatableRowDetailTemplateDirective,
+        DataTableBodyCellComponent,
+        DataTableSelectionComponent,
+        DataTableColumnHeaderDirective,
+        DataTableColumnCellDirective,
+        DataTableColumnCellTreeToggle,
+        DatatableFooterDirective,
+        DatatableGroupHeaderTemplateDirective,
+        DataTableSummaryRowComponent], imports: [CommonModule], exports: [DatatableComponent,
+        DatatableRowDetailDirective,
+        DatatableGroupHeaderDirective,
+        DatatableRowDetailTemplateDirective,
+        DataTableColumnDirective,
+        DataTableColumnHeaderDirective,
+        DataTableColumnCellDirective,
+        DataTableColumnCellTreeToggle,
+        DataTableFooterTemplateDirective,
+        DatatableFooterDirective,
+        DataTablePagerComponent,
+        DatatableGroupHeaderTemplateDirective] });
+NgxDatatableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxDatatableModule, providers: [ScrollbarHelper, DimensionsHelper, ColumnChangesService], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxDatatableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    providers: [ScrollbarHelper, DimensionsHelper, ColumnChangesService],
+                    declarations: [
+                        DataTableFooterTemplateDirective,
+                        VisibilityDirective,
+                        DraggableDirective,
+                        ResizeableDirective,
+                        OrderableDirective,
+                        LongPressDirective,
+                        ScrollerComponent,
+                        DatatableComponent,
+                        DataTableColumnDirective,
+                        DataTableHeaderComponent,
+                        DataTableHeaderCellComponent,
+                        DataTableBodyComponent,
+                        DataTableFooterComponent,
+                        DataTablePagerComponent,
+                        ProgressBarComponent,
+                        DataTableBodyRowComponent,
+                        DataTableRowWrapperComponent,
+                        DatatableRowDetailDirective,
+                        DatatableGroupHeaderDirective,
+                        DatatableRowDetailTemplateDirective,
+                        DataTableBodyCellComponent,
+                        DataTableSelectionComponent,
+                        DataTableColumnHeaderDirective,
+                        DataTableColumnCellDirective,
+                        DataTableColumnCellTreeToggle,
+                        DatatableFooterDirective,
+                        DatatableGroupHeaderTemplateDirective,
+                        DataTableSummaryRowComponent
+                    ],
+                    exports: [
+                        DatatableComponent,
+                        DatatableRowDetailDirective,
+                        DatatableGroupHeaderDirective,
+                        DatatableRowDetailTemplateDirective,
+                        DataTableColumnDirective,
+                        DataTableColumnHeaderDirective,
+                        DataTableColumnCellDirective,
+                        DataTableColumnCellTreeToggle,
+                        DataTableFooterTemplateDirective,
+                        DatatableFooterDirective,
+                        DataTablePagerComponent,
+                        DatatableGroupHeaderTemplateDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-datatable.module.js","sourceRoot":"","sources":["../../../../../projects/swimlane/ngx-datatable/src/lib/ngx-datatable.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule, ModuleWithProviders } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ScrollbarHelper } from './services/scrollbar-helper.service';\nimport { DimensionsHelper } from './services/dimensions-helper.service';\nimport { ColumnChangesService } from './services/column-changes.service';\nimport { DataTableFooterTemplateDirective } from './components/footer/footer-template.directive';\nimport { VisibilityDirective } from './directives/visibility.directive';\nimport { DraggableDirective } from './directives/draggable.directive';\nimport { ResizeableDirective } from './directives/resizeable.directive';\nimport { OrderableDirective } from './directives/orderable.directive';\nimport { LongPressDirective } from './directives/long-press.directive';\nimport { ScrollerComponent } from './components/body/scroller.component';\nimport { DatatableComponent } from './components/datatable.component';\nimport { DataTableColumnDirective } from './components/columns/column.directive';\nimport { DataTableHeaderComponent } from './components/header/header.component';\nimport { DataTableHeaderCellComponent } from './components/header/header-cell.component';\nimport { DataTableBodyComponent } from './components/body/body.component';\nimport { DataTableFooterComponent } from './components/footer/footer.component';\nimport { DataTablePagerComponent } from './components/footer/pager.component';\nimport { ProgressBarComponent } from './components/body/progress-bar.component';\nimport { DataTableBodyRowComponent } from './components/body/body-row.component';\nimport { DataTableRowWrapperComponent } from './components/body/body-row-wrapper.component';\nimport { DatatableRowDetailDirective } from './components/row-detail/row-detail.directive';\nimport { DatatableGroupHeaderDirective } from './components/body/body-group-header.directive';\nimport { DatatableRowDetailTemplateDirective } from './components/row-detail/row-detail-template.directive';\nimport { DataTableBodyCellComponent } from './components/body/body-cell.component';\nimport { DataTableSelectionComponent } from './components/body/selection.component';\nimport { DataTableColumnHeaderDirective } from './components/columns/column-header.directive';\nimport { DataTableColumnCellDirective } from './components/columns/column-cell.directive';\nimport { DataTableColumnCellTreeToggle } from './components/columns/tree.directive';\nimport { DatatableFooterDirective } from './components/footer/footer.directive';\nimport { DatatableGroupHeaderTemplateDirective } from './components/body/body-group-header-template.directive';\nimport { DataTableSummaryRowComponent } from './components/body/summary/summary-row.component';\n\n@NgModule({\n  imports: [CommonModule],\n  providers: [ScrollbarHelper, DimensionsHelper, ColumnChangesService],\n  declarations: [\n    DataTableFooterTemplateDirective,\n    VisibilityDirective,\n    DraggableDirective,\n    ResizeableDirective,\n    OrderableDirective,\n    LongPressDirective,\n    ScrollerComponent,\n    DatatableComponent,\n    DataTableColumnDirective,\n    DataTableHeaderComponent,\n    DataTableHeaderCellComponent,\n    DataTableBodyComponent,\n    DataTableFooterComponent,\n    DataTablePagerComponent,\n    ProgressBarComponent,\n    DataTableBodyRowComponent,\n    DataTableRowWrapperComponent,\n    DatatableRowDetailDirective,\n    DatatableGroupHeaderDirective,\n    DatatableRowDetailTemplateDirective,\n    DataTableBodyCellComponent,\n    DataTableSelectionComponent,\n    DataTableColumnHeaderDirective,\n    DataTableColumnCellDirective,\n    DataTableColumnCellTreeToggle,\n    DatatableFooterDirective,\n    DatatableGroupHeaderTemplateDirective,\n    DataTableSummaryRowComponent\n  ],\n  exports: [\n    DatatableComponent,\n    DatatableRowDetailDirective,\n    DatatableGroupHeaderDirective,\n    DatatableRowDetailTemplateDirective,\n    DataTableColumnDirective,\n    DataTableColumnHeaderDirective,\n    DataTableColumnCellDirective,\n    DataTableColumnCellTreeToggle,\n    DataTableFooterTemplateDirective,\n    DatatableFooterDirective,\n    DataTablePagerComponent,\n    DatatableGroupHeaderTemplateDirective\n  ]\n})\nexport class NgxDatatableModule {\n  /**\n   * Configure global configuration via INgxDatatableConfig\n   * @param configuration\n   */\n  static forRoot(configuration: INgxDatatableConfig): ModuleWithProviders<NgxDatatableModule> {\n    return {\n      ngModule: NgxDatatableModule,\n      providers: [{ provide: 'configuration', useValue: configuration }]\n    };\n  }\n}\n\n/**\n * Interface definition for INgxDatatableConfig global configuration\n */\nexport interface INgxDatatableConfig {\n  messages: {\n    emptyMessage: string; // Message to show when array is presented, but contains no values\n    totalMessage: string; // Footer total message\n    selectedMessage: string; // Footer selected message\n  };\n}\n"]}