@swimlane/ngx-datatable 20.0.0 → 20.1.0

package/esm2020/lib/components/header/header.component.mjs

@@ -0,0 +1,376 @@
+import { Component, Output, EventEmitter, Input, HostBinding, ChangeDetectionStrategy } from '@angular/core';
+import { columnsByPin, columnGroupWidths, columnsByPinArr } from '../../utils/column';
+import { SortType } from '../../types/sort.type';
+import { translateXY } from '../../utils/translate';
+import * as i0 from "@angular/core";
+import * as i1 from "./header-cell.component";
+import * as i2 from "../../directives/orderable.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "../../directives/resizeable.directive";
+import * as i5 from "../../directives/long-press.directive";
+import * as i6 from "../../directives/draggable.directive";
+export class DataTableHeaderComponent {
+    constructor(cd) {
+        this.cd = cd;
+        this.sort = new EventEmitter();
+        this.reorder = new EventEmitter();
+        this.resize = new EventEmitter();
+        this.select = new EventEmitter();
+        this.columnContextmenu = new EventEmitter(false);
+        this._columnGroupWidths = {
+            total: 100
+        };
+        this._styleByGroup = {
+            left: {},
+            center: {},
+            right: {}
+        };
+        this.destroyed = false;
+    }
+    set innerWidth(val) {
+        this._innerWidth = val;
+        setTimeout(() => {
+            if (this._columns) {
+                const colByPin = columnsByPin(this._columns);
+                this._columnGroupWidths = columnGroupWidths(colByPin, this._columns);
+                this.setStylesByGroup();
+            }
+        });
+    }
+    get innerWidth() {
+        return this._innerWidth;
+    }
+    set headerHeight(val) {
+        if (val !== 'auto') {
+            this._headerHeight = `${val}px`;
+        }
+        else {
+            this._headerHeight = val;
+        }
+    }
+    get headerHeight() {
+        return this._headerHeight;
+    }
+    set columns(val) {
+        this._columns = val;
+        const colsByPin = columnsByPin(val);
+        this._columnsByPin = columnsByPinArr(val);
+        setTimeout(() => {
+            this._columnGroupWidths = columnGroupWidths(colsByPin, val);
+            this.setStylesByGroup();
+        });
+    }
+    get columns() {
+        return this._columns;
+    }
+    set offsetX(val) {
+        this._offsetX = val;
+        this.setStylesByGroup();
+    }
+    get offsetX() {
+        return this._offsetX;
+    }
+    ngOnDestroy() {
+        this.destroyed = true;
+    }
+    onLongPressStart({ event, model }) {
+        model.dragging = true;
+        this.dragEventTarget = event;
+    }
+    onLongPressEnd({ event, model }) {
+        this.dragEventTarget = event;
+        // delay resetting so sort can be
+        // prevented if we were dragging
+        setTimeout(() => {
+            // datatable component creates copies from columns on reorder
+            // set dragging to false on new objects
+            const column = this._columns.find(c => c.$$id === model.$$id);
+            if (column) {
+                column.dragging = false;
+            }
+        }, 5);
+    }
+    get headerWidth() {
+        if (this.scrollbarH) {
+            return this.innerWidth + 'px';
+        }
+        return '100%';
+    }
+    trackByGroups(index, colGroup) {
+        return colGroup.type;
+    }
+    columnTrackingFn(index, column) {
+        return column.$$id;
+    }
+    onColumnResized(width, column) {
+        if (width <= column.minWidth) {
+            width = column.minWidth;
+        }
+        else if (width >= column.maxWidth) {
+            width = column.maxWidth;
+        }
+        this.resize.emit({
+            column,
+            prevValue: column.width,
+            newValue: width
+        });
+    }
+    onColumnReordered({ prevIndex, newIndex, model }) {
+        const column = this.getColumn(newIndex);
+        column.isTarget = false;
+        column.targetMarkerContext = undefined;
+        this.reorder.emit({
+            column: model,
+            prevValue: prevIndex,
+            newValue: newIndex
+        });
+    }
+    onTargetChanged({ prevIndex, newIndex, initialIndex }) {
+        if (prevIndex || prevIndex === 0) {
+            const oldColumn = this.getColumn(prevIndex);
+            oldColumn.isTarget = false;
+            oldColumn.targetMarkerContext = undefined;
+        }
+        if (newIndex || newIndex === 0) {
+            const newColumn = this.getColumn(newIndex);
+            newColumn.isTarget = true;
+            if (initialIndex !== newIndex) {
+                newColumn.targetMarkerContext = {
+                    class: 'targetMarker '.concat(initialIndex > newIndex ? 'dragFromRight' : 'dragFromLeft')
+                };
+            }
+        }
+    }
+    getColumn(index) {
+        const leftColumnCount = this._columnsByPin[0].columns.length;
+        if (index < leftColumnCount) {
+            return this._columnsByPin[0].columns[index];
+        }
+        const centerColumnCount = this._columnsByPin[1].columns.length;
+        if (index < leftColumnCount + centerColumnCount) {
+            return this._columnsByPin[1].columns[index - leftColumnCount];
+        }
+        return this._columnsByPin[2].columns[index - leftColumnCount - centerColumnCount];
+    }
+    onSort({ column, prevValue, newValue }) {
+        // if we are dragging don't sort!
+        if (column.dragging) {
+            return;
+        }
+        const sorts = this.calcNewSorts(column, prevValue, newValue);
+        this.sort.emit({
+            sorts,
+            column,
+            prevValue,
+            newValue
+        });
+    }
+    calcNewSorts(column, prevValue, newValue) {
+        let idx = 0;
+        if (!this.sorts) {
+            this.sorts = [];
+        }
+        const sorts = this.sorts.map((s, i) => {
+            s = { ...s };
+            if (s.prop === column.prop) {
+                idx = i;
+            }
+            return s;
+        });
+        if (newValue === undefined) {
+            sorts.splice(idx, 1);
+        }
+        else if (prevValue) {
+            sorts[idx].dir = newValue;
+        }
+        else {
+            if (this.sortType === SortType.single) {
+                sorts.splice(0, this.sorts.length);
+            }
+            sorts.push({ dir: newValue, prop: column.prop });
+        }
+        return sorts;
+    }
+    setStylesByGroup() {
+        this._styleByGroup.left = this.calcStylesByGroup('left');
+        this._styleByGroup.center = this.calcStylesByGroup('center');
+        this._styleByGroup.right = this.calcStylesByGroup('right');
+        if (!this.destroyed) {
+            this.cd.detectChanges();
+        }
+    }
+    calcStylesByGroup(group) {
+        const widths = this._columnGroupWidths;
+        const offsetX = this.offsetX;
+        const styles = {
+            width: `${widths[group]}px`
+        };
+        if (group === 'center') {
+            translateXY(styles, offsetX * -1, 0);
+        }
+        else if (group === 'right') {
+            const totalDiff = widths.total - this.innerWidth;
+            const offset = totalDiff * -1;
+            translateXY(styles, offset, 0);
+        }
+        return styles;
+    }
+}
+DataTableHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableHeaderComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+DataTableHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: DataTableHeaderComponent, selector: "datatable-header", inputs: { sortAscendingIcon: "sortAscendingIcon", sortDescendingIcon: "sortDescendingIcon", sortUnsetIcon: "sortUnsetIcon", scrollbarH: "scrollbarH", dealsWithGroup: "dealsWithGroup", targetMarkerTemplate: "targetMarkerTemplate", innerWidth: "innerWidth", sorts: "sorts", sortType: "sortType", allRowsSelected: "allRowsSelected", selectionType: "selectionType", reorderable: "reorderable", headerHeight: "headerHeight", columns: "columns", offsetX: "offsetX" }, outputs: { sort: "sort", reorder: "reorder", resize: "resize", select: "select", columnContextmenu: "columnContextmenu" }, host: { properties: { "style.height": "this.headerHeight", "style.width": "this.headerWidth" }, classAttribute: "datatable-header" }, ngImport: i0, template: `
+    <div
+      role="row"
+      orderable
+      (reorder)="onColumnReordered($event)"
+      (targetChanged)="onTargetChanged($event)"
+      [style.width.px]="_columnGroupWidths.total"
+      class="datatable-header-inner"
+    >
+      <div
+        *ngFor="let colGroup of _columnsByPin; trackBy: trackByGroups"
+        [class]="'datatable-row-' + colGroup.type"
+        [ngStyle]="_styleByGroup[colGroup.type]"
+      >
+        <datatable-header-cell
+          role="columnheader"
+          *ngFor="let column of colGroup.columns; trackBy: columnTrackingFn"
+          resizeable
+          [resizeEnabled]="column.resizeable"
+          (resize)="onColumnResized($event, column)"
+          long-press
+          [pressModel]="column"
+          [pressEnabled]="reorderable && column.draggable"
+          (longPressStart)="onLongPressStart($event)"
+          (longPressEnd)="onLongPressEnd($event)"
+          draggable
+          [dragX]="reorderable && column.draggable && column.dragging"
+          [dragY]="false"
+          [dragModel]="column"
+          [dragEventTarget]="dragEventTarget"
+          [headerHeight]="headerHeight"
+          [isTarget]="column.isTarget"
+          [targetMarkerTemplate]="targetMarkerTemplate"
+          [targetMarkerContext]="column.targetMarkerContext"
+          [column]="column"
+          [sortType]="sortType"
+          [sorts]="sorts"
+          [selectionType]="selectionType"
+          [sortAscendingIcon]="sortAscendingIcon"
+          [sortDescendingIcon]="sortDescendingIcon"
+          [sortUnsetIcon]="sortUnsetIcon"
+          [allRowsSelected]="allRowsSelected"
+          (sort)="onSort($event)"
+          (select)="select.emit($event)"
+          (columnContextmenu)="columnContextmenu.emit($event)"
+        >
+        </datatable-header-cell>
+      </div>
+    </div>
+  `, isInline: true, components: [{ type: i1.DataTableHeaderCellComponent, selector: "datatable-header-cell", inputs: ["sortType", "sortAscendingIcon", "sortDescendingIcon", "sortUnsetIcon", "isTarget", "targetMarkerTemplate", "targetMarkerContext", "allRowsSelected", "selectionType", "column", "headerHeight", "sorts"], outputs: ["sort", "select", "columnContextmenu"] }], directives: [{ type: i2.OrderableDirective, selector: "[orderable]", outputs: ["reorder", "targetChanged"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i4.ResizeableDirective, selector: "[resizeable]", inputs: ["resizeEnabled", "minWidth", "maxWidth"], outputs: ["resize"] }, { type: i5.LongPressDirective, selector: "[long-press]", inputs: ["pressEnabled", "pressModel", "duration"], outputs: ["longPressStart", "longPressing", "longPressEnd"] }, { type: i6.DraggableDirective, selector: "[draggable]", inputs: ["dragEventTarget", "dragModel", "dragX", "dragY"], outputs: ["dragStart", "dragging", "dragEnd"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-header',
+                    template: `
+    <div
+      role="row"
+      orderable
+      (reorder)="onColumnReordered($event)"
+      (targetChanged)="onTargetChanged($event)"
+      [style.width.px]="_columnGroupWidths.total"
+      class="datatable-header-inner"
+    >
+      <div
+        *ngFor="let colGroup of _columnsByPin; trackBy: trackByGroups"
+        [class]="'datatable-row-' + colGroup.type"
+        [ngStyle]="_styleByGroup[colGroup.type]"
+      >
+        <datatable-header-cell
+          role="columnheader"
+          *ngFor="let column of colGroup.columns; trackBy: columnTrackingFn"
+          resizeable
+          [resizeEnabled]="column.resizeable"
+          (resize)="onColumnResized($event, column)"
+          long-press
+          [pressModel]="column"
+          [pressEnabled]="reorderable && column.draggable"
+          (longPressStart)="onLongPressStart($event)"
+          (longPressEnd)="onLongPressEnd($event)"
+          draggable
+          [dragX]="reorderable && column.draggable && column.dragging"
+          [dragY]="false"
+          [dragModel]="column"
+          [dragEventTarget]="dragEventTarget"
+          [headerHeight]="headerHeight"
+          [isTarget]="column.isTarget"
+          [targetMarkerTemplate]="targetMarkerTemplate"
+          [targetMarkerContext]="column.targetMarkerContext"
+          [column]="column"
+          [sortType]="sortType"
+          [sorts]="sorts"
+          [selectionType]="selectionType"
+          [sortAscendingIcon]="sortAscendingIcon"
+          [sortDescendingIcon]="sortDescendingIcon"
+          [sortUnsetIcon]="sortUnsetIcon"
+          [allRowsSelected]="allRowsSelected"
+          (sort)="onSort($event)"
+          (select)="select.emit($event)"
+          (columnContextmenu)="columnContextmenu.emit($event)"
+        >
+        </datatable-header-cell>
+      </div>
+    </div>
+  `,
+                    host: {
+                        class: 'datatable-header'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { sortAscendingIcon: [{
+                type: Input
+            }], sortDescendingIcon: [{
+                type: Input
+            }], sortUnsetIcon: [{
+                type: Input
+            }], scrollbarH: [{
+                type: Input
+            }], dealsWithGroup: [{
+                type: Input
+            }], targetMarkerTemplate: [{
+                type: Input
+            }], innerWidth: [{
+                type: Input
+            }], sorts: [{
+                type: Input
+            }], sortType: [{
+                type: Input
+            }], allRowsSelected: [{
+                type: Input
+            }], selectionType: [{
+                type: Input
+            }], reorderable: [{
+                type: Input
+            }], headerHeight: [{
+                type: HostBinding,
+                args: ['style.height']
+            }, {
+                type: Input
+            }], columns: [{
+                type: Input
+            }], offsetX: [{
+                type: Input
+            }], sort: [{
+                type: Output
+            }], reorder: [{
+                type: Output
+            }], resize: [{
+                type: Output
+            }], select: [{
+                type: Output
+            }], columnContextmenu: [{
+                type: Output
+            }], headerWidth: [{
+                type: HostBinding,
+                args: ['style.width']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header.component.js","sourceRoot":"","sources":["../../../../../../../projects/swimlane/ngx-datatable/src/lib/components/header/header.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Output,\n  EventEmitter,\n  Input,\n  HostBinding,\n  ChangeDetectorRef,\n  ChangeDetectionStrategy,\n  OnDestroy\n} from '@angular/core';\nimport { columnsByPin, columnGroupWidths, columnsByPinArr } from '../../utils/column';\nimport { SortType } from '../../types/sort.type';\nimport { SelectionType } from '../../types/selection.type';\nimport { DataTableColumnDirective } from '../columns/column.directive';\nimport { translateXY } from '../../utils/translate';\n\n@Component({\n  selector: 'datatable-header',\n  template: `\n    <div\n      role=\"row\"\n      orderable\n      (reorder)=\"onColumnReordered($event)\"\n      (targetChanged)=\"onTargetChanged($event)\"\n      [style.width.px]=\"_columnGroupWidths.total\"\n      class=\"datatable-header-inner\"\n    >\n      <div\n        *ngFor=\"let colGroup of _columnsByPin; trackBy: trackByGroups\"\n        [class]=\"'datatable-row-' + colGroup.type\"\n        [ngStyle]=\"_styleByGroup[colGroup.type]\"\n      >\n        <datatable-header-cell\n          role=\"columnheader\"\n          *ngFor=\"let column of colGroup.columns; trackBy: columnTrackingFn\"\n          resizeable\n          [resizeEnabled]=\"column.resizeable\"\n          (resize)=\"onColumnResized($event, column)\"\n          long-press\n          [pressModel]=\"column\"\n          [pressEnabled]=\"reorderable && column.draggable\"\n          (longPressStart)=\"onLongPressStart($event)\"\n          (longPressEnd)=\"onLongPressEnd($event)\"\n          draggable\n          [dragX]=\"reorderable && column.draggable && column.dragging\"\n          [dragY]=\"false\"\n          [dragModel]=\"column\"\n          [dragEventTarget]=\"dragEventTarget\"\n          [headerHeight]=\"headerHeight\"\n          [isTarget]=\"column.isTarget\"\n          [targetMarkerTemplate]=\"targetMarkerTemplate\"\n          [targetMarkerContext]=\"column.targetMarkerContext\"\n          [column]=\"column\"\n          [sortType]=\"sortType\"\n          [sorts]=\"sorts\"\n          [selectionType]=\"selectionType\"\n          [sortAscendingIcon]=\"sortAscendingIcon\"\n          [sortDescendingIcon]=\"sortDescendingIcon\"\n          [sortUnsetIcon]=\"sortUnsetIcon\"\n          [allRowsSelected]=\"allRowsSelected\"\n          (sort)=\"onSort($event)\"\n          (select)=\"select.emit($event)\"\n          (columnContextmenu)=\"columnContextmenu.emit($event)\"\n        >\n        </datatable-header-cell>\n      </div>\n    </div>\n  `,\n  host: {\n    class: 'datatable-header'\n  },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DataTableHeaderComponent implements OnDestroy {\n  @Input() sortAscendingIcon: any;\n  @Input() sortDescendingIcon: any;\n  @Input() sortUnsetIcon: any;\n  @Input() scrollbarH: boolean;\n  @Input() dealsWithGroup: boolean;\n  @Input() targetMarkerTemplate: any;\n\n  targetMarkerContext: any;\n\n  @Input() set innerWidth(val: number) {\n    this._innerWidth = val;\n    setTimeout(() => {\n      if (this._columns) {\n        const colByPin = columnsByPin(this._columns);\n        this._columnGroupWidths = columnGroupWidths(colByPin, this._columns);\n        this.setStylesByGroup();\n      }\n    });\n  }\n\n  get innerWidth(): number {\n    return this._innerWidth;\n  }\n\n  @Input() sorts: any[];\n  @Input() sortType: SortType;\n  @Input() allRowsSelected: boolean;\n  @Input() selectionType: SelectionType;\n  @Input() reorderable: boolean;\n\n  dragEventTarget: any;\n\n  @HostBinding('style.height')\n  @Input()\n  set headerHeight(val: any) {\n    if (val !== 'auto') {\n      this._headerHeight = `${val}px`;\n    } else {\n      this._headerHeight = val;\n    }\n  }\n\n  get headerHeight(): any {\n    return this._headerHeight;\n  }\n\n  @Input() set columns(val: any[]) {\n    this._columns = val;\n\n    const colsByPin = columnsByPin(val);\n    this._columnsByPin = columnsByPinArr(val);\n    setTimeout(() => {\n      this._columnGroupWidths = columnGroupWidths(colsByPin, val);\n      this.setStylesByGroup();\n    });\n  }\n\n  get columns(): any[] {\n    return this._columns;\n  }\n\n  @Input()\n  set offsetX(val: number) {\n    this._offsetX = val;\n    this.setStylesByGroup();\n  }\n  get offsetX() {\n    return this._offsetX;\n  }\n\n  @Output() sort: EventEmitter<any> = new EventEmitter();\n  @Output() reorder: EventEmitter<any> = new EventEmitter();\n  @Output() resize: EventEmitter<any> = new EventEmitter();\n  @Output() select: EventEmitter<any> = new EventEmitter();\n  @Output() columnContextmenu = new EventEmitter<{ event: MouseEvent; column: any }>(false);\n\n  _columnsByPin: any;\n  _columnGroupWidths: any = {\n    total: 100\n  };\n  _innerWidth: number;\n  _offsetX: number;\n  _columns: any[];\n  _headerHeight: string;\n  _styleByGroup: { [prop: string]: {} } = {\n    left: {},\n    center: {},\n    right: {}\n  };\n\n  private destroyed = false;\n\n  constructor(private cd: ChangeDetectorRef) {}\n\n  ngOnDestroy(): void {\n    this.destroyed = true;\n  }\n\n  onLongPressStart({ event, model }: { event: any; model: any }) {\n    model.dragging = true;\n    this.dragEventTarget = event;\n  }\n\n  onLongPressEnd({ event, model }: { event: any; model: any }) {\n    this.dragEventTarget = event;\n\n    // delay resetting so sort can be\n    // prevented if we were dragging\n    setTimeout(() => {\n      // datatable component creates copies from columns on reorder\n      // set dragging to false on new objects\n      const column = this._columns.find(c => c.$$id === model.$$id);\n      if (column) {\n        column.dragging = false;\n      }\n    }, 5);\n  }\n\n  @HostBinding('style.width')\n  get headerWidth(): string {\n    if (this.scrollbarH) {\n      return this.innerWidth + 'px';\n    }\n\n    return '100%';\n  }\n\n  trackByGroups(index: number, colGroup: any): any {\n    return colGroup.type;\n  }\n\n  columnTrackingFn(index: number, column: any): any {\n    return column.$$id;\n  }\n\n  onColumnResized(width: number, column: DataTableColumnDirective): void {\n    if (width <= column.minWidth) {\n      width = column.minWidth;\n    } else if (width >= column.maxWidth) {\n      width = column.maxWidth;\n    }\n\n    this.resize.emit({\n      column,\n      prevValue: column.width,\n      newValue: width\n    });\n  }\n\n  onColumnReordered({ prevIndex, newIndex, model }: any): void {\n    const column = this.getColumn(newIndex);\n    column.isTarget = false;\n    column.targetMarkerContext = undefined;\n    this.reorder.emit({\n      column: model,\n      prevValue: prevIndex,\n      newValue: newIndex\n    });\n  }\n\n  onTargetChanged({ prevIndex, newIndex, initialIndex }: any): void {\n    if (prevIndex || prevIndex === 0) {\n      const oldColumn = this.getColumn(prevIndex);\n      oldColumn.isTarget = false;\n      oldColumn.targetMarkerContext = undefined;\n    }\n    if (newIndex || newIndex === 0) {\n      const newColumn = this.getColumn(newIndex);\n      newColumn.isTarget = true;\n\n      if (initialIndex !== newIndex) {\n        newColumn.targetMarkerContext = {\n          class: 'targetMarker '.concat(initialIndex > newIndex ? 'dragFromRight' : 'dragFromLeft')\n        };\n      }\n    }\n  }\n\n  getColumn(index: number): any {\n    const leftColumnCount = this._columnsByPin[0].columns.length;\n    if (index < leftColumnCount) {\n      return this._columnsByPin[0].columns[index];\n    }\n\n    const centerColumnCount = this._columnsByPin[1].columns.length;\n    if (index < leftColumnCount + centerColumnCount) {\n      return this._columnsByPin[1].columns[index - leftColumnCount];\n    }\n\n    return this._columnsByPin[2].columns[index - leftColumnCount - centerColumnCount];\n  }\n\n  onSort({ column, prevValue, newValue }: any): void {\n    // if we are dragging don't sort!\n    if (column.dragging) {\n      return;\n    }\n\n    const sorts = this.calcNewSorts(column, prevValue, newValue);\n    this.sort.emit({\n      sorts,\n      column,\n      prevValue,\n      newValue\n    });\n  }\n\n  calcNewSorts(column: any, prevValue: number, newValue: number): any[] {\n    let idx = 0;\n\n    if (!this.sorts) {\n      this.sorts = [];\n    }\n\n    const sorts = this.sorts.map((s, i) => {\n      s = { ...s };\n      if (s.prop === column.prop) {\n        idx = i;\n      }\n      return s;\n    });\n\n    if (newValue === undefined) {\n      sorts.splice(idx, 1);\n    } else if (prevValue) {\n      sorts[idx].dir = newValue;\n    } else {\n      if (this.sortType === SortType.single) {\n        sorts.splice(0, this.sorts.length);\n      }\n\n      sorts.push({ dir: newValue, prop: column.prop });\n    }\n\n    return sorts;\n  }\n\n  setStylesByGroup() {\n    this._styleByGroup.left = this.calcStylesByGroup('left');\n    this._styleByGroup.center = this.calcStylesByGroup('center');\n    this._styleByGroup.right = this.calcStylesByGroup('right');\n    if (!this.destroyed) {\n      this.cd.detectChanges();\n    }\n  }\n\n  calcStylesByGroup(group: string): any {\n    const widths = this._columnGroupWidths;\n    const offsetX = this.offsetX;\n\n    const styles = {\n      width: `${widths[group]}px`\n    };\n\n    if (group === 'center') {\n      translateXY(styles, offsetX * -1, 0);\n    } else if (group === 'right') {\n      const totalDiff = widths.total - this.innerWidth;\n      const offset = totalDiff * -1;\n      translateXY(styles, offset, 0);\n    }\n\n    return styles;\n  }\n}\n"]}

package/esm2020/lib/components/row-detail/row-detail-template.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DatatableRowDetailTemplateDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+DatatableRowDetailTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DatatableRowDetailTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DatatableRowDetailTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DatatableRowDetailTemplateDirective, selector: "[ngx-datatable-row-detail-template]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DatatableRowDetailTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngx-datatable-row-detail-template]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LWRldGFpbC10ZW1wbGF0ZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zd2ltbGFuZS9uZ3gtZGF0YXRhYmxlL3NyYy9saWIvY29tcG9uZW50cy9yb3ctZGV0YWlsL3Jvdy1kZXRhaWwtdGVtcGxhdGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWUsTUFBTSxlQUFlLENBQUM7O0FBS3ZELE1BQU0sT0FBTyxtQ0FBbUM7SUFDOUMsWUFBbUIsUUFBMEI7UUFBMUIsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7SUFBRyxDQUFDOztnSUFEdEMsbUNBQW1DO29IQUFuQyxtQ0FBbUM7MkZBQW5DLG1DQUFtQztrQkFIL0MsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUscUNBQXFDO2lCQUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW25neC1kYXRhdGFibGUtcm93LWRldGFpbC10ZW1wbGF0ZV0nXG59KVxuZXhwb3J0IGNsYXNzIERhdGF0YWJsZVJvd0RldGFpbFRlbXBsYXRlRGlyZWN0aXZlIHtcbiAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+KSB7fVxufVxuIl19

package/esm2020/lib/components/row-detail/row-detail.directive.mjs

@@ -0,0 +1,63 @@
+import { Input, Output, EventEmitter, Directive, TemplateRef, ContentChild } from '@angular/core';
+import { DatatableRowDetailTemplateDirective } from './row-detail-template.directive';
+import * as i0 from "@angular/core";
+export class DatatableRowDetailDirective {
+    constructor() {
+        /**
+         * The detail row height is required especially
+         * when virtual scroll is enabled.
+         */
+        this.rowHeight = 0;
+        /**
+         * Row detail row visbility was toggled.
+         */
+        this.toggle = new EventEmitter();
+    }
+    get template() {
+        return this._templateInput || this._templateQuery;
+    }
+    /**
+     * Toggle the expansion of the row
+     */
+    toggleExpandRow(row) {
+        this.toggle.emit({
+            type: 'row',
+            value: row
+        });
+    }
+    /**
+     * API method to expand all the rows.
+     */
+    expandAllRows() {
+        this.toggle.emit({
+            type: 'all',
+            value: true
+        });
+    }
+    /**
+     * API method to collapse all the rows.
+     */
+    collapseAllRows() {
+        this.toggle.emit({
+            type: 'all',
+            value: false
+        });
+    }
+}
+DatatableRowDetailDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DatatableRowDetailDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DatatableRowDetailDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DatatableRowDetailDirective, selector: "ngx-datatable-row-detail", inputs: { rowHeight: "rowHeight", _templateInput: ["template", "_templateInput"] }, outputs: { toggle: "toggle" }, queries: [{ propertyName: "_templateQuery", first: true, predicate: DatatableRowDetailTemplateDirective, descendants: true, read: TemplateRef, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DatatableRowDetailDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngx-datatable-row-detail' }]
+        }], propDecorators: { rowHeight: [{
+                type: Input
+            }], _templateInput: [{
+                type: Input,
+                args: ['template']
+            }], _templateQuery: [{
+                type: ContentChild,
+                args: [DatatableRowDetailTemplateDirective, { read: TemplateRef, static: true }]
+            }], toggle: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LWRldGFpbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zd2ltbGFuZS9uZ3gtZGF0YXRhYmxlL3NyYy9saWIvY29tcG9uZW50cy9yb3ctZGV0YWlsL3Jvdy1kZXRhaWwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRyxPQUFPLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQzs7QUFHdEYsTUFBTSxPQUFPLDJCQUEyQjtJQUR4QztRQUVFOzs7V0FHRztRQUNNLGNBQVMsR0FBcUQsQ0FBQyxDQUFDO1FBWXpFOztXQUVHO1FBQ08sV0FBTSxHQUFzQixJQUFJLFlBQVksRUFBRSxDQUFDO0tBK0IxRDtJQXRDQyxJQUFJLFFBQVE7UUFDVixPQUFPLElBQUksQ0FBQyxjQUFjLElBQUksSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUNwRCxDQUFDO0lBT0Q7O09BRUc7SUFDSCxlQUFlLENBQUMsR0FBUTtRQUN0QixJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQztZQUNmLElBQUksRUFBRSxLQUFLO1lBQ1gsS0FBSyxFQUFFLEdBQUc7U0FDWCxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxhQUFhO1FBQ1gsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUM7WUFDZixJQUFJLEVBQUUsS0FBSztZQUNYLEtBQUssRUFBRSxJQUFJO1NBQ1osQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsZUFBZTtRQUNiLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDO1lBQ2YsSUFBSSxFQUFFLEtBQUs7WUFDWCxLQUFLLEVBQUUsS0FBSztTQUNiLENBQUMsQ0FBQztJQUNMLENBQUM7O3dIQWxEVSwyQkFBMkI7NEdBQTNCLDJCQUEyQiwrTkFVeEIsbUNBQW1DLDJCQUFVLFdBQVc7MkZBVjNELDJCQUEyQjtrQkFEdkMsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSwwQkFBMEIsRUFBRTs4QkFNeEMsU0FBUztzQkFBakIsS0FBSztnQkFHTixjQUFjO3NCQURiLEtBQUs7dUJBQUMsVUFBVTtnQkFJakIsY0FBYztzQkFEYixZQUFZO3VCQUFDLG1DQUFtQyxFQUFFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFO2dCQVU1RSxNQUFNO3NCQUFmLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnB1dCwgT3V0cHV0LCBFdmVudEVtaXR0ZXIsIERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYsIENvbnRlbnRDaGlsZCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRGF0YXRhYmxlUm93RGV0YWlsVGVtcGxhdGVEaXJlY3RpdmUgfSBmcm9tICcuL3Jvdy1kZXRhaWwtdGVtcGxhdGUuZGlyZWN0aXZlJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnbmd4LWRhdGF0YWJsZS1yb3ctZGV0YWlsJyB9KVxuZXhwb3J0IGNsYXNzIERhdGF0YWJsZVJvd0RldGFpbERpcmVjdGl2ZSB7XG4gIC8qKlxuICAgKiBUaGUgZGV0YWlsIHJvdyBoZWlnaHQgaXMgcmVxdWlyZWQgZXNwZWNpYWxseVxuICAgKiB3aGVuIHZpcnR1YWwgc2Nyb2xsIGlzIGVuYWJsZWQuXG4gICAqL1xuICBASW5wdXQoKSByb3dIZWlnaHQ6IG51bWJlciB8ICgocm93PzogYW55LCBpbmRleD86IG51bWJlcikgPT4gbnVtYmVyKSA9IDA7XG5cbiAgQElucHV0KCd0ZW1wbGF0ZScpXG4gIF90ZW1wbGF0ZUlucHV0OiBUZW1wbGF0ZVJlZjxhbnk+O1xuXG4gIEBDb250ZW50Q2hpbGQoRGF0YXRhYmxlUm93RGV0YWlsVGVtcGxhdGVEaXJlY3RpdmUsIHsgcmVhZDogVGVtcGxhdGVSZWYsIHN0YXRpYzogdHJ1ZSB9KVxuICBfdGVtcGxhdGVRdWVyeTogVGVtcGxhdGVSZWY8YW55PjtcblxuICBnZXQgdGVtcGxhdGUoKTogVGVtcGxhdGVSZWY8YW55PiB7XG4gICAgcmV0dXJuIHRoaXMuX3RlbXBsYXRlSW5wdXQgfHwgdGhpcy5fdGVtcGxhdGVRdWVyeTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSb3cgZGV0YWlsIHJvdyB2aXNiaWxpdHkgd2FzIHRvZ2dsZWQuXG4gICAqL1xuICBAT3V0cHV0KCkgdG9nZ2xlOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcblxuICAvKipcbiAgICogVG9nZ2xlIHRoZSBleHBhbnNpb24gb2YgdGhlIHJvd1xuICAgKi9cbiAgdG9nZ2xlRXhwYW5kUm93KHJvdzogYW55KTogdm9pZCB7XG4gICAgdGhpcy50b2dnbGUuZW1pdCh7XG4gICAgICB0eXBlOiAncm93JyxcbiAgICAgIHZhbHVlOiByb3dcbiAgICB9KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBBUEkgbWV0aG9kIHRvIGV4cGFuZCBhbGwgdGhlIHJvd3MuXG4gICAqL1xuICBleHBhbmRBbGxSb3dzKCk6IHZvaWQge1xuICAgIHRoaXMudG9nZ2xlLmVtaXQoe1xuICAgICAgdHlwZTogJ2FsbCcsXG4gICAgICB2YWx1ZTogdHJ1ZVxuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIEFQSSBtZXRob2QgdG8gY29sbGFwc2UgYWxsIHRoZSByb3dzLlxuICAgKi9cbiAgY29sbGFwc2VBbGxSb3dzKCk6IHZvaWQge1xuICAgIHRoaXMudG9nZ2xlLmVtaXQoe1xuICAgICAgdHlwZTogJ2FsbCcsXG4gICAgICB2YWx1ZTogZmFsc2VcbiAgICB9KTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,108 @@
+import { Directive, Input, Output, EventEmitter } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Draggable Directive for Angular2
+ *
+ * Inspiration:
+ *   https://github.com/AngularClass/angular2-examples/blob/master/rx-draggable/directives/draggable.ts
+ *   http://stackoverflow.com/questions/35662530/how-to-implement-drag-and-drop-in-angular2
+ *
+ */
+export class DraggableDirective {
+    constructor(element) {
+        this.dragX = true;
+        this.dragY = true;
+        this.dragStart = new EventEmitter();
+        this.dragging = new EventEmitter();
+        this.dragEnd = new EventEmitter();
+        this.isDragging = false;
+        this.element = element.nativeElement;
+    }
+    ngOnChanges(changes) {
+        if (changes['dragEventTarget'] && changes['dragEventTarget'].currentValue && this.dragModel.dragging) {
+            this.onMousedown(changes['dragEventTarget'].currentValue);
+        }
+    }
+    ngOnDestroy() {
+        this._destroySubscription();
+    }
+    onMouseup(event) {
+        if (!this.isDragging)
+            return;
+        this.isDragging = false;
+        this.element.classList.remove('dragging');
+        if (this.subscription) {
+            this._destroySubscription();
+            this.dragEnd.emit({
+                event,
+                element: this.element,
+                model: this.dragModel
+            });
+        }
+    }
+    onMousedown(event) {
+        // we only want to drag the inner header text
+        const isDragElm = event.target.classList.contains('draggable');
+        if (isDragElm && (this.dragX || this.dragY)) {
+            event.preventDefault();
+            this.isDragging = true;
+            const mouseDownPos = { x: event.clientX, y: event.clientY };
+            const mouseup = fromEvent(document, 'mouseup');
+            this.subscription = mouseup.subscribe((ev) => this.onMouseup(ev));
+            const mouseMoveSub = fromEvent(document, 'mousemove')
+                .pipe(takeUntil(mouseup))
+                .subscribe((ev) => this.move(ev, mouseDownPos));
+            this.subscription.add(mouseMoveSub);
+            this.dragStart.emit({
+                event,
+                element: this.element,
+                model: this.dragModel
+            });
+        }
+    }
+    move(event, mouseDownPos) {
+        if (!this.isDragging)
+            return;
+        const x = event.clientX - mouseDownPos.x;
+        const y = event.clientY - mouseDownPos.y;
+        if (this.dragX)
+            this.element.style.left = `${x}px`;
+        if (this.dragY)
+            this.element.style.top = `${y}px`;
+        this.element.classList.add('dragging');
+        this.dragging.emit({
+            event,
+            element: this.element,
+            model: this.dragModel
+        });
+    }
+    _destroySubscription() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = undefined;
+        }
+    }
+}
+DraggableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DraggableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DraggableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DraggableDirective, selector: "[draggable]", inputs: { dragEventTarget: "dragEventTarget", dragModel: "dragModel", dragX: "dragX", dragY: "dragY" }, outputs: { dragStart: "dragStart", dragging: "dragging", dragEnd: "dragEnd" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DraggableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[draggable]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { dragEventTarget: [{
+                type: Input
+            }], dragModel: [{
+                type: Input
+            }], dragX: [{
+                type: Input
+            }], dragY: [{
+                type: Input
+            }], dragStart: [{
+                type: Output
+            }], dragging: [{
+                type: Output
+            }], dragEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draggable.directive.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/directives/draggable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, Output, EventEmitter, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';\nimport { Subscription, fromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n/**\n * Draggable Directive for Angular2\n *\n * Inspiration:\n *   https://github.com/AngularClass/angular2-examples/blob/master/rx-draggable/directives/draggable.ts\n *   http://stackoverflow.com/questions/35662530/how-to-implement-drag-and-drop-in-angular2\n *\n */\n@Directive({ selector: '[draggable]' })\nexport class DraggableDirective implements OnDestroy, OnChanges {\n  @Input() dragEventTarget: any;\n  @Input() dragModel: any;\n  @Input() dragX: boolean = true;\n  @Input() dragY: boolean = true;\n\n  @Output() dragStart: EventEmitter<any> = new EventEmitter();\n  @Output() dragging: EventEmitter<any> = new EventEmitter();\n  @Output() dragEnd: EventEmitter<any> = new EventEmitter();\n\n  element: HTMLElement;\n  isDragging: boolean = false;\n  subscription: Subscription;\n\n  constructor(element: ElementRef) {\n    this.element = element.nativeElement;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['dragEventTarget'] && changes['dragEventTarget'].currentValue && this.dragModel.dragging) {\n      this.onMousedown(changes['dragEventTarget'].currentValue);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._destroySubscription();\n  }\n\n  onMouseup(event: MouseEvent): void {\n    if (!this.isDragging) return;\n\n    this.isDragging = false;\n    this.element.classList.remove('dragging');\n\n    if (this.subscription) {\n      this._destroySubscription();\n      this.dragEnd.emit({\n        event,\n        element: this.element,\n        model: this.dragModel\n      });\n    }\n  }\n\n  onMousedown(event: MouseEvent): void {\n    // we only want to drag the inner header text\n    const isDragElm = (<HTMLElement>event.target).classList.contains('draggable');\n\n    if (isDragElm && (this.dragX || this.dragY)) {\n      event.preventDefault();\n      this.isDragging = true;\n\n      const mouseDownPos = { x: event.clientX, y: event.clientY };\n\n      const mouseup = fromEvent(document, 'mouseup');\n      this.subscription = mouseup.subscribe((ev: MouseEvent) => this.onMouseup(ev));\n\n      const mouseMoveSub = fromEvent(document, 'mousemove')\n        .pipe(takeUntil(mouseup))\n        .subscribe((ev: MouseEvent) => this.move(ev, mouseDownPos));\n\n      this.subscription.add(mouseMoveSub);\n\n      this.dragStart.emit({\n        event,\n        element: this.element,\n        model: this.dragModel\n      });\n    }\n  }\n\n  move(event: MouseEvent, mouseDownPos: { x: number; y: number }): void {\n    if (!this.isDragging) return;\n\n    const x = event.clientX - mouseDownPos.x;\n    const y = event.clientY - mouseDownPos.y;\n\n    if (this.dragX) this.element.style.left = `${x}px`;\n    if (this.dragY) this.element.style.top = `${y}px`;\n\n    this.element.classList.add('dragging');\n\n    this.dragging.emit({\n      event,\n      element: this.element,\n      model: this.dragModel\n    });\n  }\n\n  private _destroySubscription(): void {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      this.subscription = undefined;\n    }\n  }\n}\n"]}