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

package/esm2020/lib/components/body/progress-bar.component.mjs

@@ -0,0 +1,27 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProgressBarComponent {
+}
+ProgressBarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ProgressBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ProgressBarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: ProgressBarComponent, selector: "datatable-progress", ngImport: i0, template: `
+    <div class="progress-linear" role="progressbar">
+      <div class="container">
+        <div class="bar"></div>
+      </div>
+    </div>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ProgressBarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-progress',
+                    template: `
+    <div class="progress-linear" role="progressbar">
+      <div class="container">
+        <div class="bar"></div>
+      </div>
+    </div>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MtYmFyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N3aW1sYW5lL25neC1kYXRhdGFibGUvc3JjL2xpYi9jb21wb25lbnRzL2JvZHkvcHJvZ3Jlc3MtYmFyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWFuRSxNQUFNLE9BQU8sb0JBQW9COztpSEFBcEIsb0JBQW9CO3FHQUFwQixvQkFBb0IsMERBVHJCOzs7Ozs7R0FNVDsyRkFHVSxvQkFBb0I7a0JBWGhDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtvQkFDOUIsUUFBUSxFQUFFOzs7Ozs7R0FNVDtvQkFDRCxlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTtpQkFDaEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIENoYW5nZURldGVjdGlvblN0cmF0ZWd5IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2RhdGF0YWJsZS1wcm9ncmVzcycsXG4gIHRlbXBsYXRlOiBgXG4gICAgPGRpdiBjbGFzcz1cInByb2dyZXNzLWxpbmVhclwiIHJvbGU9XCJwcm9ncmVzc2JhclwiPlxuICAgICAgPGRpdiBjbGFzcz1cImNvbnRhaW5lclwiPlxuICAgICAgICA8ZGl2IGNsYXNzPVwiYmFyXCI+PC9kaXY+XG4gICAgICA8L2Rpdj5cbiAgICA8L2Rpdj5cbiAgYCxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgUHJvZ3Jlc3NCYXJDb21wb25lbnQge31cbiJdfQ==

package/esm2020/lib/components/body/scroller.component.mjs

