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

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

@@ -0,0 +1,140 @@
+import { Component, Input, Output, EventEmitter, HostListener, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DataTableRowWrapperComponent {
+    constructor(cd, differs) {
+        this.cd = cd;
+        this.differs = differs;
+        this.rowContextmenu = new EventEmitter(false);
+        this._expanded = false;
+        this.groupContext = {
+            group: this.row,
+            expanded: this.expanded,
+            rowIndex: this.rowIndex
+        };
+        this.rowContext = {
+            row: this.row,
+            expanded: this.expanded,
+            rowIndex: this.rowIndex
+        };
+        this.rowDiffer = differs.find({}).create();
+    }
+    set rowIndex(val) {
+        this._rowIndex = val;
+        this.rowContext.rowIndex = val;
+        this.groupContext.rowIndex = val;
+        this.cd.markForCheck();
+    }
+    get rowIndex() {
+        return this._rowIndex;
+    }
+    set expanded(val) {
+        this._expanded = val;
+        this.groupContext.expanded = val;
+        this.rowContext.expanded = val;
+        this.cd.markForCheck();
+    }
+    get expanded() {
+        return this._expanded;
+    }
+    ngDoCheck() {
+        if (this.rowDiffer.diff(this.row)) {
+            this.rowContext.row = this.row;
+            this.groupContext.group = this.row;
+            this.cd.markForCheck();
+        }
+    }
+    onContextmenu($event) {
+        this.rowContextmenu.emit({ event: $event, row: this.row });
+    }
+    getGroupHeaderStyle() {
+        const styles = {};
+        styles['transform'] = 'translate3d(' + this.offsetX + 'px, 0px, 0px)';
+        styles['backface-visibility'] = 'hidden';
+        styles['width'] = this.innerWidth;
+        return styles;
+    }
+}
+DataTableRowWrapperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableRowWrapperComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.KeyValueDiffers }], target: i0.ɵɵFactoryTarget.Component });
+DataTableRowWrapperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: DataTableRowWrapperComponent, selector: "datatable-row-wrapper", inputs: { innerWidth: "innerWidth", rowDetail: "rowDetail", groupHeader: "groupHeader", offsetX: "offsetX", detailRowHeight: "detailRowHeight", row: "row", groupedRows: "groupedRows", rowIndex: "rowIndex", expanded: "expanded" }, outputs: { rowContextmenu: "rowContextmenu" }, host: { listeners: { "contextmenu": "onContextmenu($event)" }, classAttribute: "datatable-row-wrapper" }, ngImport: i0, template: `
+    <div *ngIf="groupHeader && groupHeader.template" class="datatable-group-header" [ngStyle]="getGroupHeaderStyle()">
+      <ng-template
+        *ngIf="groupHeader && groupHeader.template"
+        [ngTemplateOutlet]="groupHeader.template"
+        [ngTemplateOutletContext]="groupContext"
+      >
+      </ng-template>
+    </div>
+    <ng-content *ngIf="(groupHeader && groupHeader.template && expanded) || !groupHeader || !groupHeader.template">
+    </ng-content>
+    <div
+      *ngIf="rowDetail && rowDetail.template && expanded"
+      [style.height.px]="detailRowHeight"
+      class="datatable-row-detail"
+    >
+      <ng-template
+        *ngIf="rowDetail && rowDetail.template"
+        [ngTemplateOutlet]="rowDetail.template"
+        [ngTemplateOutletContext]="rowContext"
+      >
+      </ng-template>
+    </div>
+  `, isInline: true, directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableRowWrapperComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-row-wrapper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <div *ngIf="groupHeader && groupHeader.template" class="datatable-group-header" [ngStyle]="getGroupHeaderStyle()">
+      <ng-template
+        *ngIf="groupHeader && groupHeader.template"
+        [ngTemplateOutlet]="groupHeader.template"
+        [ngTemplateOutletContext]="groupContext"
+      >
+      </ng-template>
+    </div>
+    <ng-content *ngIf="(groupHeader && groupHeader.template && expanded) || !groupHeader || !groupHeader.template">
+    </ng-content>
+    <div
+      *ngIf="rowDetail && rowDetail.template && expanded"
+      [style.height.px]="detailRowHeight"
+      class="datatable-row-detail"
+    >
+      <ng-template
+        *ngIf="rowDetail && rowDetail.template"
+        [ngTemplateOutlet]="rowDetail.template"
+        [ngTemplateOutletContext]="rowContext"
+      >
+      </ng-template>
+    </div>
+  `,
+                    host: {
+                        class: 'datatable-row-wrapper'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.KeyValueDiffers }]; }, propDecorators: { innerWidth: [{
+                type: Input
+            }], rowDetail: [{
+                type: Input
+            }], groupHeader: [{
+                type: Input
+            }], offsetX: [{
+                type: Input
+            }], detailRowHeight: [{
+                type: Input
+            }], row: [{
+                type: Input
+            }], groupedRows: [{
+                type: Input
+            }], rowContextmenu: [{
+                type: Output
+            }], rowIndex: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }], onContextmenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,262 @@
+import { Component, Input, HostBinding, Output, EventEmitter, HostListener, ChangeDetectionStrategy, SkipSelf } from '@angular/core';
+import { columnsByPin, columnGroupWidths, columnsByPinArr } from '../../utils/column';
+import { Keys } from '../../utils/keys';
+import { translateXY } from '../../utils/translate';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/scrollbar-helper.service";
+import * as i2 from "./body-cell.component";
+import * as i3 from "@angular/common";
+export class DataTableBodyRowComponent {
+    constructor(differs, scrollbarHelper, cd, element) {
+        this.differs = differs;
+        this.scrollbarHelper = scrollbarHelper;
+        this.cd = cd;
+        this.treeStatus = 'collapsed';
+        this.activate = new EventEmitter();
+        this.treeAction = new EventEmitter();
+        this._groupStyles = {
+            left: {},
+            center: {},
+            right: {}
+        };
+        this._element = element.nativeElement;
+        this._rowDiffer = differs.find({}).create();
+    }
+    set columns(val) {
+        this._columns = val;
+        this.recalculateColumns(val);
+        this.buildStylesByGroup();
+    }
+    get columns() {
+        return this._columns;
+    }
+    set innerWidth(val) {
+        if (this._columns) {
+            const colByPin = columnsByPin(this._columns);
+            this._columnGroupWidths = columnGroupWidths(colByPin, this._columns);
+        }
+        this._innerWidth = val;
+        this.recalculateColumns();
+        this.buildStylesByGroup();
+    }
+    get innerWidth() {
+        return this._innerWidth;
+    }
+    set offsetX(val) {
+        this._offsetX = val;
+        this.buildStylesByGroup();
+    }
+    get offsetX() {
+        return this._offsetX;
+    }
+    get cssClass() {
+        let cls = 'datatable-body-row';
+        if (this.isSelected) {
+            cls += ' active';
+        }
+        if (this.rowIndex % 2 !== 0) {
+            cls += ' datatable-row-odd';
+        }
+        if (this.rowIndex % 2 === 0) {
+            cls += ' datatable-row-even';
+        }
+        if (this.rowClass) {
+            const res = this.rowClass(this.row);
+            if (typeof res === 'string') {
+                cls += ` ${res}`;
+            }
+            else if (typeof res === 'object') {
+                const keys = Object.keys(res);
+                for (const k of keys) {
+                    if (res[k] === true) {
+                        cls += ` ${k}`;
+                    }
+                }
+            }
+        }
+        return cls;
+    }
+    get columnsTotalWidths() {
+        return this._columnGroupWidths.total;
+    }
+    ngDoCheck() {
+        if (this._rowDiffer.diff(this.row)) {
+            this.cd.markForCheck();
+        }
+    }
+    trackByGroups(index, colGroup) {
+        return colGroup.type;
+    }
+    columnTrackingFn(index, column) {
+        return column.$$id;
+    }
+    buildStylesByGroup() {
+        this._groupStyles.left = this.calcStylesByGroup('left');
+        this._groupStyles.center = this.calcStylesByGroup('center');
+        this._groupStyles.right = this.calcStylesByGroup('right');
+        this.cd.markForCheck();
+    }
+    calcStylesByGroup(group) {
+        const widths = this._columnGroupWidths;
+        const offsetX = this.offsetX;
+        const styles = {
+            width: `${widths[group]}px`
+        };
+        if (group === 'left') {
+            translateXY(styles, offsetX, 0);
+        }
+        else if (group === 'right') {
+            const bodyWidth = parseInt(this.innerWidth + '', 0);
+            const totalDiff = widths.total - bodyWidth;
+            const offsetDiff = totalDiff - offsetX;
+            const offset = (offsetDiff + this.scrollbarHelper.width) * -1;
+            translateXY(styles, offset, 0);
+        }
+        return styles;
+    }
+    onActivate(event, index) {
+        event.cellIndex = index;
+        event.rowElement = this._element;
+        this.activate.emit(event);
+    }
+    onKeyDown(event) {
+        const keyCode = event.keyCode;
+        const isTargetRow = event.target === this._element;
+        const isAction = keyCode === Keys.return ||
+            keyCode === Keys.down ||
+            keyCode === Keys.up ||
+            keyCode === Keys.left ||
+            keyCode === Keys.right;
+        if (isAction && isTargetRow) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.activate.emit({
+                type: 'keydown',
+                event,
+                row: this.row,
+                rowElement: this._element
+            });
+        }
+    }
+    onMouseenter(event) {
+        this.activate.emit({
+            type: 'mouseenter',
+            event,
+            row: this.row,
+            rowElement: this._element
+        });
+    }
+    recalculateColumns(val = this.columns) {
+        this._columns = val;
+        const colsByPin = columnsByPin(this._columns);
+        this._columnsByPin = columnsByPinArr(this._columns);
+        this._columnGroupWidths = columnGroupWidths(colsByPin, this._columns);
+    }
+    onTreeAction() {
+        this.treeAction.emit();
+    }
+}
+DataTableBodyRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableBodyRowComponent, deps: [{ token: i0.KeyValueDiffers }, { token: i1.ScrollbarHelper, skipSelf: true }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+DataTableBodyRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: DataTableBodyRowComponent, selector: "datatable-body-row", inputs: { columns: "columns", innerWidth: "innerWidth", expanded: "expanded", rowClass: "rowClass", row: "row", group: "group", isSelected: "isSelected", rowIndex: "rowIndex", displayCheck: "displayCheck", treeStatus: "treeStatus", offsetX: "offsetX", rowHeight: "rowHeight" }, outputs: { activate: "activate", treeAction: "treeAction" }, host: { listeners: { "keydown": "onKeyDown($event)", "mouseenter": "onMouseenter($event)" }, properties: { "class": "this.cssClass", "style.height.px": "this.rowHeight", "style.width.px": "this.columnsTotalWidths" } }, ngImport: i0, template: `
+    <div
+      *ngFor="let colGroup of _columnsByPin; let i = index; trackBy: trackByGroups"
+      class="datatable-row-{{ colGroup.type }} datatable-row-group"
+      [ngStyle]="_groupStyles[colGroup.type]"
+    >
+      <datatable-body-cell
+        role="cell"
+        *ngFor="let column of colGroup.columns; let ii = index; trackBy: columnTrackingFn"
+        tabindex="-1"
+        [row]="row"
+        [group]="group"
+        [expanded]="expanded"
+        [isSelected]="isSelected"
+        [rowIndex]="rowIndex"
+        [column]="column"
+        [rowHeight]="rowHeight"
+        [displayCheck]="displayCheck"
+        [treeStatus]="treeStatus"
+        (activate)="onActivate($event, ii)"
+        (treeAction)="onTreeAction()"
+      >
+      </datatable-body-cell>
+    </div>
+  `, isInline: true, components: [{ type: i2.DataTableBodyCellComponent, selector: "datatable-body-cell", inputs: ["displayCheck", "group", "rowHeight", "isSelected", "expanded", "rowIndex", "column", "row", "sorts", "treeStatus"], outputs: ["activate", "treeAction"] }], directives: [{ type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DataTableBodyRowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'datatable-body-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <div
+      *ngFor="let colGroup of _columnsByPin; let i = index; trackBy: trackByGroups"
+      class="datatable-row-{{ colGroup.type }} datatable-row-group"
+      [ngStyle]="_groupStyles[colGroup.type]"
+    >
+      <datatable-body-cell
+        role="cell"
+        *ngFor="let column of colGroup.columns; let ii = index; trackBy: columnTrackingFn"
+        tabindex="-1"
+        [row]="row"
+        [group]="group"
+        [expanded]="expanded"
+        [isSelected]="isSelected"
+        [rowIndex]="rowIndex"
+        [column]="column"
+        [rowHeight]="rowHeight"
+        [displayCheck]="displayCheck"
+        [treeStatus]="treeStatus"
+        (activate)="onActivate($event, ii)"
+        (treeAction)="onTreeAction()"
+      >
+      </datatable-body-cell>
+    </div>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: i0.KeyValueDiffers }, { type: i1.ScrollbarHelper, decorators: [{
+                    type: SkipSelf
+                }] }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, propDecorators: { columns: [{
+                type: Input
+            }], innerWidth: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], row: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], isSelected: [{
+                type: Input
+            }], rowIndex: [{
+                type: Input
+            }], displayCheck: [{
+                type: Input
+            }], treeStatus: [{
+                type: Input
+            }], offsetX: [{
+                type: Input
+            }], cssClass: [{
+                type: HostBinding,
+                args: ['class']
+            }], rowHeight: [{
+                type: HostBinding,
+                args: ['style.height.px']
+            }, {
+                type: Input
+            }], columnsTotalWidths: [{
+                type: HostBinding,
+                args: ['style.width.px']
+            }], activate: [{
+                type: Output
+            }], treeAction: [{
+                type: Output
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onMouseenter: [{
+                type: HostListener,
+                args: ['mouseenter', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"body-row.component.js","sourceRoot":"","sources":["../../../../../../../projects/swimlane/ngx-datatable/src/lib/components/body/body-row.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  HostBinding,\n  ElementRef,\n  Output,\n  KeyValueDiffers,\n  KeyValueDiffer,\n  EventEmitter,\n  HostListener,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  DoCheck,\n  SkipSelf\n} from '@angular/core';\n\nimport { TreeStatus } from './body-cell.component';\nimport { columnsByPin, columnGroupWidths, columnsByPinArr } from '../../utils/column';\nimport { Keys } from '../../utils/keys';\nimport { ScrollbarHelper } from '../../services/scrollbar-helper.service';\nimport { translateXY } from '../../utils/translate';\n\n@Component({\n  selector: 'datatable-body-row',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      *ngFor=\"let colGroup of _columnsByPin; let i = index; trackBy: trackByGroups\"\n      class=\"datatable-row-{{ colGroup.type }} datatable-row-group\"\n      [ngStyle]=\"_groupStyles[colGroup.type]\"\n    >\n      <datatable-body-cell\n        role=\"cell\"\n        *ngFor=\"let column of colGroup.columns; let ii = index; trackBy: columnTrackingFn\"\n        tabindex=\"-1\"\n        [row]=\"row\"\n        [group]=\"group\"\n        [expanded]=\"expanded\"\n        [isSelected]=\"isSelected\"\n        [rowIndex]=\"rowIndex\"\n        [column]=\"column\"\n        [rowHeight]=\"rowHeight\"\n        [displayCheck]=\"displayCheck\"\n        [treeStatus]=\"treeStatus\"\n        (activate)=\"onActivate($event, ii)\"\n        (treeAction)=\"onTreeAction()\"\n      >\n      </datatable-body-cell>\n    </div>\n  `\n})\nexport class DataTableBodyRowComponent implements DoCheck {\n  @Input() set columns(val: any[]) {\n    this._columns = val;\n    this.recalculateColumns(val);\n    this.buildStylesByGroup();\n  }\n\n  get columns(): any[] {\n    return this._columns;\n  }\n\n  @Input() set innerWidth(val: number) {\n    if (this._columns) {\n      const colByPin = columnsByPin(this._columns);\n      this._columnGroupWidths = columnGroupWidths(colByPin, this._columns);\n    }\n\n    this._innerWidth = val;\n    this.recalculateColumns();\n    this.buildStylesByGroup();\n  }\n\n  get innerWidth(): number {\n    return this._innerWidth;\n  }\n\n  @Input() expanded: boolean;\n  @Input() rowClass: any;\n  @Input() row: any;\n  @Input() group: any;\n  @Input() isSelected: boolean;\n  @Input() rowIndex: number;\n  @Input() displayCheck: any;\n  @Input() treeStatus: TreeStatus = 'collapsed';\n\n  @Input()\n  set offsetX(val: number) {\n    this._offsetX = val;\n    this.buildStylesByGroup();\n  }\n  get offsetX() {\n    return this._offsetX;\n  }\n\n  @HostBinding('class')\n  get cssClass() {\n    let cls = 'datatable-body-row';\n    if (this.isSelected) {\n      cls += ' active';\n    }\n    if (this.rowIndex % 2 !== 0) {\n      cls += ' datatable-row-odd';\n    }\n    if (this.rowIndex % 2 === 0) {\n      cls += ' datatable-row-even';\n    }\n\n    if (this.rowClass) {\n      const res = this.rowClass(this.row);\n      if (typeof res === 'string') {\n        cls += ` ${res}`;\n      } else if (typeof res === 'object') {\n        const keys = Object.keys(res);\n        for (const k of keys) {\n          if (res[k] === true) {\n            cls += ` ${k}`;\n          }\n        }\n      }\n    }\n\n    return cls;\n  }\n\n  @HostBinding('style.height.px')\n  @Input()\n  rowHeight: number;\n\n  @HostBinding('style.width.px')\n  get columnsTotalWidths(): string {\n    return this._columnGroupWidths.total;\n  }\n\n  @Output() activate: EventEmitter<any> = new EventEmitter();\n  @Output() treeAction: EventEmitter<any> = new EventEmitter();\n\n  _element: any;\n  _columnGroupWidths: any;\n  _columnsByPin: any;\n  _offsetX: number;\n  _columns: any[];\n  _innerWidth: number;\n  _groupStyles: { [prop: string]: {} } = {\n    left: {},\n    center: {},\n    right: {}\n  };\n\n  private _rowDiffer: KeyValueDiffer<{}, {}>;\n\n  constructor(\n    private differs: KeyValueDiffers,\n    @SkipSelf() private scrollbarHelper: ScrollbarHelper,\n    private cd: ChangeDetectorRef,\n    element: ElementRef\n  ) {\n    this._element = element.nativeElement;\n    this._rowDiffer = differs.find({}).create();\n  }\n\n  ngDoCheck(): void {\n    if (this._rowDiffer.diff(this.row)) {\n      this.cd.markForCheck();\n    }\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  buildStylesByGroup() {\n    this._groupStyles.left = this.calcStylesByGroup('left');\n    this._groupStyles.center = this.calcStylesByGroup('center');\n    this._groupStyles.right = this.calcStylesByGroup('right');\n    this.cd.markForCheck();\n  }\n\n  calcStylesByGroup(group: string) {\n    const widths = this._columnGroupWidths;\n    const offsetX = this.offsetX;\n\n    const styles = {\n      width: `${widths[group]}px`\n    };\n\n    if (group === 'left') {\n      translateXY(styles, offsetX, 0);\n    } else if (group === 'right') {\n      const bodyWidth = parseInt(this.innerWidth + '', 0);\n      const totalDiff = widths.total - bodyWidth;\n      const offsetDiff = totalDiff - offsetX;\n      const offset = (offsetDiff + this.scrollbarHelper.width) * -1;\n      translateXY(styles, offset, 0);\n    }\n\n    return styles;\n  }\n\n  onActivate(event: any, index: number): void {\n    event.cellIndex = index;\n    event.rowElement = this._element;\n    this.activate.emit(event);\n  }\n\n  @HostListener('keydown', ['$event'])\n  onKeyDown(event: KeyboardEvent): void {\n    const keyCode = event.keyCode;\n    const isTargetRow = event.target === this._element;\n\n    const isAction =\n      keyCode === Keys.return ||\n      keyCode === Keys.down ||\n      keyCode === Keys.up ||\n      keyCode === Keys.left ||\n      keyCode === Keys.right;\n\n    if (isAction && isTargetRow) {\n      event.preventDefault();\n      event.stopPropagation();\n\n      this.activate.emit({\n        type: 'keydown',\n        event,\n        row: this.row,\n        rowElement: this._element\n      });\n    }\n  }\n\n  @HostListener('mouseenter', ['$event'])\n  onMouseenter(event: any): void {\n    this.activate.emit({\n      type: 'mouseenter',\n      event,\n      row: this.row,\n      rowElement: this._element\n    });\n  }\n\n  recalculateColumns(val: any[] = this.columns): void {\n    this._columns = val;\n    const colsByPin = columnsByPin(this._columns);\n    this._columnsByPin = columnsByPinArr(this._columns);\n    this._columnGroupWidths = columnGroupWidths(colsByPin, this._columns);\n  }\n\n  onTreeAction() {\n    this.treeAction.emit();\n  }\n}\n"]}