@@ -0,0 +1,91 @@
+import { Component, Input, Output, EventEmitter, HostBinding, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ScrollerComponent {
+    constructor(ngZone, element, renderer) {
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        this.scrollbarV = false;
+        this.scrollbarH = false;
+        this.scroll = new EventEmitter();
+        this.scrollYPos = 0;
+        this.scrollXPos = 0;
+        this.prevScrollYPos = 0;
+        this.prevScrollXPos = 0;
+        this._scrollEventListener = null;
+        this.element = element.nativeElement;
+    }
+    ngOnInit() {
+        // manual bind so we don't always listen
+        if (this.scrollbarV || this.scrollbarH) {
+            const renderer = this.renderer;
+            this.parentElement = renderer.parentNode(renderer.parentNode(this.element));
+            this._scrollEventListener = this.onScrolled.bind(this);
+            this.parentElement.addEventListener('scroll', this._scrollEventListener);
+        }
+    }
+    ngOnDestroy() {
+        if (this._scrollEventListener) {
+            this.parentElement.removeEventListener('scroll', this._scrollEventListener);
+            this._scrollEventListener = null;
+        }
+    }
+    setOffset(offsetY) {
+        if (this.parentElement) {
+            this.parentElement.scrollTop = offsetY;
+        }
+    }
+    onScrolled(event) {
+        const dom = event.currentTarget;
+        requestAnimationFrame(() => {
+            this.scrollYPos = dom.scrollTop;
+            this.scrollXPos = dom.scrollLeft;
+            this.updateOffset();
+        });
+    }
+    updateOffset() {
+        let direction;
+        if (this.scrollYPos < this.prevScrollYPos) {
+            direction = 'down';
+        }
+        else if (this.scrollYPos > this.prevScrollYPos) {
+            direction = 'up';
+        }
+        this.scroll.emit({
+            direction,
+            scrollYPos: this.scrollYPos,
+            scrollXPos: this.scrollXPos
+        });
+        this.prevScrollYPos = this.scrollYPos;
+        this.prevScrollXPos = this.scrollXPos;
+    }
+}
+ScrollerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollerComponent, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+ScrollerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: ScrollerComponent, selector: "datatable-scroller", inputs: { scrollbarV: "scrollbarV", scrollbarH: "scrollbarH", scrollHeight: "scrollHeight", scrollWidth: "scrollWidth" }, outputs: { scroll: "scroll" }, host: { properties: { "style.height.px": "this.scrollHeight", "style.width.px": "this.scrollWidth" }, classAttribute: "datatable-scroll" }, ngImport: i0, template: ` <ng-content></ng-content> `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-scroller',
+                    template: ` <ng-content></ng-content> `,
+                    host: {
+                        class: 'datatable-scroll'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { scrollbarV: [{
+                type: Input
+            }], scrollbarH: [{
+                type: Input
+            }], scrollHeight: [{
+                type: HostBinding,
+                args: ['style.height.px']
+            }, {
+                type: Input
+            }], scrollWidth: [{
+                type: HostBinding,
+                args: ['style.width.px']
+            }, {
+                type: Input
+            }], scroll: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/body/selection.component.mjs

@@ -0,0 +1,150 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import { SelectionType } from '../../types/selection.type';
+import { selectRowsBetween, selectRows } from '../../utils/selection';
+import { Keys } from '../../utils/keys';
+import * as i0 from "@angular/core";
+export class DataTableSelectionComponent {
+    constructor() {
+        this.activate = new EventEmitter();
+        this.select = new EventEmitter();
+    }
+    selectRow(event, index, row) {
+        if (!this.selectEnabled)
+            return;
+        const chkbox = this.selectionType === SelectionType.checkbox;
+        const multi = this.selectionType === SelectionType.multi;
+        const multiClick = this.selectionType === SelectionType.multiClick;
+        let selected = [];
+        if (multi || chkbox || multiClick) {
+            if (event.shiftKey) {
+                selected = selectRowsBetween([], this.rows, index, this.prevIndex, this.getRowSelectedIdx.bind(this));
+            }
+            else if (event.ctrlKey || event.metaKey || multiClick || chkbox) {
+                selected = selectRows([...this.selected], row, this.getRowSelectedIdx.bind(this));
+            }
+            else {
+                selected = selectRows([], row, this.getRowSelectedIdx.bind(this));
+            }
+        }
+        else {
+            selected = selectRows([], row, this.getRowSelectedIdx.bind(this));
+        }
+        if (typeof this.selectCheck === 'function') {
+            selected = selected.filter(this.selectCheck.bind(this));
+        }
+        this.selected.splice(0, this.selected.length);
+        this.selected.push(...selected);
+        this.prevIndex = index;
+        this.select.emit({
+            selected
+        });
+    }
+    onActivate(model, index) {
+        const { type, event, row } = model;
+        const chkbox = this.selectionType === SelectionType.checkbox;
+        const select = (!chkbox && (type === 'click' || type === 'dblclick')) || (chkbox && type === 'checkbox');
+        if (select) {
+            this.selectRow(event, index, row);
+        }
+        else if (type === 'keydown') {
+            if (event.keyCode === Keys.return) {
+                this.selectRow(event, index, row);
+            }
+            else {
+                this.onKeyboardFocus(model);
+            }
+        }
+        this.activate.emit(model);
+    }
+    onKeyboardFocus(model) {
+        const { keyCode } = model.event;
+        const shouldFocus = keyCode === Keys.up || keyCode === Keys.down || keyCode === Keys.right || keyCode === Keys.left;
+        if (shouldFocus) {
+            const isCellSelection = this.selectionType === SelectionType.cell;
+            if (!model.cellElement || !isCellSelection) {
+                this.focusRow(model.rowElement, keyCode);
+            }
+            else if (isCellSelection) {
+                this.focusCell(model.cellElement, model.rowElement, keyCode, model.cellIndex);
+            }
+        }
+    }
+    focusRow(rowElement, keyCode) {
+        const nextRowElement = this.getPrevNextRow(rowElement, keyCode);
+        if (nextRowElement)
+            nextRowElement.focus();
+    }
+    getPrevNextRow(rowElement, keyCode) {
+        const parentElement = rowElement.parentElement;
+        if (parentElement) {
+            let focusElement;
+            if (keyCode === Keys.up) {
+                focusElement = parentElement.previousElementSibling;
+            }
+            else if (keyCode === Keys.down) {
+                focusElement = parentElement.nextElementSibling;
+            }
+            if (focusElement && focusElement.children.length) {
+                return focusElement.children[0];
+            }
+        }
+    }
+    focusCell(cellElement, rowElement, keyCode, cellIndex) {
+        let nextCellElement;
+        if (keyCode === Keys.left) {
+            nextCellElement = cellElement.previousElementSibling;
+        }
+        else if (keyCode === Keys.right) {
+            nextCellElement = cellElement.nextElementSibling;
+        }
+        else if (keyCode === Keys.up || keyCode === Keys.down) {
+            const nextRowElement = this.getPrevNextRow(rowElement, keyCode);
+            if (nextRowElement) {
+                const children = nextRowElement.getElementsByClassName('datatable-body-cell');
+                if (children.length)
+                    nextCellElement = children[cellIndex];
+            }
+        }
+        if (nextCellElement)
+            nextCellElement.focus();
+    }
+    getRowSelected(row) {
+        return this.getRowSelectedIdx(row, this.selected) > -1;
+    }
+    getRowSelectedIdx(row, selected) {
+        if (!selected || !selected.length)
+            return -1;
+        const rowId = this.rowIdentity(row);
+        return selected.findIndex(r => {
+            const id = this.rowIdentity(r);
+            return id === rowId;
+        });
+    }
+}
+DataTableSelectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableSelectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DataTableSelectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: DataTableSelectionComponent, selector: "datatable-selection", inputs: { rows: "rows", selected: "selected", selectEnabled: "selectEnabled", selectionType: "selectionType", rowIdentity: "rowIdentity", selectCheck: "selectCheck" }, outputs: { activate: "activate", select: "select" }, ngImport: i0, template: ` <ng-content></ng-content> `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableSelectionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-selection',
+                    template: ` <ng-content></ng-content> `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { rows: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], selectEnabled: [{
+                type: Input
+            }], selectionType: [{
+                type: Input
+            }], rowIdentity: [{
+                type: Input
+            }], selectCheck: [{
+                type: Input
+            }], activate: [{
+                type: Output
+            }], select: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection.component.js","sourceRoot":"","sources":["../../../../../../../projects/swimlane/ngx-datatable/src/lib/components/body/selection.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';\nimport { SelectionType } from '../../types/selection.type';\nimport { selectRowsBetween, selectRows } from '../../utils/selection';\nimport { Keys } from '../../utils/keys';\n\nexport interface Model {\n  type: string;\n  event: MouseEvent | KeyboardEvent;\n  row: any;\n  rowElement: any;\n  cellElement: any;\n  cellIndex: number;\n}\n\n@Component({\n  selector: 'datatable-selection',\n  template: ` <ng-content></ng-content> `,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DataTableSelectionComponent {\n  @Input() rows: any[];\n  @Input() selected: any[];\n  @Input() selectEnabled: boolean;\n  @Input() selectionType: SelectionType;\n  @Input() rowIdentity: any;\n  @Input() selectCheck: any;\n\n  @Output() activate: EventEmitter<any> = new EventEmitter();\n  @Output() select: EventEmitter<any> = new EventEmitter();\n\n  prevIndex: number;\n\n  selectRow(event: KeyboardEvent | MouseEvent, index: number, row: any): void {\n    if (!this.selectEnabled) return;\n\n    const chkbox = this.selectionType === SelectionType.checkbox;\n    const multi = this.selectionType === SelectionType.multi;\n    const multiClick = this.selectionType === SelectionType.multiClick;\n    let selected: any[] = [];\n\n    if (multi || chkbox || multiClick) {\n      if (event.shiftKey) {\n        selected = selectRowsBetween([], this.rows, index, this.prevIndex, this.getRowSelectedIdx.bind(this));\n      } else if (event.ctrlKey || event.metaKey || multiClick || chkbox) {\n        selected = selectRows([...this.selected], row, this.getRowSelectedIdx.bind(this));\n      } else {\n        selected = selectRows([], row, this.getRowSelectedIdx.bind(this));\n      }\n    } else {\n      selected = selectRows([], row, this.getRowSelectedIdx.bind(this));\n    }\n\n    if (typeof this.selectCheck === 'function') {\n      selected = selected.filter(this.selectCheck.bind(this));\n    }\n\n    this.selected.splice(0, this.selected.length);\n    this.selected.push(...selected);\n\n    this.prevIndex = index;\n\n    this.select.emit({\n      selected\n    });\n  }\n\n  onActivate(model: Model, index: number): void {\n    const { type, event, row } = model;\n    const chkbox = this.selectionType === SelectionType.checkbox;\n    const select = (!chkbox && (type === 'click' || type === 'dblclick')) || (chkbox && type === 'checkbox');\n\n    if (select) {\n      this.selectRow(event, index, row);\n    } else if (type === 'keydown') {\n      if ((<KeyboardEvent>event).keyCode === Keys.return) {\n        this.selectRow(event, index, row);\n      } else {\n        this.onKeyboardFocus(model);\n      }\n    }\n    this.activate.emit(model);\n  }\n\n  onKeyboardFocus(model: Model): void {\n    const { keyCode } = <KeyboardEvent>model.event;\n    const shouldFocus = keyCode === Keys.up || keyCode === Keys.down || keyCode === Keys.right || keyCode === Keys.left;\n\n    if (shouldFocus) {\n      const isCellSelection = this.selectionType === SelectionType.cell;\n\n      if (!model.cellElement || !isCellSelection) {\n        this.focusRow(model.rowElement, keyCode);\n      } else if (isCellSelection) {\n        this.focusCell(model.cellElement, model.rowElement, keyCode, model.cellIndex);\n      }\n    }\n  }\n\n  focusRow(rowElement: any, keyCode: number): void {\n    const nextRowElement = this.getPrevNextRow(rowElement, keyCode);\n    if (nextRowElement) nextRowElement.focus();\n  }\n\n  getPrevNextRow(rowElement: any, keyCode: number): any {\n    const parentElement = rowElement.parentElement;\n\n    if (parentElement) {\n      let focusElement: HTMLElement;\n      if (keyCode === Keys.up) {\n        focusElement = parentElement.previousElementSibling;\n      } else if (keyCode === Keys.down) {\n        focusElement = parentElement.nextElementSibling;\n      }\n\n      if (focusElement && focusElement.children.length) {\n        return focusElement.children[0];\n      }\n    }\n  }\n\n  focusCell(cellElement: any, rowElement: any, keyCode: number, cellIndex: number): void {\n    let nextCellElement: HTMLElement;\n\n    if (keyCode === Keys.left) {\n      nextCellElement = cellElement.previousElementSibling;\n    } else if (keyCode === Keys.right) {\n      nextCellElement = cellElement.nextElementSibling;\n    } else if (keyCode === Keys.up || keyCode === Keys.down) {\n      const nextRowElement = this.getPrevNextRow(rowElement, keyCode);\n      if (nextRowElement) {\n        const children = nextRowElement.getElementsByClassName('datatable-body-cell');\n        if (children.length) nextCellElement = children[cellIndex];\n      }\n    }\n\n    if (nextCellElement) nextCellElement.focus();\n  }\n\n  getRowSelected(row: any): boolean {\n    return this.getRowSelectedIdx(row, this.selected) > -1;\n  }\n\n  getRowSelectedIdx(row: any, selected: any[]): number {\n    if (!selected || !selected.length) return -1;\n\n    const rowId = this.rowIdentity(row);\n    return selected.findIndex(r => {\n      const id = this.rowIdentity(r);\n      return id === rowId;\n    });\n  }\n}\n"]}

package/esm2020/lib/components/body/summary/summary-row.component.mjs

@@ -0,0 +1,105 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../body-row.component";
+import * as i2 from "@angular/common";
+function defaultSumFunc(cells) {
+    const cellsWithValues = cells.filter(cell => !!cell);
+    if (!cellsWithValues.length) {
+        return null;
+    }
+    if (cellsWithValues.some(cell => typeof cell !== 'number')) {
+        return null;
+    }
+    return cellsWithValues.reduce((res, cell) => res + cell);
+}
+function noopSumFunc(cells) {
+    return null;
+}
+export class DataTableSummaryRowComponent {
+    constructor() {
+        this.summaryRow = {};
+    }
+    ngOnChanges() {
+        if (!this.columns || !this.rows) {
+            return;
+        }
+        this.updateInternalColumns();
+        this.updateValues();
+    }
+    updateInternalColumns() {
+        this._internalColumns = this.columns.map(col => ({
+            ...col,
+            cellTemplate: col.summaryTemplate
+        }));
+    }
+    updateValues() {
+        this.summaryRow = {};
+        this.columns
+            .filter(col => !col.summaryTemplate)
+            .forEach(col => {
+            const cellsFromSingleColumn = this.rows.map(row => row[col.prop]);
+            const sumFunc = this.getSummaryFunction(col);
+            this.summaryRow[col.prop] = col.pipe
+                ? col.pipe.transform(sumFunc(cellsFromSingleColumn))
+                : sumFunc(cellsFromSingleColumn);
+        });
+    }
+    getSummaryFunction(column) {
+        if (column.summaryFunc === undefined) {
+            return defaultSumFunc;
+        }
+        else if (column.summaryFunc === null) {
+            return noopSumFunc;
+        }
+        else {
+            return column.summaryFunc;
+        }
+    }
+}
+DataTableSummaryRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableSummaryRowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DataTableSummaryRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: DataTableSummaryRowComponent, selector: "datatable-summary-row", inputs: { rows: "rows", columns: "columns", rowHeight: "rowHeight", offsetX: "offsetX", innerWidth: "innerWidth" }, host: { classAttribute: "datatable-summary-row" }, usesOnChanges: true, ngImport: i0, template: `
+    <datatable-body-row
+      *ngIf="summaryRow && _internalColumns"
+      tabindex="-1"
+      [innerWidth]="innerWidth"
+      [offsetX]="offsetX"
+      [columns]="_internalColumns"
+      [rowHeight]="rowHeight"
+      [row]="summaryRow"
+      [rowIndex]="-1"
+    >
+    </datatable-body-row>
+  `, isInline: true, components: [{ type: i1.DataTableBodyRowComponent, selector: "datatable-body-row", inputs: ["columns", "innerWidth", "expanded", "rowClass", "row", "group", "isSelected", "rowIndex", "displayCheck", "treeStatus", "offsetX", "rowHeight"], outputs: ["activate", "treeAction"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableSummaryRowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-summary-row',
+                    template: `
+    <datatable-body-row
+      *ngIf="summaryRow && _internalColumns"
+      tabindex="-1"
+      [innerWidth]="innerWidth"
+      [offsetX]="offsetX"
+      [columns]="_internalColumns"
+      [rowHeight]="rowHeight"
+      [row]="summaryRow"
+      [rowIndex]="-1"
+    >
+    </datatable-body-row>
+  `,
+                    host: {
+                        class: 'datatable-summary-row'
+                    }
+                }]
+        }], propDecorators: { rows: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], offsetX: [{
+                type: Input
+            }], innerWidth: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/columns/column-cell.directive.mjs

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

package/esm2020/lib/components/columns/column-header.directive.mjs

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

package/esm2020/lib/components/columns/column.directive.mjs

@@ -0,0 +1,98 @@
+import { Directive, TemplateRef, ContentChild, Input } from '@angular/core';
+import { DataTableColumnHeaderDirective } from './column-header.directive';
+import { DataTableColumnCellDirective } from './column-cell.directive';
+import { DataTableColumnCellTreeToggle } from './tree.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/column-changes.service";
+export class DataTableColumnDirective {
+    constructor(columnChangesService) {
+        this.columnChangesService = columnChangesService;
+        this.isFirstChange = true;
+    }
+    get cellTemplate() {
+        return this._cellTemplateInput || this._cellTemplateQuery;
+    }
+    get headerTemplate() {
+        return this._headerTemplateInput || this._headerTemplateQuery;
+    }
+    get treeToggleTemplate() {
+        return this._treeToggleTemplateInput || this._treeToggleTemplateQuery;
+    }
+    ngOnChanges() {
+        if (this.isFirstChange) {
+            this.isFirstChange = false;
+        }
+        else {
+            this.columnChangesService.onInputChange();
+        }
+    }
+}
+DataTableColumnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableColumnDirective, deps: [{ token: i1.ColumnChangesService }], target: i0.ɵɵFactoryTarget.Directive });
+DataTableColumnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: DataTableColumnDirective, selector: "ngx-datatable-column", inputs: { name: "name", prop: "prop", frozenLeft: "frozenLeft", frozenRight: "frozenRight", flexGrow: "flexGrow", resizeable: "resizeable", comparator: "comparator", pipe: "pipe", sortable: "sortable", draggable: "draggable", canAutoResize: "canAutoResize", minWidth: "minWidth", width: "width", maxWidth: "maxWidth", checkboxable: "checkboxable", headerCheckboxable: "headerCheckboxable", headerClass: "headerClass", cellClass: "cellClass", isTreeColumn: "isTreeColumn", treeLevelIndent: "treeLevelIndent", summaryFunc: "summaryFunc", summaryTemplate: "summaryTemplate", _cellTemplateInput: ["cellTemplate", "_cellTemplateInput"], _headerTemplateInput: ["headerTemplate", "_headerTemplateInput"], _treeToggleTemplateInput: ["treeToggleTemplate", "_treeToggleTemplateInput"] }, queries: [{ propertyName: "_cellTemplateQuery", first: true, predicate: DataTableColumnCellDirective, descendants: true, read: TemplateRef, static: true }, { propertyName: "_headerTemplateQuery", first: true, predicate: DataTableColumnHeaderDirective, descendants: true, read: TemplateRef, static: true }, { propertyName: "_treeToggleTemplateQuery", first: true, predicate: DataTableColumnCellTreeToggle, descendants: true, read: TemplateRef, static: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableColumnDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngx-datatable-column' }]
+        }], ctorParameters: function () { return [{ type: i1.ColumnChangesService }]; }, propDecorators: { name: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], frozenLeft: [{
+                type: Input
+            }], frozenRight: [{
+                type: Input
+            }], flexGrow: [{
+                type: Input
+            }], resizeable: [{
+                type: Input
+            }], comparator: [{
+                type: Input
+            }], pipe: [{
+                type: Input
+            }], sortable: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], canAutoResize: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], checkboxable: [{
+                type: Input
+            }], headerCheckboxable: [{
+                type: Input
+            }], headerClass: [{
+                type: Input
+            }], cellClass: [{
+                type: Input
+            }], isTreeColumn: [{
+                type: Input
+            }], treeLevelIndent: [{
+                type: Input
+            }], summaryFunc: [{
+                type: Input
+            }], summaryTemplate: [{
+                type: Input
+            }], _cellTemplateInput: [{
+                type: Input,
+                args: ['cellTemplate']
+            }], _cellTemplateQuery: [{
+                type: ContentChild,
+                args: [DataTableColumnCellDirective, { read: TemplateRef, static: true }]
+            }], _headerTemplateInput: [{
+                type: Input,
+                args: ['headerTemplate']
+            }], _headerTemplateQuery: [{
+                type: ContentChild,
+                args: [DataTableColumnHeaderDirective, { read: TemplateRef, static: true }]
+            }], _treeToggleTemplateInput: [{
+                type: Input,
+                args: ['treeToggleTemplate']
+            }], _treeToggleTemplateQuery: [{
+                type: ContentChild,
+                args: [DataTableColumnCellTreeToggle, { read: TemplateRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N3aW1sYW5lL25neC1kYXRhdGFibGUvc3JjL2xpYi9jb21wb25lbnRzL2NvbHVtbnMvY29sdW1uLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUE0QixNQUFNLGVBQWUsQ0FBQztBQUN0RyxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQzs7O0FBS2pFLE1BQU0sT0FBTyx3QkFBd0I7SUF3RG5DLFlBQW9CLG9CQUEwQztRQUExQyx5QkFBb0IsR0FBcEIsb0JBQW9CLENBQXNCO1FBRnRELGtCQUFhLEdBQUcsSUFBSSxDQUFDO0lBRW9DLENBQUM7SUExQmxFLElBQUksWUFBWTtRQUNkLE9BQU8sSUFBSSxDQUFDLGtCQUFrQixJQUFJLElBQUksQ0FBQyxrQkFBa0IsQ0FBQztJQUM1RCxDQUFDO0lBUUQsSUFBSSxjQUFjO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLG9CQUFvQixJQUFJLElBQUksQ0FBQyxvQkFBb0IsQ0FBQztJQUNoRSxDQUFDO0lBUUQsSUFBSSxrQkFBa0I7UUFDcEIsT0FBTyxJQUFJLENBQUMsd0JBQXdCLElBQUksSUFBSSxDQUFDLHdCQUF3QixDQUFDO0lBQ3hFLENBQUM7SUFNRCxXQUFXO1FBQ1QsSUFBSSxJQUFJLENBQUMsYUFBYSxFQUFFO1lBQ3RCLElBQUksQ0FBQyxhQUFhLEdBQUcsS0FBSyxDQUFDO1NBQzVCO2FBQU07WUFDTCxJQUFJLENBQUMsb0JBQW9CLENBQUMsYUFBYSxFQUFFLENBQUM7U0FDM0M7SUFDSCxDQUFDOztxSEFoRVUsd0JBQXdCO3lHQUF4Qix3QkFBd0IsczNCQTJCckIsNEJBQTRCLDJCQUFVLFdBQVcsa0ZBVWpELDhCQUE4QiwyQkFBVSxXQUFXLHNGQVVuRCw2QkFBNkIsMkJBQVUsV0FBVzsyRkEvQ3JELHdCQUF3QjtrQkFEcEMsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSxzQkFBc0IsRUFBRTsyR0FFcEMsSUFBSTtzQkFBWixLQUFLO2dCQUNHLElBQUk7c0JBQVosS0FBSztnQkFDRyxVQUFVO3NCQUFsQixLQUFLO2dCQUNHLFdBQVc7c0JBQW5CLEtBQUs7Z0JBQ0csUUFBUTtzQkFBaEIsS0FBSztnQkFDRyxVQUFVO3NCQUFsQixLQUFLO2dCQUNHLFVBQVU7c0JBQWxCLEtBQUs7Z0JBQ0csSUFBSTtzQkFBWixLQUFLO2dCQUNHLFFBQVE7c0JBQWhCLEtBQUs7Z0JBQ0csU0FBUztzQkFBakIsS0FBSztnQkFDRyxhQUFhO3NCQUFyQixLQUFLO2dCQUNHLFFBQVE7c0JBQWhCLEtBQUs7Z0JBQ0csS0FBSztzQkFBYixLQUFLO2dCQUNHLFFBQVE7c0JBQWhCLEtBQUs7Z0JBQ0csWUFBWTtzQkFBcEIsS0FBSztnQkFDRyxrQkFBa0I7c0JBQTFCLEtBQUs7Z0JBQ0csV0FBVztzQkFBbkIsS0FBSztnQkFDRyxTQUFTO3NCQUFqQixLQUFLO2dCQUNHLFlBQVk7c0JBQXBCLEtBQUs7Z0JBQ0csZUFBZTtzQkFBdkIsS0FBSztnQkFDRyxXQUFXO3NCQUFuQixLQUFLO2dCQUNHLGVBQWU7c0JBQXZCLEtBQUs7Z0JBR04sa0JBQWtCO3NCQURqQixLQUFLO3VCQUFDLGNBQWM7Z0JBSXJCLGtCQUFrQjtzQkFEakIsWUFBWTt1QkFBQyw0QkFBNEIsRUFBRSxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRTtnQkFRL0Usb0JBQW9CO3NCQURuQixLQUFLO3VCQUFDLGdCQUFnQjtnQkFJdkIsb0JBQW9CO3NCQURuQixZQUFZO3VCQUFDLDhCQUE4QixFQUFFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFO2dCQVFqRix3QkFBd0I7c0JBRHZCLEtBQUs7dUJBQUMsb0JBQW9CO2dCQUkzQix3QkFBd0I7c0JBRHZCLFlBQVk7dUJBQUMsNkJBQTZCLEVBQUUsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFRlbXBsYXRlUmVmLCBDb250ZW50Q2hpbGQsIElucHV0LCBPbkNoYW5nZXMsIFNpbXBsZUNoYW5nZXMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERhdGFUYWJsZUNvbHVtbkhlYWRlckRpcmVjdGl2ZSB9IGZyb20gJy4vY29sdW1uLWhlYWRlci5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRGF0YVRhYmxlQ29sdW1uQ2VsbERpcmVjdGl2ZSB9IGZyb20gJy4vY29sdW1uLWNlbGwuZGlyZWN0aXZlJztcbmltcG9ydCB7IERhdGFUYWJsZUNvbHVtbkNlbGxUcmVlVG9nZ2xlIH0gZnJvbSAnLi90cmVlLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBDb2x1bW5DaGFuZ2VzU2VydmljZSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzL2NvbHVtbi1jaGFuZ2VzLnNlcnZpY2UnO1xuaW1wb3J0IHsgVGFibGVDb2x1bW5Qcm9wIH0gZnJvbSAnLi4vLi4vdHlwZXMvdGFibGUtY29sdW1uLnR5cGUnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICduZ3gtZGF0YXRhYmxlLWNvbHVtbicgfSlcbmV4cG9ydCBjbGFzcyBEYXRhVGFibGVDb2x1bW5EaXJlY3RpdmUgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuICBASW5wdXQoKSBuYW1lOiBzdHJpbmc7XG4gIEBJbnB1dCgpIHByb3A6IFRhYmxlQ29sdW1uUHJvcDtcbiAgQElucHV0KCkgZnJvemVuTGVmdDogYW55O1xuICBASW5wdXQoKSBmcm96ZW5SaWdodDogYW55O1xuICBASW5wdXQoKSBmbGV4R3JvdzogbnVtYmVyO1xuICBASW5wdXQoKSByZXNpemVhYmxlOiBib29sZWFuO1xuICBASW5wdXQoKSBjb21wYXJhdG9yOiBhbnk7XG4gIEBJbnB1dCgpIHBpcGU6IGFueTtcbiAgQElucHV0KCkgc29ydGFibGU6IGJvb2xlYW47XG4gIEBJbnB1dCgpIGRyYWdnYWJsZTogYm9vbGVhbjtcbiAgQElucHV0KCkgY2FuQXV0b1Jlc2l6ZTogYm9vbGVhbjtcbiAgQElucHV0KCkgbWluV2lkdGg6IG51bWJlcjtcbiAgQElucHV0KCkgd2lkdGg6IG51bWJlcjtcbiAgQElucHV0KCkgbWF4V2lkdGg6IG51bWJlcjtcbiAgQElucHV0KCkgY2hlY2tib3hhYmxlOiBib29sZWFuO1xuICBASW5wdXQoKSBoZWFkZXJDaGVja2JveGFibGU6IGJvb2xlYW47XG4gIEBJbnB1dCgpIGhlYWRlckNsYXNzOiBzdHJpbmcgfCAoKGRhdGE6IGFueSkgPT4gc3RyaW5nIHwgYW55KTtcbiAgQElucHV0KCkgY2VsbENsYXNzOiBzdHJpbmcgfCAoKGRhdGE6IGFueSkgPT4gc3RyaW5nIHwgYW55KTtcbiAgQElucHV0KCkgaXNUcmVlQ29sdW1uOiBib29sZWFuO1xuICBASW5wdXQoKSB0cmVlTGV2ZWxJbmRlbnQ6IG51bWJlcjtcbiAgQElucHV0KCkgc3VtbWFyeUZ1bmM6IChjZWxsczogYW55W10pID0+IGFueTtcbiAgQElucHV0KCkgc3VtbWFyeVRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+O1xuXG4gIEBJbnB1dCgnY2VsbFRlbXBsYXRlJylcbiAgX2NlbGxUZW1wbGF0ZUlucHV0OiBUZW1wbGF0ZVJlZjxhbnk+O1xuXG4gIEBDb250ZW50Q2hpbGQoRGF0YVRhYmxlQ29sdW1uQ2VsbERpcmVjdGl2ZSwgeyByZWFkOiBUZW1wbGF0ZVJlZiwgc3RhdGljOiB0cnVlIH0pXG4gIF9jZWxsVGVtcGxhdGVRdWVyeTogVGVtcGxhdGVSZWY8YW55PjtcblxuICBnZXQgY2VsbFRlbXBsYXRlKCk6IFRlbXBsYXRlUmVmPGFueT4ge1xuICAgIHJldHVybiB0aGlzLl9jZWxsVGVtcGxhdGVJbnB1dCB8fCB0aGlzLl9jZWxsVGVtcGxhdGVRdWVyeTtcbiAgfVxuXG4gIEBJbnB1dCgnaGVhZGVyVGVtcGxhdGUnKVxuICBfaGVhZGVyVGVtcGxhdGVJbnB1dDogVGVtcGxhdGVSZWY8YW55PjtcblxuICBAQ29udGVudENoaWxkKERhdGFUYWJsZUNvbHVtbkhlYWRlckRpcmVjdGl2ZSwgeyByZWFkOiBUZW1wbGF0ZVJlZiwgc3RhdGljOiB0cnVlIH0pXG4gIF9oZWFkZXJUZW1wbGF0ZVF1ZXJ5OiBUZW1wbGF0ZVJlZjxhbnk+O1xuXG4gIGdldCBoZWFkZXJUZW1wbGF0ZSgpOiBUZW1wbGF0ZVJlZjxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5faGVhZGVyVGVtcGxhdGVJbnB1dCB8fCB0aGlzLl9oZWFkZXJUZW1wbGF0ZVF1ZXJ5O1xuICB9XG5cbiAgQElucHV0KCd0cmVlVG9nZ2xlVGVtcGxhdGUnKVxuICBfdHJlZVRvZ2dsZVRlbXBsYXRlSW5wdXQ6IFRlbXBsYXRlUmVmPGFueT47XG5cbiAgQENvbnRlbnRDaGlsZChEYXRhVGFibGVDb2x1bW5DZWxsVHJlZVRvZ2dsZSwgeyByZWFkOiBUZW1wbGF0ZVJlZiwgc3RhdGljOiB0cnVlIH0pXG4gIF90cmVlVG9nZ2xlVGVtcGxhdGVRdWVyeTogVGVtcGxhdGVSZWY8YW55PjtcblxuICBnZXQgdHJlZVRvZ2dsZVRlbXBsYXRlKCk6IFRlbXBsYXRlUmVmPGFueT4ge1xuICAgIHJldHVybiB0aGlzLl90cmVlVG9nZ2xlVGVtcGxhdGVJbnB1dCB8fCB0aGlzLl90cmVlVG9nZ2xlVGVtcGxhdGVRdWVyeTtcbiAgfVxuXG4gIHByaXZhdGUgaXNGaXJzdENoYW5nZSA9IHRydWU7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBjb2x1bW5DaGFuZ2VzU2VydmljZTogQ29sdW1uQ2hhbmdlc1NlcnZpY2UpIHt9XG5cbiAgbmdPbkNoYW5nZXMoKSB7XG4gICAgaWYgKHRoaXMuaXNGaXJzdENoYW5nZSkge1xuICAgICAgdGhpcy5pc0ZpcnN0Q2hhbmdlID0gZmFsc2U7XG4gICAgfSBlbHNlIHtcbiAgICAgIHRoaXMuY29sdW1uQ2hhbmdlc1NlcnZpY2Uub25JbnB1dENoYW5nZSgpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2020/lib/components/columns/tree.directive.mjs

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