import { Injectable, Inject, Directive, TemplateRef, EventEmitter, ElementRef, NgZone, HostBinding, Output, Input, Renderer2, HostListener, KeyValueDiffers, ContentChildren, Component, ChangeDetectionStrategy, ContentChild, ChangeDetectorRef, ViewChild, ViewEncapsulation, SkipSelf, Optional, ViewContainerRef, NgModule } from '@angular/core';
import { DOCUMENT, CommonModule } from '@angular/common';
import { Subject, fromEvent, BehaviorSubject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
import { __values, __spread, __assign, __decorate, __metadata } from 'tslib';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Gets the width of the scrollbar. Nesc for windows
* http://stackoverflow.com/a/13382873/888165
*/
var ScrollbarHelper = /** @class */ (function () {
function ScrollbarHelper(document) {
this.document = document;
this.width = this.getWidth();
}
/**
* @return {?}
*/
ScrollbarHelper.prototype.getWidth = /**
* @return {?}
*/
function () {
/** @type {?} */
var outer = this.document.createElement('div');
outer.style.visibility = 'hidden';
outer.style.width = '100px';
outer.style.msOverflowStyle = 'scrollbar';
this.document.body.appendChild(outer);
/** @type {?} */
var widthNoScroll = outer.offsetWidth;
outer.style.overflow = 'scroll';
/** @type {?} */
var inner = this.document.createElement('div');
inner.style.width = '100%';
outer.appendChild(inner);
/** @type {?} */
var widthWithScroll = inner.offsetWidth;
outer.parentNode.removeChild(outer);
return widthNoScroll - widthWithScroll;
};
ScrollbarHelper.decorators = [
{ type: Injectable }
];
/** @nocollapse */
ScrollbarHelper.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
]; };
return ScrollbarHelper;
}());
if (false) {
/** @type {?} */
ScrollbarHelper.prototype.width;
/**
* @type {?}
* @private
*/
ScrollbarHelper.prototype.document;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Gets the width of the scrollbar. Nesc for windows
* http://stackoverflow.com/a/13382873/888165
*/
var DimensionsHelper = /** @class */ (function () {
function DimensionsHelper() {
}
/**
* @param {?} element
* @return {?}
*/
DimensionsHelper.prototype.getDimensions = /**
* @param {?} element
* @return {?}
*/
function (element) {
return element.getBoundingClientRect();
};
DimensionsHelper.decorators = [
{ type: Injectable }
];
return DimensionsHelper;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* service to make DatatableComponent aware of changes to
* input bindings of DataTableColumnDirective
*/
var ColumnChangesService = /** @class */ (function () {
function ColumnChangesService() {
this.columnInputChanges = new Subject();
}
Object.defineProperty(ColumnChangesService.prototype, "columnInputChanges$", {
get: /**
* @return {?}
*/
function () {
return this.columnInputChanges.asObservable();
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
ColumnChangesService.prototype.onInputChange = /**
* @return {?}
*/
function () {
this.columnInputChanges.next();
};
ColumnChangesService.decorators = [
{ type: Injectable }
];
return ColumnChangesService;
}());
if (false) {
/**
* @type {?}
* @private
*/
ColumnChangesService.prototype.columnInputChanges;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableFooterTemplateDirective = /** @class */ (function () {
function DataTableFooterTemplateDirective(template) {
this.template = template;
}
DataTableFooterTemplateDirective.decorators = [
{ type: Directive, args: [{ selector: '[ngx-datatable-footer-template]' },] }
];
/** @nocollapse */
DataTableFooterTemplateDirective.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DataTableFooterTemplateDirective;
}());
if (false) {
/** @type {?} */
DataTableFooterTemplateDirective.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Visibility Observer Directive
*
* Usage:
*
*
*
*
*/
var VisibilityDirective = /** @class */ (function () {
function VisibilityDirective(element, zone) {
this.element = element;
this.zone = zone;
this.isVisible = false;
this.visible = new EventEmitter();
}
/**
* @return {?}
*/
VisibilityDirective.prototype.ngOnInit = /**
* @return {?}
*/
function () {
this.runCheck();
};
/**
* @return {?}
*/
VisibilityDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
clearTimeout(this.timeout);
};
/**
* @return {?}
*/
VisibilityDirective.prototype.onVisibilityChange = /**
* @return {?}
*/
function () {
var _this = this;
// trigger zone recalc for columns
this.zone.run((/**
* @return {?}
*/
function () {
_this.isVisible = true;
_this.visible.emit(true);
}));
};
/**
* @return {?}
*/
VisibilityDirective.prototype.runCheck = /**
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var check = (/**
* @return {?}
*/
function () {
// https://davidwalsh.name/offsetheight-visibility
var _a = _this.element.nativeElement, offsetHeight = _a.offsetHeight, offsetWidth = _a.offsetWidth;
if (offsetHeight && offsetWidth) {
clearTimeout(_this.timeout);
_this.onVisibilityChange();
}
else {
clearTimeout(_this.timeout);
_this.zone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.timeout = setTimeout((/**
* @return {?}
*/
function () { return check(); }), 50);
}));
}
});
this.timeout = setTimeout((/**
* @return {?}
*/
function () { return check(); }));
};
VisibilityDirective.decorators = [
{ type: Directive, args: [{ selector: '[visibilityObserver]' },] }
];
/** @nocollapse */
VisibilityDirective.ctorParameters = function () { return [
{ type: ElementRef },
{ type: NgZone }
]; };
VisibilityDirective.propDecorators = {
isVisible: [{ type: HostBinding, args: ['class.visible',] }],
visible: [{ type: Output }]
};
return VisibilityDirective;
}());
if (false) {
/** @type {?} */
VisibilityDirective.prototype.isVisible;
/** @type {?} */
VisibilityDirective.prototype.visible;
/** @type {?} */
VisibilityDirective.prototype.timeout;
/**
* @type {?}
* @private
*/
VisibilityDirective.prototype.element;
/**
* @type {?}
* @private
*/
VisibilityDirective.prototype.zone;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* 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
*
*/
var DraggableDirective = /** @class */ (function () {
function DraggableDirective(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;
}
/**
* @param {?} changes
* @return {?}
*/
DraggableDirective.prototype.ngOnChanges = /**
* @param {?} changes
* @return {?}
*/
function (changes) {
if (changes['dragEventTarget'] && changes['dragEventTarget'].currentValue && this.dragModel.dragging) {
this.onMousedown(changes['dragEventTarget'].currentValue);
}
};
/**
* @return {?}
*/
DraggableDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._destroySubscription();
};
/**
* @param {?} event
* @return {?}
*/
DraggableDirective.prototype.onMouseup = /**
* @param {?} event
* @return {?}
*/
function (event) {
if (!this.isDragging)
return;
this.isDragging = false;
this.element.classList.remove('dragging');
if (this.subscription) {
this._destroySubscription();
this.dragEnd.emit({
event: event,
element: this.element,
model: this.dragModel
});
}
};
/**
* @param {?} event
* @return {?}
*/
DraggableDirective.prototype.onMousedown = /**
* @param {?} event
* @return {?}
*/
function (event) {
var _this = this;
// we only want to drag the inner header text
/** @type {?} */
var isDragElm = ((/** @type {?} */ (event.target))).classList.contains('draggable');
if (isDragElm && (this.dragX || this.dragY)) {
event.preventDefault();
this.isDragging = true;
/** @type {?} */
var mouseDownPos_1 = { x: event.clientX, y: event.clientY };
/** @type {?} */
var mouseup = fromEvent(document, 'mouseup');
this.subscription = mouseup.subscribe((/**
* @param {?} ev
* @return {?}
*/
function (ev) { return _this.onMouseup(ev); }));
/** @type {?} */
var mouseMoveSub = fromEvent(document, 'mousemove')
.pipe(takeUntil(mouseup))
.subscribe((/**
* @param {?} ev
* @return {?}
*/
function (ev) { return _this.move(ev, mouseDownPos_1); }));
this.subscription.add(mouseMoveSub);
this.dragStart.emit({
event: event,
element: this.element,
model: this.dragModel
});
}
};
/**
* @param {?} event
* @param {?} mouseDownPos
* @return {?}
*/
DraggableDirective.prototype.move = /**
* @param {?} event
* @param {?} mouseDownPos
* @return {?}
*/
function (event, mouseDownPos) {
if (!this.isDragging)
return;
/** @type {?} */
var x = event.clientX - mouseDownPos.x;
/** @type {?} */
var 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: event,
element: this.element,
model: this.dragModel
});
};
/**
* @private
* @return {?}
*/
DraggableDirective.prototype._destroySubscription = /**
* @private
* @return {?}
*/
function () {
if (this.subscription) {
this.subscription.unsubscribe();
this.subscription = undefined;
}
};
DraggableDirective.decorators = [
{ type: Directive, args: [{ selector: '[draggable]' },] }
];
/** @nocollapse */
DraggableDirective.ctorParameters = function () { return [
{ type: ElementRef }
]; };
DraggableDirective.propDecorators = {
dragEventTarget: [{ type: Input }],
dragModel: [{ type: Input }],
dragX: [{ type: Input }],
dragY: [{ type: Input }],
dragStart: [{ type: Output }],
dragging: [{ type: Output }],
dragEnd: [{ type: Output }]
};
return DraggableDirective;
}());
if (false) {
/** @type {?} */
DraggableDirective.prototype.dragEventTarget;
/** @type {?} */
DraggableDirective.prototype.dragModel;
/** @type {?} */
DraggableDirective.prototype.dragX;
/** @type {?} */
DraggableDirective.prototype.dragY;
/** @type {?} */
DraggableDirective.prototype.dragStart;
/** @type {?} */
DraggableDirective.prototype.dragging;
/** @type {?} */
DraggableDirective.prototype.dragEnd;
/** @type {?} */
DraggableDirective.prototype.element;
/** @type {?} */
DraggableDirective.prototype.isDragging;
/** @type {?} */
DraggableDirective.prototype.subscription;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/* tslint:disable */
/** @type {?} */
var MouseEvent = (/** @type {?} */ ((((/** @type {?} */ ((typeof window !== 'undefined' && window)))) || ((/** @type {?} */ (global))))
.MouseEvent));
/** @type {?} */
var KeyboardEvent = (/** @type {?} */ ((((/** @type {?} */ ((typeof window !== 'undefined' && window)))) || ((/** @type {?} */ (global))))
.KeyboardEvent));
/** @type {?} */
var Event = (/** @type {?} */ ((((/** @type {?} */ ((typeof window !== 'undefined' && window)))) || ((/** @type {?} */ (global)))).Event));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ResizeableDirective = /** @class */ (function () {
function ResizeableDirective(element, renderer) {
this.renderer = renderer;
this.resizeEnabled = true;
this.resize = new EventEmitter();
this.resizing = false;
this.element = element.nativeElement;
}
/**
* @return {?}
*/
ResizeableDirective.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
/** @type {?} */
var renderer2 = this.renderer;
this.resizeHandle = renderer2.createElement('span');
if (this.resizeEnabled) {
renderer2.addClass(this.resizeHandle, 'resize-handle');
}
else {
renderer2.addClass(this.resizeHandle, 'resize-handle--not-resizable');
}
renderer2.appendChild(this.element, this.resizeHandle);
};
/**
* @return {?}
*/
ResizeableDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._destroySubscription();
if (this.renderer.destroyNode) {
this.renderer.destroyNode(this.resizeHandle);
}
else {
this.renderer.removeChild(this.renderer.parentNode(this.resizeHandle), this.resizeHandle);
}
};
/**
* @return {?}
*/
ResizeableDirective.prototype.onMouseup = /**
* @return {?}
*/
function () {
this.resizing = false;
if (this.subscription && !this.subscription.closed) {
this._destroySubscription();
this.resize.emit(this.element.clientWidth);
}
};
/**
* @param {?} event
* @return {?}
*/
ResizeableDirective.prototype.onMousedown = /**
* @param {?} event
* @return {?}
*/
function (event) {
var _this = this;
/** @type {?} */
var isHandle = ((/** @type {?} */ (event.target))).classList.contains('resize-handle');
/** @type {?} */
var initialWidth = this.element.clientWidth;
/** @type {?} */
var mouseDownScreenX = event.screenX;
if (isHandle) {
event.stopPropagation();
this.resizing = true;
/** @type {?} */
var mouseup = fromEvent(document, 'mouseup');
this.subscription = mouseup.subscribe((/**
* @param {?} ev
* @return {?}
*/
function (ev) { return _this.onMouseup(); }));
/** @type {?} */
var mouseMoveSub = fromEvent(document, 'mousemove')
.pipe(takeUntil(mouseup))
.subscribe((/**
* @param {?} e
* @return {?}
*/
function (e) { return _this.move(e, initialWidth, mouseDownScreenX); }));
this.subscription.add(mouseMoveSub);
}
};
/**
* @param {?} event
* @param {?} initialWidth
* @param {?} mouseDownScreenX
* @return {?}
*/
ResizeableDirective.prototype.move = /**
* @param {?} event
* @param {?} initialWidth
* @param {?} mouseDownScreenX
* @return {?}
*/
function (event, initialWidth, mouseDownScreenX) {
/** @type {?} */
var movementX = event.screenX - mouseDownScreenX;
/** @type {?} */
var newWidth = initialWidth + movementX;
/** @type {?} */
var overMinWidth = !this.minWidth || newWidth >= this.minWidth;
/** @type {?} */
var underMaxWidth = !this.maxWidth || newWidth <= this.maxWidth;
if (overMinWidth && underMaxWidth) {
this.element.style.width = newWidth + "px";
}
};
/**
* @private
* @return {?}
*/
ResizeableDirective.prototype._destroySubscription = /**
* @private
* @return {?}
*/
function () {
if (this.subscription) {
this.subscription.unsubscribe();
this.subscription = undefined;
}
};
ResizeableDirective.decorators = [
{ type: Directive, args: [{
selector: '[resizeable]',
host: {
'[class.resizeable]': 'resizeEnabled'
}
},] }
];
/** @nocollapse */
ResizeableDirective.ctorParameters = function () { return [
{ type: ElementRef },
{ type: Renderer2 }
]; };
ResizeableDirective.propDecorators = {
resizeEnabled: [{ type: Input }],
minWidth: [{ type: Input }],
maxWidth: [{ type: Input }],
resize: [{ type: Output }],
onMousedown: [{ type: HostListener, args: ['mousedown', ['$event'],] }]
};
return ResizeableDirective;
}());
if (false) {
/** @type {?} */
ResizeableDirective.prototype.resizeEnabled;
/** @type {?} */
ResizeableDirective.prototype.minWidth;
/** @type {?} */
ResizeableDirective.prototype.maxWidth;
/** @type {?} */
ResizeableDirective.prototype.resize;
/** @type {?} */
ResizeableDirective.prototype.element;
/** @type {?} */
ResizeableDirective.prototype.subscription;
/** @type {?} */
ResizeableDirective.prototype.resizing;
/**
* @type {?}
* @private
*/
ResizeableDirective.prototype.resizeHandle;
/**
* @type {?}
* @private
*/
ResizeableDirective.prototype.renderer;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var OrderableDirective = /** @class */ (function () {
function OrderableDirective(differs, document) {
this.document = document;
this.reorder = new EventEmitter();
this.targetChanged = new EventEmitter();
this.differ = differs.find({}).create();
}
/**
* @return {?}
*/
OrderableDirective.prototype.ngAfterContentInit = /**
* @return {?}
*/
function () {
// HACK: Investigate Better Way
this.updateSubscriptions();
this.draggables.changes.subscribe(this.updateSubscriptions.bind(this));
};
/**
* @return {?}
*/
OrderableDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.draggables.forEach((/**
* @param {?} d
* @return {?}
*/
function (d) {
d.dragStart.unsubscribe();
d.dragging.unsubscribe();
d.dragEnd.unsubscribe();
}));
};
/**
* @return {?}
*/
OrderableDirective.prototype.updateSubscriptions = /**
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var diffs = this.differ.diff(this.createMapDiffs());
if (diffs) {
/** @type {?} */
var subscribe = (/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var currentValue = _a.currentValue, previousValue = _a.previousValue;
unsubscribe_1({ previousValue: previousValue });
if (currentValue) {
currentValue.dragStart.subscribe(_this.onDragStart.bind(_this));
currentValue.dragging.subscribe(_this.onDragging.bind(_this));
currentValue.dragEnd.subscribe(_this.onDragEnd.bind(_this));
}
});
/** @type {?} */
var unsubscribe_1 = (/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var previousValue = _a.previousValue;
if (previousValue) {
previousValue.dragStart.unsubscribe();
previousValue.dragging.unsubscribe();
previousValue.dragEnd.unsubscribe();
}
});
diffs.forEachAddedItem(subscribe);
// diffs.forEachChangedItem(subscribe.bind(this));
diffs.forEachRemovedItem(unsubscribe_1);
}
};
/**
* @return {?}
*/
OrderableDirective.prototype.onDragStart = /**
* @return {?}
*/
function () {
var e_1, _a;
this.positions = {};
/** @type {?} */
var i = 0;
try {
for (var _b = __values(this.draggables.toArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
var dragger = _c.value;
/** @type {?} */
var elm = dragger.element;
/** @type {?} */
var left = parseInt(elm.offsetLeft.toString(), 0);
this.positions[dragger.dragModel.prop] = {
left: left,
right: left + parseInt(elm.offsetWidth.toString(), 0),
index: i++,
element: elm
};
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
};
/**
* @param {?} __0
* @return {?}
*/
OrderableDirective.prototype.onDragging = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var element = _a.element, model = _a.model, event = _a.event;
/** @type {?} */
var prevPos = this.positions[model.prop];
/** @type {?} */
var target = this.isTarget(model, event);
if (target) {
if (this.lastDraggingIndex !== target.i) {
this.targetChanged.emit({
prevIndex: this.lastDraggingIndex,
newIndex: target.i,
initialIndex: prevPos.index
});
this.lastDraggingIndex = target.i;
}
}
else if (this.lastDraggingIndex !== prevPos.index) {
this.targetChanged.emit({
prevIndex: this.lastDraggingIndex,
initialIndex: prevPos.index
});
this.lastDraggingIndex = prevPos.index;
}
};
/**
* @param {?} __0
* @return {?}
*/
OrderableDirective.prototype.onDragEnd = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var element = _a.element, model = _a.model, event = _a.event;
/** @type {?} */
var prevPos = this.positions[model.prop];
/** @type {?} */
var target = this.isTarget(model, event);
if (target) {
this.reorder.emit({
prevIndex: prevPos.index,
newIndex: target.i,
model: model
});
}
this.lastDraggingIndex = undefined;
element.style.left = 'auto';
};
/**
* @param {?} model
* @param {?} event
* @return {?}
*/
OrderableDirective.prototype.isTarget = /**
* @param {?} model
* @param {?} event
* @return {?}
*/
function (model, event) {
/** @type {?} */
var i = 0;
/** @type {?} */
var x = event.x || event.clientX;
/** @type {?} */
var y = event.y || event.clientY;
/** @type {?} */
var targets = this.document.elementsFromPoint(x, y);
var _loop_1 = function (prop) {
// current column position which throws event.
/** @type {?} */
var pos = this_1.positions[prop];
// since we drag the inner span, we need to find it in the elements at the cursor
if (model.prop !== prop && targets.find((/**
* @param {?} el
* @return {?}
*/
function (el) { return el === pos.element; }))) {
return { value: {
pos: pos,
i: i
} };
}
i++;
};
var this_1 = this;
for (var prop in this.positions) {
var state_1 = _loop_1(prop);
if (typeof state_1 === "object")
return state_1.value;
}
};
/**
* @private
* @return {?}
*/
OrderableDirective.prototype.createMapDiffs = /**
* @private
* @return {?}
*/
function () {
return this.draggables.toArray().reduce((/**
* @param {?} acc
* @param {?} curr
* @return {?}
*/
function (acc, curr) {
acc[curr.dragModel.$$id] = curr;
return acc;
}), {});
};
OrderableDirective.decorators = [
{ type: Directive, args: [{ selector: '[orderable]' },] }
];
/** @nocollapse */
OrderableDirective.ctorParameters = function () { return [
{ type: KeyValueDiffers },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
]; };
OrderableDirective.propDecorators = {
reorder: [{ type: Output }],
targetChanged: [{ type: Output }],
draggables: [{ type: ContentChildren, args: [DraggableDirective, { descendants: true },] }]
};
return OrderableDirective;
}());
if (false) {
/** @type {?} */
OrderableDirective.prototype.reorder;
/** @type {?} */
OrderableDirective.prototype.targetChanged;
/** @type {?} */
OrderableDirective.prototype.draggables;
/** @type {?} */
OrderableDirective.prototype.positions;
/** @type {?} */
OrderableDirective.prototype.differ;
/** @type {?} */
OrderableDirective.prototype.lastDraggingIndex;
/**
* @type {?}
* @private
*/
OrderableDirective.prototype.document;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LongPressDirective = /** @class */ (function () {
function LongPressDirective() {
this.pressEnabled = true;
this.duration = 500;
this.longPressStart = new EventEmitter();
this.longPressing = new EventEmitter();
this.longPressEnd = new EventEmitter();
this.mouseX = 0;
this.mouseY = 0;
}
Object.defineProperty(LongPressDirective.prototype, "press", {
get: /**
* @return {?}
*/
function () {
return this.pressing;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LongPressDirective.prototype, "isLongPress", {
get: /**
* @return {?}
*/
function () {
return this.isLongPressing;
},
enumerable: true,
configurable: true
});
/**
* @param {?} event
* @return {?}
*/
LongPressDirective.prototype.onMouseDown = /**
* @param {?} event
* @return {?}
*/
function (event) {
var _this = this;
// don't do right/middle clicks
if (event.which !== 1 || !this.pressEnabled)
return;
// don't start drag if its on resize handle
/** @type {?} */
var target = (/** @type {?} */ (event.target));
if (target.classList.contains('resize-handle'))
return;
this.mouseX = event.clientX;
this.mouseY = event.clientY;
this.pressing = true;
this.isLongPressing = false;
/** @type {?} */
var mouseup = fromEvent(document, 'mouseup');
this.subscription = mouseup.subscribe((/**
* @param {?} ev
* @return {?}
*/
function (ev) { return _this.onMouseup(); }));
this.timeout = setTimeout((/**
* @return {?}
*/
function () {
_this.isLongPressing = true;
_this.longPressStart.emit({
event: event,
model: _this.pressModel
});
_this.subscription.add(fromEvent(document, 'mousemove')
.pipe(takeUntil(mouseup))
.subscribe((/**
* @param {?} mouseEvent
* @return {?}
*/
function (mouseEvent) { return _this.onMouseMove(mouseEvent); })));
_this.loop(event);
}), this.duration);
this.loop(event);
};
/**
* @param {?} event
* @return {?}
*/
LongPressDirective.prototype.onMouseMove = /**
* @param {?} event
* @return {?}
*/
function (event) {
if (this.pressing && !this.isLongPressing) {
/** @type {?} */
var xThres = Math.abs(event.clientX - this.mouseX) > 10;
/** @type {?} */
var yThres = Math.abs(event.clientY - this.mouseY) > 10;
if (xThres || yThres) {
this.endPress();
}
}
};
/**
* @param {?} event
* @return {?}
*/
LongPressDirective.prototype.loop = /**
* @param {?} event
* @return {?}
*/
function (event) {
var _this = this;
if (this.isLongPressing) {
this.timeout = setTimeout((/**
* @return {?}
*/
function () {
_this.longPressing.emit({
event: event,
model: _this.pressModel
});
_this.loop(event);
}), 50);
}
};
/**
* @return {?}
*/
LongPressDirective.prototype.endPress = /**
* @return {?}
*/
function () {
clearTimeout(this.timeout);
this.isLongPressing = false;
this.pressing = false;
this._destroySubscription();
this.longPressEnd.emit({
model: this.pressModel
});
};
/**
* @return {?}
*/
LongPressDirective.prototype.onMouseup = /**
* @return {?}
*/
function () {
this.endPress();
};
/**
* @return {?}
*/
LongPressDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._destroySubscription();
};
/**
* @private
* @return {?}
*/
LongPressDirective.prototype._destroySubscription = /**
* @private
* @return {?}
*/
function () {
if (this.subscription) {
this.subscription.unsubscribe();
this.subscription = undefined;
}
};
LongPressDirective.decorators = [
{ type: Directive, args: [{ selector: '[long-press]' },] }
];
LongPressDirective.propDecorators = {
pressEnabled: [{ type: Input }],
pressModel: [{ type: Input }],
duration: [{ type: Input }],
longPressStart: [{ type: Output }],
longPressing: [{ type: Output }],
longPressEnd: [{ type: Output }],
press: [{ type: HostBinding, args: ['class.press',] }],
isLongPress: [{ type: HostBinding, args: ['class.longpress',] }],
onMouseDown: [{ type: HostListener, args: ['mousedown', ['$event'],] }]
};
return LongPressDirective;
}());
if (false) {
/** @type {?} */
LongPressDirective.prototype.pressEnabled;
/** @type {?} */
LongPressDirective.prototype.pressModel;
/** @type {?} */
LongPressDirective.prototype.duration;
/** @type {?} */
LongPressDirective.prototype.longPressStart;
/** @type {?} */
LongPressDirective.prototype.longPressing;
/** @type {?} */
LongPressDirective.prototype.longPressEnd;
/** @type {?} */
LongPressDirective.prototype.pressing;
/** @type {?} */
LongPressDirective.prototype.isLongPressing;
/** @type {?} */
LongPressDirective.prototype.timeout;
/** @type {?} */
LongPressDirective.prototype.mouseX;
/** @type {?} */
LongPressDirective.prototype.mouseY;
/** @type {?} */
LongPressDirective.prototype.subscription;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ScrollerComponent = /** @class */ (function () {
function ScrollerComponent(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;
}
/**
* @return {?}
*/
ScrollerComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
// manual bind so we don't always listen
if (this.scrollbarV || this.scrollbarH) {
/** @type {?} */
var renderer = this.renderer;
this.parentElement = renderer.parentNode(renderer.parentNode(this.element));
this._scrollEventListener = this.onScrolled.bind(this);
this.parentElement.addEventListener('scroll', this._scrollEventListener);
}
};
/**
* @return {?}
*/
ScrollerComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
if (this._scrollEventListener) {
this.parentElement.removeEventListener('scroll', this._scrollEventListener);
this._scrollEventListener = null;
}
};
/**
* @param {?} offsetY
* @return {?}
*/
ScrollerComponent.prototype.setOffset = /**
* @param {?} offsetY
* @return {?}
*/
function (offsetY) {
if (this.parentElement) {
this.parentElement.scrollTop = offsetY;
}
};
/**
* @param {?} event
* @return {?}
*/
ScrollerComponent.prototype.onScrolled = /**
* @param {?} event
* @return {?}
*/
function (event) {
var _this = this;
/** @type {?} */
var dom = (/** @type {?} */ (event.currentTarget));
requestAnimationFrame((/**
* @return {?}
*/
function () {
_this.scrollYPos = dom.scrollTop;
_this.scrollXPos = dom.scrollLeft;
_this.updateOffset();
}));
};
/**
* @return {?}
*/
ScrollerComponent.prototype.updateOffset = /**
* @return {?}
*/
function () {
/** @type {?} */
var direction;
if (this.scrollYPos < this.prevScrollYPos) {
direction = 'down';
}
else if (this.scrollYPos > this.prevScrollYPos) {
direction = 'up';
}
this.scroll.emit({
direction: direction,
scrollYPos: this.scrollYPos,
scrollXPos: this.scrollXPos
});
this.prevScrollYPos = this.scrollYPos;
this.prevScrollXPos = this.scrollXPos;
};
ScrollerComponent.decorators = [
{ type: Component, args: [{
selector: 'datatable-scroller',
template: "\n \n ",
host: {
class: 'datatable-scroll'
},
changeDetection: ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
ScrollerComponent.ctorParameters = function () { return [
{ type: NgZone },
{ type: ElementRef },
{ type: Renderer2 }
]; };
ScrollerComponent.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 }]
};
return ScrollerComponent;
}());
if (false) {
/** @type {?} */
ScrollerComponent.prototype.scrollbarV;
/** @type {?} */
ScrollerComponent.prototype.scrollbarH;
/** @type {?} */
ScrollerComponent.prototype.scrollHeight;
/** @type {?} */
ScrollerComponent.prototype.scrollWidth;
/** @type {?} */
ScrollerComponent.prototype.scroll;
/** @type {?} */
ScrollerComponent.prototype.scrollYPos;
/** @type {?} */
ScrollerComponent.prototype.scrollXPos;
/** @type {?} */
ScrollerComponent.prototype.prevScrollYPos;
/** @type {?} */
ScrollerComponent.prototype.prevScrollXPos;
/** @type {?} */
ScrollerComponent.prototype.element;
/** @type {?} */
ScrollerComponent.prototype.parentElement;
/** @type {?} */
ScrollerComponent.prototype.onScrollListener;
/**
* @type {?}
* @private
*/
ScrollerComponent.prototype._scrollEventListener;
/**
* @type {?}
* @private
*/
ScrollerComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
ScrollerComponent.prototype.renderer;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DatatableGroupHeaderTemplateDirective = /** @class */ (function () {
function DatatableGroupHeaderTemplateDirective(template) {
this.template = template;
}
DatatableGroupHeaderTemplateDirective.decorators = [
{ type: Directive, args: [{
selector: '[ngx-datatable-group-header-template]'
},] }
];
/** @nocollapse */
DatatableGroupHeaderTemplateDirective.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DatatableGroupHeaderTemplateDirective;
}());
if (false) {
/** @type {?} */
DatatableGroupHeaderTemplateDirective.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DatatableGroupHeaderDirective = /** @class */ (function () {
function DatatableGroupHeaderDirective() {
/**
* Row height is required when virtual scroll is enabled.
*/
this.rowHeight = 0;
/**
* Track toggling of group visibility
*/
this.toggle = new EventEmitter();
}
Object.defineProperty(DatatableGroupHeaderDirective.prototype, "template", {
get: /**
* @return {?}
*/
function () {
return this._templateInput || this._templateQuery;
},
enumerable: true,
configurable: true
});
/**
* Toggle the expansion of a group
*/
/**
* Toggle the expansion of a group
* @param {?} group
* @return {?}
*/
DatatableGroupHeaderDirective.prototype.toggleExpandGroup = /**
* Toggle the expansion of a group
* @param {?} group
* @return {?}
*/
function (group) {
this.toggle.emit({
type: 'group',
value: group
});
};
/**
* Expand all groups
*/
/**
* Expand all groups
* @return {?}
*/
DatatableGroupHeaderDirective.prototype.expandAllGroups = /**
* Expand all groups
* @return {?}
*/
function () {
this.toggle.emit({
type: 'all',
value: true
});
};
/**
* Collapse all groups
*/
/**
* Collapse all groups
* @return {?}
*/
DatatableGroupHeaderDirective.prototype.collapseAllGroups = /**
* Collapse all groups
* @return {?}
*/
function () {
this.toggle.emit({
type: 'all',
value: false
});
};
DatatableGroupHeaderDirective.decorators = [
{ type: Directive, args: [{ selector: 'ngx-datatable-group-header' },] }
];
DatatableGroupHeaderDirective.propDecorators = {
rowHeight: [{ type: Input }],
_templateInput: [{ type: Input, args: ['template',] }],
_templateQuery: [{ type: ContentChild, args: [DatatableGroupHeaderTemplateDirective, { read: TemplateRef, static: true },] }],
toggle: [{ type: Output }]
};
return DatatableGroupHeaderDirective;
}());
if (false) {
/**
* Row height is required when virtual scroll is enabled.
* @type {?}
*/
DatatableGroupHeaderDirective.prototype.rowHeight;
/** @type {?} */
DatatableGroupHeaderDirective.prototype._templateInput;
/** @type {?} */
DatatableGroupHeaderDirective.prototype._templateQuery;
/**
* Track toggling of group visibility
* @type {?}
*/
DatatableGroupHeaderDirective.prototype.toggle;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Always returns the empty string ''
* @return {?}
*/
function emptyStringGetter() {
return '';
}
/**
* Returns the appropriate getter function for this kind of prop.
* If prop == null, returns the emptyStringGetter.
* @param {?} prop
* @return {?}
*/
function getterForProp(prop) {
if (prop == null) {
return emptyStringGetter;
}
if (typeof prop === 'number') {
return numericIndexGetter;
}
else {
// deep or simple
if (prop.indexOf('.') !== -1) {
return deepValueGetter;
}
else {
return shallowValueGetter;
}
}
}
/**
* Returns the value at this numeric index.
* @param {?} row array of values
* @param {?} index numeric index
* @return {?} any or '' if invalid index
*/
function numericIndexGetter(row, index) {
if (row == null) {
return '';
}
// mimic behavior of deepValueGetter
if (!row || index == null) {
return row;
}
/** @type {?} */
var value = row[index];
if (value == null) {
return '';
}
return value;
}
/**
* Returns the value of a field.
* (more efficient than deepValueGetter)
* @param {?} obj object containing the field
* @param {?} fieldName field name string
* @return {?}
*/
function shallowValueGetter(obj, fieldName) {
if (obj == null) {
return '';
}
if (!obj || !fieldName) {
return obj;
}
/** @type {?} */
var value = obj[fieldName];
if (value == null) {
return '';
}
return value;
}
/**
* Returns a deep object given a string. zoo['animal.type']
* @param {?} obj
* @param {?} path
* @return {?}
*/
function deepValueGetter(obj, path) {
if (obj == null) {
return '';
}
if (!obj || !path) {
return obj;
}
// check if path matches a root-level field
// { "a.b.c": 123 }
/** @type {?} */
var current = obj[path];
if (current !== undefined) {
return current;
}
current = obj;
/** @type {?} */
var split = path.split('.');
if (split.length) {
for (var i = 0; i < split.length; i++) {
current = current[split[i]];
// if found undefined, return empty string
if (current === undefined || current === null) {
return '';
}
}
}
return current;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} prop
* @return {?}
*/
function optionalGetterForProp(prop) {
return prop && ((/**
* @param {?} row
* @return {?}
*/
function (row) { return getterForProp(prop)(row, prop); }));
}
/**
* This functions rearrange items by their parents
* Also sets the level value to each of the items
*
* Note: Expecting each item has a property called parentId
* Note: This algorithm will fail if a list has two or more items with same ID
* NOTE: This algorithm will fail if there is a deadlock of relationship
*
* For example,
*
* Input
*
* id -> parent
* 1 -> 0
* 2 -> 0
* 3 -> 1
* 4 -> 1
* 5 -> 2
* 7 -> 8
* 6 -> 3
*
*
* Output
* id -> level
* 1 -> 0
* --3 -> 1
* ----6 -> 2
* --4 -> 1
* 2 -> 0
* --5 -> 1
* 7 -> 8
*
*
* @param {?} rows
*
* @param {?=} from
* @param {?=} to
* @return {?}
*/
function groupRowsByParents(rows, from, to) {
if (from && to) {
/** @type {?} */
var nodeById = {};
/** @type {?} */
var l = rows.length;
/** @type {?} */
var node = null;
nodeById[0] = new TreeNode(); // that's the root node
// that's the root node
/** @type {?} */
var uniqIDs = rows.reduce((/**
* @param {?} arr
* @param {?} item
* @return {?}
*/
function (arr, item) {
/** @type {?} */
var toValue = to(item);
if (arr.indexOf(toValue) === -1) {
arr.push(toValue);
}
return arr;
}), []);
for (var i = 0; i < l; i++) {
// make TreeNode objects for each item
nodeById[to(rows[i])] = new TreeNode(rows[i]);
}
for (var i = 0; i < l; i++) {
// link all TreeNode objects
node = nodeById[to(rows[i])];
/** @type {?} */
var parent_1 = 0;
/** @type {?} */
var fromValue = from(node.row);
if (!!fromValue && uniqIDs.indexOf(fromValue) > -1) {
parent_1 = fromValue;
}
node.parent = nodeById[parent_1];
node.row['level'] = node.parent.row['level'] + 1;
node.parent.children.push(node);
}
/** @type {?} */
var resolvedRows_1 = [];
nodeById[0].flatten((/**
* @return {?}
*/
function () {
resolvedRows_1 = __spread(resolvedRows_1, [this.row]);
}), true);
return resolvedRows_1;
}
else {
return rows;
}
}
var TreeNode = /** @class */ (function () {
function TreeNode(row) {
if (row === void 0) { row = null; }
if (!row) {
row = {
level: -1,
treeStatus: 'expanded'
};
}
this.row = row;
this.parent = null;
this.children = [];
}
/**
* @param {?} f
* @param {?} recursive
* @return {?}
*/
TreeNode.prototype.flatten = /**
* @param {?} f
* @param {?} recursive
* @return {?}
*/
function (f, recursive) {
if (this.row['treeStatus'] === 'expanded') {
for (var i = 0, l = this.children.length; i < l; i++) {
/** @type {?} */
var child = this.children[i];
f.apply(child, Array.prototype.slice.call(arguments, 2));
if (recursive)
child.flatten.apply(child, arguments);
}
}
};
return TreeNode;
}());
if (false) {
/** @type {?} */
TreeNode.prototype.row;
/** @type {?} */
TreeNode.prototype.parent;
/** @type {?} */
TreeNode.prototype.children;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Converts strings from something to camel case
* http://stackoverflow.com/questions/10425287/convert-dash-separated-string-to-camelcase
* @param {?} str
* @return {?}
*/
function camelCase(str) {
// Replace special characters with a space
str = str.replace(/[^a-zA-Z0-9 ]/g, ' ');
// put a space before an uppercase letter
str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
// Lower case first character and some other stuff
str = str
.replace(/([^a-zA-Z0-9 ])|^[0-9]+/g, '')
.trim()
.toLowerCase();
// uppercase characters preceded by a space or number
str = str.replace(/([ 0-9]+)([a-zA-Z])/g, (/**
* @param {?} a
* @param {?} b
* @param {?} c
* @return {?}
*/
function (a, b, c) {
return b.trim() + c.toUpperCase();
}));
return str;
}
/**
* Converts strings from camel case to words
* http://stackoverflow.com/questions/7225407/convert-camelcasetext-to-camel-case-text
* @param {?} str
* @return {?}
*/
function deCamelCase(str) {
return str.replace(/([A-Z])/g, (/**
* @param {?} match
* @return {?}
*/
function (match) { return " " + match; })).replace(/^./, (/**
* @param {?} match
* @return {?}
*/
function (match) { return match.toUpperCase(); }));
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Creates a unique object id.
* http://stackoverflow.com/questions/6248666/how-to-generate-short-uid-like-ax4j9z-in-js
* @return {?}
*/
function id() {
return ('0000' + ((Math.random() * Math.pow(36, 4)) << 0).toString(36)).slice(-4);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Sets the column defaults
* @param {?} columns
* @return {?}
*/
function setColumnDefaults(columns) {
var e_1, _a;
if (!columns)
return;
// Only one column should hold the tree view
// Thus if multiple columns are provided with
// isTreeColumn as true we take only the first one
/** @type {?} */
var treeColumnFound = false;
try {
for (var columns_1 = __values(columns), columns_1_1 = columns_1.next(); !columns_1_1.done; columns_1_1 = columns_1.next()) {
var column = columns_1_1.value;
if (!column.$$id) {
column.$$id = id();
}
// prop can be numeric; zero is valid not a missing prop
// translate name => prop
if (isNullOrUndefined(column.prop) && column.name) {
column.prop = camelCase(column.name);
}
if (!column.$$valueGetter) {
column.$$valueGetter = getterForProp(column.prop);
}
// format props if no name passed
if (!isNullOrUndefined(column.prop) && isNullOrUndefined(column.name)) {
column.name = deCamelCase(String(column.prop));
}
if (isNullOrUndefined(column.prop) && isNullOrUndefined(column.name)) {
column.name = ''; // Fixes IE and Edge displaying `null`
}
if (!column.hasOwnProperty('resizeable')) {
column.resizeable = true;
}
if (!column.hasOwnProperty('sortable')) {
column.sortable = true;
}
if (!column.hasOwnProperty('draggable')) {
column.draggable = true;
}
if (!column.hasOwnProperty('canAutoResize')) {
column.canAutoResize = true;
}
if (!column.hasOwnProperty('width')) {
column.width = 150;
}
if (!column.hasOwnProperty('isTreeColumn')) {
column.isTreeColumn = false;
}
else {
if (column.isTreeColumn && !treeColumnFound) {
// If the first column with isTreeColumn is true found
// we mark that treeCoulmn is found
treeColumnFound = true;
}
else {
// After that isTreeColumn property for any other column
// will be set as false
column.isTreeColumn = false;
}
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (columns_1_1 && !columns_1_1.done && (_a = columns_1.return)) _a.call(columns_1);
}
finally { if (e_1) throw e_1.error; }
}
}
/**
* @template T
* @param {?} value
* @return {?}
*/
function isNullOrUndefined(value) {
return value === null || value === undefined;
}
/**
* Translates templates definitions to objects
* @param {?} templates
* @return {?}
*/
function translateTemplates(templates) {
var e_2, _a, e_3, _b;
/** @type {?} */
var result = [];
try {
for (var templates_1 = __values(templates), templates_1_1 = templates_1.next(); !templates_1_1.done; templates_1_1 = templates_1.next()) {
var temp = templates_1_1.value;
/** @type {?} */
var col = {};
/** @type {?} */
var props = Object.getOwnPropertyNames(temp);
try {
for (var props_1 = (e_3 = void 0, __values(props)), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
var prop = props_1_1.value;
col[prop] = temp[prop];
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (props_1_1 && !props_1_1.done && (_b = props_1.return)) _b.call(props_1);
}
finally { if (e_3) throw e_3.error; }
}
if (temp.headerTemplate) {
col.headerTemplate = temp.headerTemplate;
}
if (temp.cellTemplate) {
col.cellTemplate = temp.cellTemplate;
}
if (temp.summaryFunc) {
col.summaryFunc = temp.summaryFunc;
}
if (temp.summaryTemplate) {
col.summaryTemplate = temp.summaryTemplate;
}
result.push(col);
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (templates_1_1 && !templates_1_1.done && (_a = templates_1.return)) _a.call(templates_1);
}
finally { if (e_2) throw e_2.error; }
}
return result;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var ColumnMode = {
standard: 'standard',
flex: 'flex',
force: 'force',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var SelectionType = {
single: 'single',
multi: 'multi',
multiClick: 'multiClick',
cell: 'cell',
checkbox: 'checkbox',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var SortType = {
single: 'single',
multi: 'multi',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {string} */
var ContextmenuType = {
header: 'header',
body: 'body',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableColumnHeaderDirective = /** @class */ (function () {
function DataTableColumnHeaderDirective(template) {
this.template = template;
}
DataTableColumnHeaderDirective.decorators = [
{ type: Directive, args: [{ selector: '[ngx-datatable-header-template]' },] }
];
/** @nocollapse */
DataTableColumnHeaderDirective.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DataTableColumnHeaderDirective;
}());
if (false) {
/** @type {?} */
DataTableColumnHeaderDirective.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableColumnCellDirective = /** @class */ (function () {
function DataTableColumnCellDirective(template) {
this.template = template;
}
DataTableColumnCellDirective.decorators = [
{ type: Directive, args: [{ selector: '[ngx-datatable-cell-template]' },] }
];
/** @nocollapse */
DataTableColumnCellDirective.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DataTableColumnCellDirective;
}());
if (false) {
/** @type {?} */
DataTableColumnCellDirective.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableColumnCellTreeToggle = /** @class */ (function () {
function DataTableColumnCellTreeToggle(template) {
this.template = template;
}
DataTableColumnCellTreeToggle.decorators = [
{ type: Directive, args: [{ selector: '[ngx-datatable-tree-toggle]' },] }
];
/** @nocollapse */
DataTableColumnCellTreeToggle.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DataTableColumnCellTreeToggle;
}());
if (false) {
/** @type {?} */
DataTableColumnCellTreeToggle.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableColumnDirective = /** @class */ (function () {
function DataTableColumnDirective(columnChangesService) {
this.columnChangesService = columnChangesService;
this.isFirstChange = true;
}
Object.defineProperty(DataTableColumnDirective.prototype, "cellTemplate", {
get: /**
* @return {?}
*/
function () {
return this._cellTemplateInput || this._cellTemplateQuery;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableColumnDirective.prototype, "headerTemplate", {
get: /**
* @return {?}
*/
function () {
return this._headerTemplateInput || this._headerTemplateQuery;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableColumnDirective.prototype, "treeToggleTemplate", {
get: /**
* @return {?}
*/
function () {
return this._treeToggleTemplateInput || this._treeToggleTemplateQuery;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
DataTableColumnDirective.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
if (this.isFirstChange) {
this.isFirstChange = false;
}
else {
this.columnChangesService.onInputChange();
}
};
DataTableColumnDirective.decorators = [
{ type: Directive, args: [{ selector: 'ngx-datatable-column' },] }
];
/** @nocollapse */
DataTableColumnDirective.ctorParameters = function () { return [
{ type: ColumnChangesService }
]; };
DataTableColumnDirective.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 },] }]
};
return DataTableColumnDirective;
}());
if (false) {
/** @type {?} */
DataTableColumnDirective.prototype.name;
/** @type {?} */
DataTableColumnDirective.prototype.prop;
/** @type {?} */
DataTableColumnDirective.prototype.frozenLeft;
/** @type {?} */
DataTableColumnDirective.prototype.frozenRight;
/** @type {?} */
DataTableColumnDirective.prototype.flexGrow;
/** @type {?} */
DataTableColumnDirective.prototype.resizeable;
/** @type {?} */
DataTableColumnDirective.prototype.comparator;
/** @type {?} */
DataTableColumnDirective.prototype.pipe;
/** @type {?} */
DataTableColumnDirective.prototype.sortable;
/** @type {?} */
DataTableColumnDirective.prototype.draggable;
/** @type {?} */
DataTableColumnDirective.prototype.canAutoResize;
/** @type {?} */
DataTableColumnDirective.prototype.minWidth;
/** @type {?} */
DataTableColumnDirective.prototype.width;
/** @type {?} */
DataTableColumnDirective.prototype.maxWidth;
/** @type {?} */
DataTableColumnDirective.prototype.checkboxable;
/** @type {?} */
DataTableColumnDirective.prototype.headerCheckboxable;
/** @type {?} */
DataTableColumnDirective.prototype.headerClass;
/** @type {?} */
DataTableColumnDirective.prototype.cellClass;
/** @type {?} */
DataTableColumnDirective.prototype.isTreeColumn;
/** @type {?} */
DataTableColumnDirective.prototype.treeLevelIndent;
/** @type {?} */
DataTableColumnDirective.prototype.summaryFunc;
/** @type {?} */
DataTableColumnDirective.prototype.summaryTemplate;
/** @type {?} */
DataTableColumnDirective.prototype._cellTemplateInput;
/** @type {?} */
DataTableColumnDirective.prototype._cellTemplateQuery;
/** @type {?} */
DataTableColumnDirective.prototype._headerTemplateInput;
/** @type {?} */
DataTableColumnDirective.prototype._headerTemplateQuery;
/** @type {?} */
DataTableColumnDirective.prototype._treeToggleTemplateInput;
/** @type {?} */
DataTableColumnDirective.prototype._treeToggleTemplateQuery;
/**
* @type {?}
* @private
*/
DataTableColumnDirective.prototype.isFirstChange;
/**
* @type {?}
* @private
*/
DataTableColumnDirective.prototype.columnChangesService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DatatableRowDetailTemplateDirective = /** @class */ (function () {
function DatatableRowDetailTemplateDirective(template) {
this.template = template;
}
DatatableRowDetailTemplateDirective.decorators = [
{ type: Directive, args: [{
selector: '[ngx-datatable-row-detail-template]'
},] }
];
/** @nocollapse */
DatatableRowDetailTemplateDirective.ctorParameters = function () { return [
{ type: TemplateRef }
]; };
return DatatableRowDetailTemplateDirective;
}());
if (false) {
/** @type {?} */
DatatableRowDetailTemplateDirective.prototype.template;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DatatableRowDetailDirective = /** @class */ (function () {
function DatatableRowDetailDirective() {
/**
* 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();
}
Object.defineProperty(DatatableRowDetailDirective.prototype, "template", {
get: /**
* @return {?}
*/
function () {
return this._templateInput || this._templateQuery;
},
enumerable: true,
configurable: true
});
/**
* Toggle the expansion of the row
*/
/**
* Toggle the expansion of the row
* @param {?} row
* @return {?}
*/
DatatableRowDetailDirective.prototype.toggleExpandRow = /**
* Toggle the expansion of the row
* @param {?} row
* @return {?}
*/
function (row) {
this.toggle.emit({
type: 'row',
value: row
});
};
/**
* API method to expand all the rows.
*/
/**
* API method to expand all the rows.
* @return {?}
*/
DatatableRowDetailDirective.prototype.expandAllRows = /**
* API method to expand all the rows.
* @return {?}
*/
function () {
this.toggle.emit({
type: 'all',
value: true
});
};
/**
* API method to collapse all the rows.
*/
/**
* API method to collapse all the rows.
* @return {?}
*/
DatatableRowDetailDirective.prototype.collapseAllRows = /**
* API method to collapse all the rows.
* @return {?}
*/
function () {
this.toggle.emit({
type: 'all',
value: false
});
};
DatatableRowDetailDirective.decorators = [
{ type: Directive, args: [{ selector: 'ngx-datatable-row-detail' },] }
];
DatatableRowDetailDirective.propDecorators = {
rowHeight: [{ type: Input }],
_templateInput: [{ type: Input, args: ['template',] }],
_templateQuery: [{ type: ContentChild, args: [DatatableRowDetailTemplateDirective, { read: TemplateRef, static: true },] }],
toggle: [{ type: Output }]
};
return DatatableRowDetailDirective;
}());
if (false) {
/**
* The detail row height is required especially
* when virtual scroll is enabled.
* @type {?}
*/
DatatableRowDetailDirective.prototype.rowHeight;
/** @type {?} */
DatatableRowDetailDirective.prototype._templateInput;
/** @type {?} */
DatatableRowDetailDirective.prototype._templateQuery;
/**
* Row detail row visbility was toggled.
* @type {?}
*/
DatatableRowDetailDirective.prototype.toggle;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DatatableFooterDirective = /** @class */ (function () {
function DatatableFooterDirective() {
}
Object.defineProperty(DatatableFooterDirective.prototype, "template", {
get: /**
* @return {?}
*/
function () {
return this._templateInput || this._templateQuery;
},
enumerable: true,
configurable: true
});
DatatableFooterDirective.decorators = [
{ type: Directive, args: [{ selector: 'ngx-datatable-footer' },] }
];
DatatableFooterDirective.propDecorators = {
footerHeight: [{ type: Input }],
totalMessage: [{ type: Input }],
selectedMessage: [{ type: Input }],
pagerLeftArrowIcon: [{ type: Input }],
pagerRightArrowIcon: [{ type: Input }],
pagerPreviousIcon: [{ type: Input }],
pagerNextIcon: [{ type: Input }],
_templateInput: [{ type: Input, args: ['template',] }],
_templateQuery: [{ type: ContentChild, args: [DataTableFooterTemplateDirective, { read: TemplateRef, static: false },] }]
};
return DatatableFooterDirective;
}());
if (false) {
/** @type {?} */
DatatableFooterDirective.prototype.footerHeight;
/** @type {?} */
DatatableFooterDirective.prototype.totalMessage;
/** @type {?} */
DatatableFooterDirective.prototype.selectedMessage;
/** @type {?} */
DatatableFooterDirective.prototype.pagerLeftArrowIcon;
/** @type {?} */
DatatableFooterDirective.prototype.pagerRightArrowIcon;
/** @type {?} */
DatatableFooterDirective.prototype.pagerPreviousIcon;
/** @type {?} */
DatatableFooterDirective.prototype.pagerNextIcon;
/** @type {?} */
DatatableFooterDirective.prototype._templateInput;
/** @type {?} */
DatatableFooterDirective.prototype._templateQuery;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Returns the columns by pin.
* @param {?} cols
* @return {?}
*/
function columnsByPin(cols) {
var e_1, _a;
/** @type {?} */
var ret = {
left: [],
center: [],
right: []
};
if (cols) {
try {
for (var cols_1 = __values(cols), cols_1_1 = cols_1.next(); !cols_1_1.done; cols_1_1 = cols_1.next()) {
var col = cols_1_1.value;
if (col.frozenLeft) {
ret.left.push(col);
}
else if (col.frozenRight) {
ret.right.push(col);
}
else {
ret.center.push(col);
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (cols_1_1 && !cols_1_1.done && (_a = cols_1.return)) _a.call(cols_1);
}
finally { if (e_1) throw e_1.error; }
}
}
return ret;
}
/**
* Returns the widths of all group sets of a column
* @param {?} groups
* @param {?} all
* @return {?}
*/
function columnGroupWidths(groups, all) {
return {
left: columnTotalWidth(groups.left),
center: columnTotalWidth(groups.center),
right: columnTotalWidth(groups.right),
total: Math.floor(columnTotalWidth(all))
};
}
/**
* Calculates the total width of all columns and their groups
* @param {?} columns
* @param {?=} prop
* @return {?}
*/
function columnTotalWidth(columns, prop) {
var e_2, _a;
/** @type {?} */
var totalWidth = 0;
if (columns) {
try {
for (var columns_1 = __values(columns), columns_1_1 = columns_1.next(); !columns_1_1.done; columns_1_1 = columns_1.next()) {
var c = columns_1_1.value;
/** @type {?} */
var has = prop && c[prop];
/** @type {?} */
var width = has ? c[prop] : c.width;
totalWidth = totalWidth + parseFloat(width);
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (columns_1_1 && !columns_1_1.done && (_a = columns_1.return)) _a.call(columns_1);
}
finally { if (e_2) throw e_2.error; }
}
}
return totalWidth;
}
/**
* Calculates the total width of all columns and their groups
* @param {?} columns
* @param {?=} prop
* @return {?}
*/
function columnsTotalWidth(columns, prop) {
var e_3, _a;
/** @type {?} */
var totalWidth = 0;
try {
for (var columns_2 = __values(columns), columns_2_1 = columns_2.next(); !columns_2_1.done; columns_2_1 = columns_2.next()) {
var column = columns_2_1.value;
/** @type {?} */
var has = prop && column[prop];
totalWidth = totalWidth + (has ? column[prop] : column.width);
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (columns_2_1 && !columns_2_1.done && (_a = columns_2.return)) _a.call(columns_2);
}
finally { if (e_3) throw e_3.error; }
}
return totalWidth;
}
/**
* @param {?} val
* @return {?}
*/
function columnsByPinArr(val) {
/** @type {?} */
var colsByPinArr = [];
/** @type {?} */
var colsByPin = columnsByPin(val);
colsByPinArr.push({ type: 'left', columns: colsByPin['left'] });
colsByPinArr.push({ type: 'center', columns: colsByPin['center'] });
colsByPinArr.push({ type: 'right', columns: colsByPin['right'] });
return colsByPinArr;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* This object contains the cache of the various row heights that are present inside
* the data table. Its based on Fenwick tree data structure that helps with
* querying sums that have time complexity of log n.
*
* Fenwick Tree Credits: http://petr-mitrichev.blogspot.com/2013/05/fenwick-tree-range-updates.html
* https://github.com/mikolalysenko/fenwick-tree
*
*/
var /**
* This object contains the cache of the various row heights that are present inside
* the data table. Its based on Fenwick tree data structure that helps with
* querying sums that have time complexity of log n.
*
* Fenwick Tree Credits: http://petr-mitrichev.blogspot.com/2013/05/fenwick-tree-range-updates.html
* https://github.com/mikolalysenko/fenwick-tree
*
*/
RowHeightCache = /** @class */ (function () {
function RowHeightCache() {
/**
* Tree Array stores the cumulative information of the row heights to perform efficient
* range queries and updates. Currently the tree is initialized to the base row
* height instead of the detail row height.
*/
this.treeArray = [];
}
/**
* Clear the Tree array.
*/
/**
* Clear the Tree array.
* @return {?}
*/
RowHeightCache.prototype.clearCache = /**
* Clear the Tree array.
* @return {?}
*/
function () {
this.treeArray = [];
};
/**
* Initialize the Fenwick tree with row Heights.
*
* @param rows The array of rows which contain the expanded status.
* @param rowHeight The row height.
* @param detailRowHeight The detail row height.
*/
/**
* Initialize the Fenwick tree with row Heights.
*
* @param {?} details
* @return {?}
*/
RowHeightCache.prototype.initCache = /**
* Initialize the Fenwick tree with row Heights.
*
* @param {?} details
* @return {?}
*/
function (details) {
var rows = details.rows, rowHeight = details.rowHeight, detailRowHeight = details.detailRowHeight, externalVirtual = details.externalVirtual, rowCount = details.rowCount, rowIndexes = details.rowIndexes, rowExpansions = details.rowExpansions;
/** @type {?} */
var isFn = typeof rowHeight === 'function';
/** @type {?} */
var isDetailFn = typeof detailRowHeight === 'function';
if (!isFn && isNaN(rowHeight)) {
throw new Error("Row Height cache initialization failed. Please ensure that 'rowHeight' is a\n valid number or function value: (" + rowHeight + ") when 'scrollbarV' is enabled.");
}
// Add this additional guard in case detailRowHeight is set to 'auto' as it wont work.
if (!isDetailFn && isNaN(detailRowHeight)) {
throw new Error("Row Height cache initialization failed. Please ensure that 'detailRowHeight' is a\n valid number or function value: (" + detailRowHeight + ") when 'scrollbarV' is enabled.");
}
/** @type {?} */
var n = externalVirtual ? rowCount : rows.length;
this.treeArray = new Array(n);
for (var i = 0; i < n; ++i) {
this.treeArray[i] = 0;
}
for (var i = 0; i < n; ++i) {
/** @type {?} */
var row = rows[i];
/** @type {?} */
var currentRowHeight = rowHeight;
if (isFn) {
currentRowHeight = rowHeight(row);
}
// Add the detail row height to the already expanded rows.
// This is useful for the table that goes through a filter or sort.
/** @type {?} */
var expanded = rowExpansions.has(row);
if (row && expanded) {
if (isDetailFn) {
/** @type {?} */
var index = rowIndexes.get(row);
currentRowHeight += detailRowHeight(row, index);
}
else {
currentRowHeight += detailRowHeight;
}
}
this.update(i, currentRowHeight);
}
};
/**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port. Below handles edge cases.
*/
/**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port. Below handles edge cases.
* @param {?} scrollY
* @return {?}
*/
RowHeightCache.prototype.getRowIndex = /**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port. Below handles edge cases.
* @param {?} scrollY
* @return {?}
*/
function (scrollY) {
if (scrollY === 0)
return 0;
return this.calcRowIndex(scrollY);
};
/**
* When a row is expanded or rowHeight is changed, update the height. This can
* be utilized in future when Angular Data table supports dynamic row heights.
*/
/**
* When a row is expanded or rowHeight is changed, update the height. This can
* be utilized in future when Angular Data table supports dynamic row heights.
* @param {?} atRowIndex
* @param {?} byRowHeight
* @return {?}
*/
RowHeightCache.prototype.update = /**
* When a row is expanded or rowHeight is changed, update the height. This can
* be utilized in future when Angular Data table supports dynamic row heights.
* @param {?} atRowIndex
* @param {?} byRowHeight
* @return {?}
*/
function (atRowIndex, byRowHeight) {
if (!this.treeArray.length) {
throw new Error("Update at index " + atRowIndex + " with value " + byRowHeight + " failed:\n Row Height cache not initialized.");
}
/** @type {?} */
var n = this.treeArray.length;
atRowIndex |= 0;
while (atRowIndex < n) {
this.treeArray[atRowIndex] += byRowHeight;
atRowIndex |= atRowIndex + 1;
}
};
/**
* Range Sum query from 1 to the rowIndex
*/
/**
* Range Sum query from 1 to the rowIndex
* @param {?} atIndex
* @return {?}
*/
RowHeightCache.prototype.query = /**
* Range Sum query from 1 to the rowIndex
* @param {?} atIndex
* @return {?}
*/
function (atIndex) {
if (!this.treeArray.length) {
throw new Error("query at index " + atIndex + " failed: Fenwick tree array not initialized.");
}
/** @type {?} */
var sum = 0;
atIndex |= 0;
while (atIndex >= 0) {
sum += this.treeArray[atIndex];
atIndex = (atIndex & (atIndex + 1)) - 1;
}
return sum;
};
/**
* Find the total height between 2 row indexes
*/
/**
* Find the total height between 2 row indexes
* @param {?} atIndexA
* @param {?} atIndexB
* @return {?}
*/
RowHeightCache.prototype.queryBetween = /**
* Find the total height between 2 row indexes
* @param {?} atIndexA
* @param {?} atIndexB
* @return {?}
*/
function (atIndexA, atIndexB) {
return this.query(atIndexB) - this.query(atIndexA - 1);
};
/**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port.
*/
/**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port.
* @private
* @param {?} sum
* @return {?}
*/
RowHeightCache.prototype.calcRowIndex = /**
* Given the ScrollY position i.e. sum, provide the rowIndex
* that is present in the current view port.
* @private
* @param {?} sum
* @return {?}
*/
function (sum) {
if (!this.treeArray.length)
return 0;
/** @type {?} */
var pos = -1;
/** @type {?} */
var dataLength = this.treeArray.length;
// Get the highest bit for the block size.
/** @type {?} */
var highestBit = Math.pow(2, dataLength.toString(2).length - 1);
for (var blockSize = highestBit; blockSize !== 0; blockSize >>= 1) {
/** @type {?} */
var nextPos = pos + blockSize;
if (nextPos < dataLength && sum >= this.treeArray[nextPos]) {
sum -= this.treeArray[nextPos];
pos = nextPos;
}
}
return pos + 1;
};
return RowHeightCache;
}());
if (false) {
/**
* Tree Array stores the cumulative information of the row heights to perform efficient
* range queries and updates. Currently the tree is initialized to the base row
* height instead of the detail row height.
* @type {?}
* @private
*/
RowHeightCache.prototype.treeArray;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var cache = {};
/** @type {?} */
var testStyle = typeof document !== 'undefined' ? document.createElement('div').style : undefined;
// Get Prefix
// http://davidwalsh.name/vendor-prefix
var ɵ0 = /**
* @return {?}
*/
function () {
/** @type {?} */
var styles = typeof window !== 'undefined' ? window.getComputedStyle(document.documentElement, '') : undefined;
/** @type {?} */
var match = typeof styles !== 'undefined'
? Array.prototype.slice
.call(styles)
.join('')
.match(/-(moz|webkit|ms)-/)
: null;
/** @type {?} */
var pre = match !== null ? match[1] : undefined;
// tslint:disable-next-line: tsr-detect-non-literal-regexp
/** @type {?} */
var dom = typeof pre !== 'undefined' ? 'WebKit|Moz|MS|O'.match(new RegExp('(' + pre + ')', 'i'))[1] : undefined;
return dom
? {
dom: dom,
lowercase: pre,
css: "-" + pre + "-",
js: pre[0].toUpperCase() + pre.substr(1)
}
: undefined;
};
/** @type {?} */
var prefix = ((ɵ0))();
/**
* @param {?} property
* @return {?}
*/
function getVendorPrefixedName(property) {
/** @type {?} */
var name = camelCase(property);
if (!cache[name]) {
if (prefix !== undefined && testStyle[prefix.css + property] !== undefined) {
cache[name] = prefix.css + property;
}
else if (testStyle[property] !== undefined) {
cache[name] = property;
}
}
return cache[name];
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// browser detection and prefixing tools
/** @type {?} */
var transform = typeof window !== 'undefined' ? getVendorPrefixedName('transform') : undefined;
/** @type {?} */
var backfaceVisibility = typeof window !== 'undefined' ? getVendorPrefixedName('backfaceVisibility') : undefined;
/** @type {?} */
var hasCSSTransforms = typeof window !== 'undefined' ? !!getVendorPrefixedName('transform') : undefined;
/** @type {?} */
var hasCSS3DTransforms = typeof window !== 'undefined' ? !!getVendorPrefixedName('perspective') : undefined;
/** @type {?} */
var ua = typeof window !== 'undefined' ? window.navigator.userAgent : 'Chrome';
/** @type {?} */
var isSafari = /Safari\//.test(ua) && !/Chrome\//.test(ua);
/**
* @param {?} styles
* @param {?} x
* @param {?} y
* @return {?}
*/
function translateXY(styles, x, y) {
if (typeof transform !== 'undefined' && hasCSSTransforms) {
if (!isSafari && hasCSS3DTransforms) {
styles[transform] = "translate3d(" + x + "px, " + y + "px, 0)";
styles[backfaceVisibility] = 'hidden';
}
else {
styles[camelCase(transform)] = "translate(" + x + "px, " + y + "px)";
}
}
else {
styles.top = y + "px";
styles.left = x + "px";
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableBodyComponent = /** @class */ (function () {
/**
* Creates an instance of DataTableBodyComponent.
*/
function DataTableBodyComponent(cd) {
var _this = this;
this.cd = cd;
this.selected = [];
this.scroll = new EventEmitter();
this.page = new EventEmitter();
this.activate = new EventEmitter();
this.select = new EventEmitter();
this.detailToggle = new EventEmitter();
this.rowContextmenu = new EventEmitter(false);
this.treeAction = new EventEmitter();
this.rowHeightsCache = new RowHeightCache();
this.temp = [];
this.offsetY = 0;
this.indexes = {};
this.rowIndexes = new Map();
this.rowExpansions = [];
/**
* Get the height of the detail row.
*/
this.getDetailRowHeight = (/**
* @param {?=} row
* @param {?=} index
* @return {?}
*/
function (row, index) {
if (!_this.rowDetail) {
return 0;
}
/** @type {?} */
var rowHeight = _this.rowDetail.rowHeight;
return typeof rowHeight === 'function' ? rowHeight(row, index) : ((/** @type {?} */ (rowHeight)));
});
// declare fn here so we can get access to the `this` property
this.rowTrackingFn = (/**
* @param {?} index
* @param {?} row
* @return {?}
*/
function (index, row) {
/** @type {?} */
var idx = _this.getRowIndex(row);
if (_this.trackByProp) {
return row[_this.trackByProp];
}
else {
return idx;
}
});
}
Object.defineProperty(DataTableBodyComponent.prototype, "pageSize", {
get: /**
* @return {?}
*/
function () {
return this._pageSize;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._pageSize = val;
this.recalcLayout();
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "rows", {
get: /**
* @return {?}
*/
function () {
return this._rows;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._rows = val;
this.recalcLayout();
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "columns", {
get: /**
* @return {?}
*/
function () {
return this._columns;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._columns = val;
/** @type {?} */
var colsByPin = columnsByPin(val);
this.columnGroupWidths = columnGroupWidths(colsByPin, val);
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "offset", {
get: /**
* @return {?}
*/
function () {
return this._offset;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._offset = val;
if (!this.scrollbarV || (this.scrollbarV && !this.virtualization))
this.recalcLayout();
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "rowCount", {
get: /**
* @return {?}
*/
function () {
return this._rowCount;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._rowCount = val;
this.recalcLayout();
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "bodyWidth", {
get: /**
* @return {?}
*/
function () {
if (this.scrollbarH) {
return this.innerWidth + 'px';
}
else {
return '100%';
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "bodyHeight", {
get: /**
* @return {?}
*/
function () {
return this._bodyHeight;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
if (this.scrollbarV) {
this._bodyHeight = val + 'px';
}
else {
this._bodyHeight = 'auto';
}
this.recalcLayout();
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "selectEnabled", {
/**
* Returns if selection is enabled.
*/
get: /**
* Returns if selection is enabled.
* @return {?}
*/
function () {
return !!this.selectionType;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableBodyComponent.prototype, "scrollHeight", {
/**
* Property that would calculate the height of scroll bar
* based on the row heights cache for virtual scroll and virtualization. Other scenarios
* calculate scroll height automatically (as height will be undefined).
*/
get: /**
* Property that would calculate the height of scroll bar
* based on the row heights cache for virtual scroll and virtualization. Other scenarios
* calculate scroll height automatically (as height will be undefined).
* @return {?}
*/
function () {
if (this.scrollbarV && this.virtualization && this.rowCount) {
return this.rowHeightsCache.query(this.rowCount - 1);
}
// avoid TS7030: Not all code paths return a value.
return undefined;
},
enumerable: true,
configurable: true
});
/**
* Called after the constructor, initializing input properties
*/
/**
* Called after the constructor, initializing input properties
* @return {?}
*/
DataTableBodyComponent.prototype.ngOnInit = /**
* Called after the constructor, initializing input properties
* @return {?}
*/
function () {
var _this = this;
if (this.rowDetail) {
this.listener = this.rowDetail.toggle.subscribe((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var type = _a.type, value = _a.value;
if (type === 'row') {
_this.toggleRowExpansion(value);
}
if (type === 'all') {
_this.toggleAllRows(value);
}
// Refresh rows after toggle
// Fixes #883
_this.updateIndexes();
_this.updateRows();
_this.cd.markForCheck();
}));
}
if (this.groupHeader) {
this.listener = this.groupHeader.toggle.subscribe((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var type = _a.type, value = _a.value;
if (type === 'group') {
_this.toggleRowExpansion(value);
}
if (type === 'all') {
_this.toggleAllRows(value);
}
// Refresh rows after toggle
// Fixes #883
_this.updateIndexes();
_this.updateRows();
_this.cd.markForCheck();
}));
}
};
/**
* Called once, before the instance is destroyed.
*/
/**
* Called once, before the instance is destroyed.
* @return {?}
*/
DataTableBodyComponent.prototype.ngOnDestroy = /**
* Called once, before the instance is destroyed.
* @return {?}
*/
function () {
if (this.rowDetail || this.groupHeader) {
this.listener.unsubscribe();
}
};
/**
* Updates the Y offset given a new offset.
*/
/**
* Updates the Y offset given a new offset.
* @param {?=} offset
* @return {?}
*/
DataTableBodyComponent.prototype.updateOffsetY = /**
* Updates the Y offset given a new offset.
* @param {?=} offset
* @return {?}
*/
function (offset) {
// scroller is missing on empty table
if (!this.scroller) {
return;
}
if (this.scrollbarV && this.virtualization && offset) {
// First get the row Index that we need to move to.
/** @type {?} */
var rowIndex = this.pageSize * offset;
offset = this.rowHeightsCache.query(rowIndex - 1);
}
else if (this.scrollbarV && !this.virtualization) {
offset = 0;
}
this.scroller.setOffset(offset || 0);
};
/**
* Body was scrolled, this is mainly useful for
* when a user is server-side pagination via virtual scroll.
*/
/**
* Body was scrolled, this is mainly useful for
* when a user is server-side pagination via virtual scroll.
* @param {?} event
* @return {?}
*/
DataTableBodyComponent.prototype.onBodyScroll = /**
* Body was scrolled, this is mainly useful for
* when a user is server-side pagination via virtual scroll.
* @param {?} event
* @return {?}
*/
function (event) {
/** @type {?} */
var scrollYPos = event.scrollYPos;
/** @type {?} */
var scrollXPos = event.scrollXPos;
// if scroll change, trigger update
// this is mainly used for header cell positions
if (this.offsetY !== scrollYPos || this.offsetX !== scrollXPos) {
this.scroll.emit({
offsetY: scrollYPos,
offsetX: scrollXPos
});
}
this.offsetY = scrollYPos;
this.offsetX = scrollXPos;
this.updateIndexes();
this.updatePage(event.direction);
this.updateRows();
};
/**
* Updates the page given a direction.
*/
/**
* Updates the page given a direction.
* @param {?} direction
* @return {?}
*/
DataTableBodyComponent.prototype.updatePage = /**
* Updates the page given a direction.
* @param {?} direction
* @return {?}
*/
function (direction) {
/** @type {?} */
var offset = this.indexes.first / this.pageSize;
if (direction === 'up') {
offset = Math.ceil(offset);
}
else if (direction === 'down') {
offset = Math.floor(offset);
}
if (direction !== undefined && !isNaN(offset)) {
this.page.emit({ offset: offset });
}
};
/**
* Updates the rows in the view port
*/
/**
* Updates the rows in the view port
* @return {?}
*/
DataTableBodyComponent.prototype.updateRows = /**
* Updates the rows in the view port
* @return {?}
*/
function () {
var _a = this.indexes, first = _a.first, last = _a.last;
/** @type {?} */
var rowIndex = first;
/** @type {?} */
var idx = 0;
/** @type {?} */
var temp = [];
this.rowIndexes.clear();
// if grouprowsby has been specified treat row paging
// parameters as group paging parameters ie if limit 10 has been
// specified treat it as 10 groups rather than 10 rows
if (this.groupedRows) {
/** @type {?} */
var maxRowsPerGroup = 3;
// if there is only one group set the maximum number of
// rows per group the same as the total number of rows
if (this.groupedRows.length === 1) {
maxRowsPerGroup = this.groupedRows[0].value.length;
}
while (rowIndex < last && rowIndex < this.groupedRows.length) {
// Add the groups into this page
/** @type {?} */
var group = this.groupedRows[rowIndex];
temp[idx] = group;
idx++;
// Group index in this context
rowIndex++;
}
}
else {
while (rowIndex < last && rowIndex < this.rowCount) {
/** @type {?} */
var row = this.rows[rowIndex];
if (row) {
this.rowIndexes.set(row, rowIndex);
temp[idx] = row;
}
idx++;
rowIndex++;
}
}
this.temp = temp;
};
/**
* Get the row height
*/
/**
* Get the row height
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.getRowHeight = /**
* Get the row height
* @param {?} row
* @return {?}
*/
function (row) {
// if its a function return it
if (typeof this.rowHeight === 'function') {
return this.rowHeight(row);
}
return (/** @type {?} */ (this.rowHeight));
};
/**
* @param group the group with all rows
*/
/**
* @param {?} group the group with all rows
* @return {?}
*/
DataTableBodyComponent.prototype.getGroupHeight = /**
* @param {?} group the group with all rows
* @return {?}
*/
function (group) {
/** @type {?} */
var rowHeight = 0;
if (group.value) {
for (var index = 0; index < group.value.length; index++) {
rowHeight += this.getRowAndDetailHeight(group.value[index]);
}
}
return rowHeight;
};
/**
* Calculate row height based on the expanded state of the row.
*/
/**
* Calculate row height based on the expanded state of the row.
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.getRowAndDetailHeight = /**
* Calculate row height based on the expanded state of the row.
* @param {?} row
* @return {?}
*/
function (row) {
/** @type {?} */
var rowHeight = this.getRowHeight(row);
/** @type {?} */
var expanded = this.getRowExpanded(row);
// Adding detail row height if its expanded.
if (expanded) {
rowHeight += this.getDetailRowHeight(row);
}
return rowHeight;
};
/**
* Calculates the styles for the row so that the rows can be moved in 2D space
* during virtual scroll inside the DOM. In the below case the Y position is
* manipulated. As an example, if the height of row 0 is 30 px and row 1 is
* 100 px then following styles are generated:
*
* transform: translate3d(0px, 0px, 0px); -> row0
* transform: translate3d(0px, 30px, 0px); -> row1
* transform: translate3d(0px, 130px, 0px); -> row2
*
* Row heights have to be calculated based on the row heights cache as we wont
* be able to determine which row is of what height before hand. In the above
* case the positionY of the translate3d for row2 would be the sum of all the
* heights of the rows before it (i.e. row0 and row1).
*
* @param rows the row that needs to be placed in the 2D space.
* @returns the CSS3 style to be applied
*
* @memberOf DataTableBodyComponent
*/
/**
* Calculates the styles for the row so that the rows can be moved in 2D space
* during virtual scroll inside the DOM. In the below case the Y position is
* manipulated. As an example, if the height of row 0 is 30 px and row 1 is
* 100 px then following styles are generated:
*
* transform: translate3d(0px, 0px, 0px); -> row0
* transform: translate3d(0px, 30px, 0px); -> row1
* transform: translate3d(0px, 130px, 0px); -> row2
*
* Row heights have to be calculated based on the row heights cache as we wont
* be able to determine which row is of what height before hand. In the above
* case the positionY of the translate3d for row2 would be the sum of all the
* heights of the rows before it (i.e. row0 and row1).
*
* \@memberOf DataTableBodyComponent
* @param {?} rows the row that needs to be placed in the 2D space.
* @return {?} the CSS3 style to be applied
*
*/
DataTableBodyComponent.prototype.getRowsStyles = /**
* Calculates the styles for the row so that the rows can be moved in 2D space
* during virtual scroll inside the DOM. In the below case the Y position is
* manipulated. As an example, if the height of row 0 is 30 px and row 1 is
* 100 px then following styles are generated:
*
* transform: translate3d(0px, 0px, 0px); -> row0
* transform: translate3d(0px, 30px, 0px); -> row1
* transform: translate3d(0px, 130px, 0px); -> row2
*
* Row heights have to be calculated based on the row heights cache as we wont
* be able to determine which row is of what height before hand. In the above
* case the positionY of the translate3d for row2 would be the sum of all the
* heights of the rows before it (i.e. row0 and row1).
*
* \@memberOf DataTableBodyComponent
* @param {?} rows the row that needs to be placed in the 2D space.
* @return {?} the CSS3 style to be applied
*
*/
function (rows) {
/** @type {?} */
var styles = {};
// only add styles for the group if there is a group
if (this.groupedRows) {
styles.width = this.columnGroupWidths.total;
}
if (this.scrollbarV && this.virtualization) {
/** @type {?} */
var idx = 0;
if (this.groupedRows) {
// Get the latest row rowindex in a group
/** @type {?} */
var row = rows[rows.length - 1];
idx = row ? this.getRowIndex(row) : 0;
}
else {
idx = this.getRowIndex(rows);
}
// const pos = idx * rowHeight;
// The position of this row would be the sum of all row heights
// until the previous row position.
/** @type {?} */
var pos = this.rowHeightsCache.query(idx - 1);
translateXY(styles, 0, pos);
}
return styles;
};
/**
* Calculate bottom summary row offset for scrollbar mode.
* For more information about cache and offset calculation
* see description for `getRowsStyles` method
*
* @returns the CSS3 style to be applied
*
* @memberOf DataTableBodyComponent
*/
/**
* Calculate bottom summary row offset for scrollbar mode.
* For more information about cache and offset calculation
* see description for `getRowsStyles` method
*
* \@memberOf DataTableBodyComponent
* @return {?} the CSS3 style to be applied
*
*/
DataTableBodyComponent.prototype.getBottomSummaryRowStyles = /**
* Calculate bottom summary row offset for scrollbar mode.
* For more information about cache and offset calculation
* see description for `getRowsStyles` method
*
* \@memberOf DataTableBodyComponent
* @return {?} the CSS3 style to be applied
*
*/
function () {
if (!this.scrollbarV || !this.rows || !this.rows.length) {
return null;
}
/** @type {?} */
var styles = { position: 'absolute' };
/** @type {?} */
var pos = this.rowHeightsCache.query(this.rows.length - 1);
translateXY(styles, 0, pos);
return styles;
};
/**
* Hides the loading indicator
*/
/**
* Hides the loading indicator
* @return {?}
*/
DataTableBodyComponent.prototype.hideIndicator = /**
* Hides the loading indicator
* @return {?}
*/
function () {
var _this = this;
setTimeout((/**
* @return {?}
*/
function () { return (_this.loadingIndicator = false); }), 500);
};
/**
* Updates the index of the rows in the viewport
*/
/**
* Updates the index of the rows in the viewport
* @return {?}
*/
DataTableBodyComponent.prototype.updateIndexes = /**
* Updates the index of the rows in the viewport
* @return {?}
*/
function () {
/** @type {?} */
var first = 0;
/** @type {?} */
var last = 0;
if (this.scrollbarV) {
if (this.virtualization) {
// Calculation of the first and last indexes will be based on where the
// scrollY position would be at. The last index would be the one
// that shows up inside the view port the last.
/** @type {?} */
var height = parseInt(this.bodyHeight, 0);
first = this.rowHeightsCache.getRowIndex(this.offsetY);
last = this.rowHeightsCache.getRowIndex(height + this.offsetY) + 1;
}
else {
// If virtual rows are not needed
// We render all in one go
first = 0;
last = this.rowCount;
}
}
else {
// The server is handling paging and will pass an array that begins with the
// element at a specified offset. first should always be 0 with external paging.
if (!this.externalPaging) {
first = Math.max(this.offset * this.pageSize, 0);
}
last = Math.min(first + this.pageSize, this.rowCount);
}
this.indexes = { first: first, last: last };
};
/**
* Refreshes the full Row Height cache. Should be used
* when the entire row array state has changed.
*/
/**
* Refreshes the full Row Height cache. Should be used
* when the entire row array state has changed.
* @return {?}
*/
DataTableBodyComponent.prototype.refreshRowHeightCache = /**
* Refreshes the full Row Height cache. Should be used
* when the entire row array state has changed.
* @return {?}
*/
function () {
var e_1, _a;
if (!this.scrollbarV || (this.scrollbarV && !this.virtualization)) {
return;
}
// clear the previous row height cache if already present.
// this is useful during sorts, filters where the state of the
// rows array is changed.
this.rowHeightsCache.clearCache();
// Initialize the tree only if there are rows inside the tree.
if (this.rows && this.rows.length) {
/** @type {?} */
var rowExpansions = new Set();
try {
for (var _b = __values(this.rows), _c = _b.next(); !_c.done; _c = _b.next()) {
var row = _c.value;
if (this.getRowExpanded(row)) {
rowExpansions.add(row);
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
this.rowHeightsCache.initCache({
rows: this.rows,
rowHeight: this.rowHeight,
detailRowHeight: this.getDetailRowHeight,
externalVirtual: this.scrollbarV && this.externalPaging,
rowCount: this.rowCount,
rowIndexes: this.rowIndexes,
rowExpansions: rowExpansions
});
}
};
/**
* Gets the index for the view port
*/
/**
* Gets the index for the view port
* @return {?}
*/
DataTableBodyComponent.prototype.getAdjustedViewPortIndex = /**
* Gets the index for the view port
* @return {?}
*/
function () {
// Capture the row index of the first row that is visible on the viewport.
// If the scroll bar is just below the row which is highlighted then make that as the
// first index.
/** @type {?} */
var viewPortFirstRowIndex = this.indexes.first;
if (this.scrollbarV && this.virtualization) {
/** @type {?} */
var offsetScroll = this.rowHeightsCache.query(viewPortFirstRowIndex - 1);
return offsetScroll <= this.offsetY ? viewPortFirstRowIndex - 1 : viewPortFirstRowIndex;
}
return viewPortFirstRowIndex;
};
/**
* Toggle the Expansion of the row i.e. if the row is expanded then it will
* collapse and vice versa. Note that the expanded status is stored as
* a part of the row object itself as we have to preserve the expanded row
* status in case of sorting and filtering of the row set.
*/
/**
* Toggle the Expansion of the row i.e. if the row is expanded then it will
* collapse and vice versa. Note that the expanded status is stored as
* a part of the row object itself as we have to preserve the expanded row
* status in case of sorting and filtering of the row set.
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.toggleRowExpansion = /**
* Toggle the Expansion of the row i.e. if the row is expanded then it will
* collapse and vice versa. Note that the expanded status is stored as
* a part of the row object itself as we have to preserve the expanded row
* status in case of sorting and filtering of the row set.
* @param {?} row
* @return {?}
*/
function (row) {
// Capture the row index of the first row that is visible on the viewport.
/** @type {?} */
var viewPortFirstRowIndex = this.getAdjustedViewPortIndex();
/** @type {?} */
var rowExpandedIdx = this.getRowExpandedIdx(row, this.rowExpansions);
/** @type {?} */
var expanded = rowExpandedIdx > -1;
// If the detailRowHeight is auto --> only in case of non-virtualized scroll
if (this.scrollbarV && this.virtualization) {
/** @type {?} */
var detailRowHeight = this.getDetailRowHeight(row) * (expanded ? -1 : 1);
// const idx = this.rowIndexes.get(row) || 0;
/** @type {?} */
var idx = this.getRowIndex(row);
this.rowHeightsCache.update(idx, detailRowHeight);
}
// Update the toggled row and update thive nevere heights in the cache.
if (expanded) {
this.rowExpansions.splice(rowExpandedIdx, 1);
}
else {
this.rowExpansions.push(row);
}
this.detailToggle.emit({
rows: [row],
currentIndex: viewPortFirstRowIndex
});
};
/**
* Expand/Collapse all the rows no matter what their state is.
*/
/**
* Expand/Collapse all the rows no matter what their state is.
* @param {?} expanded
* @return {?}
*/
DataTableBodyComponent.prototype.toggleAllRows = /**
* Expand/Collapse all the rows no matter what their state is.
* @param {?} expanded
* @return {?}
*/
function (expanded) {
var e_2, _a;
// clear prev expansions
this.rowExpansions = [];
// Capture the row index of the first row that is visible on the viewport.
/** @type {?} */
var viewPortFirstRowIndex = this.getAdjustedViewPortIndex();
if (expanded) {
try {
for (var _b = __values(this.rows), _c = _b.next(); !_c.done; _c = _b.next()) {
var row = _c.value;
this.rowExpansions.push(row);
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
}
if (this.scrollbarV) {
// Refresh the full row heights cache since every row was affected.
this.recalcLayout();
}
// Emit all rows that have been expanded.
this.detailToggle.emit({
rows: this.rows,
currentIndex: viewPortFirstRowIndex
});
};
/**
* Recalculates the table
*/
/**
* Recalculates the table
* @return {?}
*/
DataTableBodyComponent.prototype.recalcLayout = /**
* Recalculates the table
* @return {?}
*/
function () {
this.refreshRowHeightCache();
this.updateIndexes();
this.updateRows();
};
/**
* Tracks the column
*/
/**
* Tracks the column
* @param {?} index
* @param {?} column
* @return {?}
*/
DataTableBodyComponent.prototype.columnTrackingFn = /**
* Tracks the column
* @param {?} index
* @param {?} column
* @return {?}
*/
function (index, column) {
return column.$$id;
};
/**
* Gets the row pinning group styles
*/
/**
* Gets the row pinning group styles
* @param {?} group
* @return {?}
*/
DataTableBodyComponent.prototype.stylesByGroup = /**
* Gets the row pinning group styles
* @param {?} group
* @return {?}
*/
function (group) {
/** @type {?} */
var widths = this.columnGroupWidths;
/** @type {?} */
var offsetX = this.offsetX;
/** @type {?} */
var styles = {
width: widths[group] + "px"
};
if (group === 'left') {
translateXY(styles, offsetX, 0);
}
else if (group === 'right') {
/** @type {?} */
var bodyWidth = parseInt(this.innerWidth + '', 0);
/** @type {?} */
var totalDiff = widths.total - bodyWidth;
/** @type {?} */
var offsetDiff = totalDiff - offsetX;
/** @type {?} */
var offset = offsetDiff * -1;
translateXY(styles, offset, 0);
}
return styles;
};
/**
* Returns if the row was expanded and set default row expansion when row expansion is empty
*/
/**
* Returns if the row was expanded and set default row expansion when row expansion is empty
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.getRowExpanded = /**
* Returns if the row was expanded and set default row expansion when row expansion is empty
* @param {?} row
* @return {?}
*/
function (row) {
var e_3, _a;
if (this.rowExpansions.length === 0 && this.groupExpansionDefault) {
try {
for (var _b = __values(this.groupedRows), _c = _b.next(); !_c.done; _c = _b.next()) {
var group = _c.value;
this.rowExpansions.push(group);
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_3) throw e_3.error; }
}
}
return this.getRowExpandedIdx(row, this.rowExpansions) > -1;
};
/**
* @param {?} row
* @param {?} expanded
* @return {?}
*/
DataTableBodyComponent.prototype.getRowExpandedIdx = /**
* @param {?} row
* @param {?} expanded
* @return {?}
*/
function (row, expanded) {
var _this = this;
if (!expanded || !expanded.length)
return -1;
/** @type {?} */
var rowId = this.rowIdentity(row);
return expanded.findIndex((/**
* @param {?} r
* @return {?}
*/
function (r) {
/** @type {?} */
var id = _this.rowIdentity(r);
return id === rowId;
}));
};
/**
* Gets the row index given a row
*/
/**
* Gets the row index given a row
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.getRowIndex = /**
* Gets the row index given a row
* @param {?} row
* @return {?}
*/
function (row) {
return this.rowIndexes.get(row) || 0;
};
/**
* @param {?} row
* @return {?}
*/
DataTableBodyComponent.prototype.onTreeAction = /**
* @param {?} row
* @return {?}
*/
function (row) {
this.treeAction.emit({ row: row });
};
DataTableBodyComponent.decorators = [
{ type: Component, args: [{
selector: 'datatable-body',
template: "\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n ",
changeDetection: ChangeDetectionStrategy.OnPush,
host: {
class: 'datatable-body'
}
}] }
];
/** @nocollapse */
DataTableBodyComponent.ctorParameters = function () { return [
{ type: ChangeDetectorRef }
]; };
DataTableBodyComponent.propDecorators = {
scrollbarV: [{ type: Input }],
scrollbarH: [{ type: Input }],
loadingIndicator: [{ type: Input }],
externalPaging: [{ type: Input }],
rowHeight: [{ type: Input }],
offsetX: [{ type: Input }],
emptyMessage: [{ type: Input }],
selectionType: [{ type: Input }],
selected: [{ type: Input }],
rowIdentity: [{ type: Input }],
rowDetail: [{ type: Input }],
groupHeader: [{ type: Input }],
selectCheck: [{ type: Input }],
displayCheck: [{ type: Input }],
trackByProp: [{ type: Input }],
rowClass: [{ type: Input }],
groupedRows: [{ type: Input }],
groupExpansionDefault: [{ type: Input }],
innerWidth: [{ type: Input }],
groupRowsBy: [{ type: Input }],
virtualization: [{ type: Input }],
summaryRow: [{ type: Input }],
summaryPosition: [{ type: Input }],
summaryHeight: [{ type: Input }],
pageSize: [{ type: Input }],
rows: [{ type: Input }],
columns: [{ type: Input }],
offset: [{ type: Input }],
rowCount: [{ type: Input }],
bodyWidth: [{ type: HostBinding, args: ['style.width',] }],
bodyHeight: [{ type: Input }, { type: HostBinding, args: ['style.height',] }],
scroll: [{ type: Output }],
page: [{ type: Output }],
activate: [{ type: Output }],
select: [{ type: Output }],
detailToggle: [{ type: Output }],
rowContextmenu: [{ type: Output }],
treeAction: [{ type: Output }],
scroller: [{ type: ViewChild, args: [ScrollerComponent, { static: false },] }]
};
return DataTableBodyComponent;
}());
if (false) {
/** @type {?} */
DataTableBodyComponent.prototype.scrollbarV;
/** @type {?} */
DataTableBodyComponent.prototype.scrollbarH;
/** @type {?} */
DataTableBodyComponent.prototype.loadingIndicator;
/** @type {?} */
DataTableBodyComponent.prototype.externalPaging;
/** @type {?} */
DataTableBodyComponent.prototype.rowHeight;
/** @type {?} */
DataTableBodyComponent.prototype.offsetX;
/** @type {?} */
DataTableBodyComponent.prototype.emptyMessage;
/** @type {?} */
DataTableBodyComponent.prototype.selectionType;
/** @type {?} */
DataTableBodyComponent.prototype.selected;
/** @type {?} */
DataTableBodyComponent.prototype.rowIdentity;
/** @type {?} */
DataTableBodyComponent.prototype.rowDetail;
/** @type {?} */
DataTableBodyComponent.prototype.groupHeader;
/** @type {?} */
DataTableBodyComponent.prototype.selectCheck;
/** @type {?} */
DataTableBodyComponent.prototype.displayCheck;
/** @type {?} */
DataTableBodyComponent.prototype.trackByProp;
/** @type {?} */
DataTableBodyComponent.prototype.rowClass;
/** @type {?} */
DataTableBodyComponent.prototype.groupedRows;
/** @type {?} */
DataTableBodyComponent.prototype.groupExpansionDefault;
/** @type {?} */
DataTableBodyComponent.prototype.innerWidth;
/** @type {?} */
DataTableBodyComponent.prototype.groupRowsBy;
/** @type {?} */
DataTableBodyComponent.prototype.virtualization;
/** @type {?} */
DataTableBodyComponent.prototype.summaryRow;
/** @type {?} */
DataTableBodyComponent.prototype.summaryPosition;
/** @type {?} */
DataTableBodyComponent.prototype.summaryHeight;
/** @type {?} */
DataTableBodyComponent.prototype.scroll;
/** @type {?} */
DataTableBodyComponent.prototype.page;
/** @type {?} */
DataTableBodyComponent.prototype.activate;
/** @type {?} */
DataTableBodyComponent.prototype.select;
/** @type {?} */
DataTableBodyComponent.prototype.detailToggle;
/** @type {?} */
DataTableBodyComponent.prototype.rowContextmenu;
/** @type {?} */
DataTableBodyComponent.prototype.treeAction;
/** @type {?} */
DataTableBodyComponent.prototype.scroller;
/** @type {?} */
DataTableBodyComponent.prototype.rowHeightsCache;
/** @type {?} */
DataTableBodyComponent.prototype.temp;
/** @type {?} */
DataTableBodyComponent.prototype.offsetY;
/** @type {?} */
DataTableBodyComponent.prototype.indexes;
/** @type {?} */
DataTableBodyComponent.prototype.columnGroupWidths;
/** @type {?} */
DataTableBodyComponent.prototype.columnGroupWidthsWithoutGroup;
/** @type {?} */
DataTableBodyComponent.prototype.rowTrackingFn;
/** @type {?} */
DataTableBodyComponent.prototype.listener;
/** @type {?} */
DataTableBodyComponent.prototype.rowIndexes;
/** @type {?} */
DataTableBodyComponent.prototype.rowExpansions;
/** @type {?} */
DataTableBodyComponent.prototype._rows;
/** @type {?} */
DataTableBodyComponent.prototype._bodyHeight;
/** @type {?} */
DataTableBodyComponent.prototype._columns;
/** @type {?} */
DataTableBodyComponent.prototype._rowCount;
/** @type {?} */
DataTableBodyComponent.prototype._offset;
/** @type {?} */
DataTableBodyComponent.prototype._pageSize;
/**
* Get the height of the detail row.
* @type {?}
*/
DataTableBodyComponent.prototype.getDetailRowHeight;
/**
* @type {?}
* @private
*/
DataTableBodyComponent.prototype.cd;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var DataTableHeaderComponent = /** @class */ (function () {
function DataTableHeaderComponent(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;
}
Object.defineProperty(DataTableHeaderComponent.prototype, "innerWidth", {
get: /**
* @return {?}
*/
function () {
return this._innerWidth;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
var _this = this;
this._innerWidth = val;
setTimeout((/**
* @return {?}
*/
function () {
if (_this._columns) {
/** @type {?} */
var colByPin = columnsByPin(_this._columns);
_this._columnGroupWidths = columnGroupWidths(colByPin, _this._columns);
_this.setStylesByGroup();
}
}));
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableHeaderComponent.prototype, "headerHeight", {
get: /**
* @return {?}
*/
function () {
return this._headerHeight;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
if (val !== 'auto') {
this._headerHeight = val + "px";
}
else {
this._headerHeight = val;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableHeaderComponent.prototype, "columns", {
get: /**
* @return {?}
*/
function () {
return this._columns;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
var _this = this;
this._columns = val;
/** @type {?} */
var colsByPin = columnsByPin(val);
this._columnsByPin = columnsByPinArr(val);
setTimeout((/**
* @return {?}
*/
function () {
_this._columnGroupWidths = columnGroupWidths(colsByPin, val);
_this.setStylesByGroup();
}));
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableHeaderComponent.prototype, "offsetX", {
get: /**
* @return {?}
*/
function () {
return this._offsetX;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._offsetX = val;
this.setStylesByGroup();
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
DataTableHeaderComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.destroyed = true;
};
/**
* @param {?} __0
* @return {?}
*/
DataTableHeaderComponent.prototype.onLongPressStart = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var event = _a.event, model = _a.model;
model.dragging = true;
this.dragEventTarget = event;
};
/**
* @param {?} __0
* @return {?}
*/
DataTableHeaderComponent.prototype.onLongPressEnd = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _this = this;
var event = _a.event, model = _a.model;
this.dragEventTarget = event;
// delay resetting so sort can be
// prevented if we were dragging
setTimeout((/**
* @return {?}
*/
function () {
// datatable component creates copies from columns on reorder
// set dragging to false on new objects
/** @type {?} */
var column = _this._columns.find((/**
* @param {?} c
* @return {?}
*/
function (c) { return c.$$id === model.$$id; }));
if (column) {
column.dragging = false;
}
}), 5);
};
Object.defineProperty(DataTableHeaderComponent.prototype, "headerWidth", {
get: /**
* @return {?}
*/
function () {
if (this.scrollbarH) {
return this.innerWidth + 'px';
}
return '100%';
},
enumerable: true,
configurable: true
});
/**
* @param {?} index
* @param {?} colGroup
* @return {?}
*/
DataTableHeaderComponent.prototype.trackByGroups = /**
* @param {?} index
* @param {?} colGroup
* @return {?}
*/
function (index, colGroup) {
return colGroup.type;
};
/**
* @param {?} index
* @param {?} column
* @return {?}
*/
DataTableHeaderComponent.prototype.columnTrackingFn = /**
* @param {?} index
* @param {?} column
* @return {?}
*/
function (index, column) {
return column.$$id;
};
/**
* @param {?} width
* @param {?} column
* @return {?}
*/
DataTableHeaderComponent.prototype.onColumnResized = /**
* @param {?} width
* @param {?} column
* @return {?}
*/
function (width, column) {
if (width <= column.minWidth) {
width = column.minWidth;
}
else if (width >= column.maxWidth) {
width = column.maxWidth;
}
this.resize.emit({
column: column,
prevValue: column.width,
newValue: width
});
};
/**
* @param {?} __0
* @return {?}
*/
DataTableHeaderComponent.prototype.onColumnReordered = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var prevIndex = _a.prevIndex, newIndex = _a.newIndex, model = _a.model;
/** @type {?} */
var column = this.getColumn(newIndex);
column.isTarget = false;
column.targetMarkerContext = undefined;
this.reorder.emit({
column: model,
prevValue: prevIndex,
newValue: newIndex
});
};
/**
* @param {?} __0
* @return {?}
*/
DataTableHeaderComponent.prototype.onTargetChanged = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var prevIndex = _a.prevIndex, newIndex = _a.newIndex, initialIndex = _a.initialIndex;
if (prevIndex || prevIndex === 0) {
/** @type {?} */
var oldColumn = this.getColumn(prevIndex);
oldColumn.isTarget = false;
oldColumn.targetMarkerContext = undefined;
}
if (newIndex || newIndex === 0) {
/** @type {?} */
var newColumn = this.getColumn(newIndex);
newColumn.isTarget = true;
if (initialIndex !== newIndex) {
newColumn.targetMarkerContext = {
class: 'targetMarker '.concat(initialIndex > newIndex ? 'dragFromRight' : 'dragFromLeft')
};
}
}
};
/**
* @param {?} index
* @return {?}
*/
DataTableHeaderComponent.prototype.getColumn = /**
* @param {?} index
* @return {?}
*/
function (index) {
/** @type {?} */
var leftColumnCount = this._columnsByPin[0].columns.length;
if (index < leftColumnCount) {
return this._columnsByPin[0].columns[index];
}
/** @type {?} */
var 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];
};
/**
* @param {?} __0
* @return {?}
*/
DataTableHeaderComponent.prototype.onSort = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var column = _a.column, prevValue = _a.prevValue, newValue = _a.newValue;
// if we are dragging don't sort!
if (column.dragging) {
return;
}
/** @type {?} */
var sorts = this.calcNewSorts(column, prevValue, newValue);
this.sort.emit({
sorts: sorts,
column: column,
prevValue: prevValue,
newValue: newValue
});
};
/**
* @param {?} column
* @param {?} prevValue
* @param {?} newValue
* @return {?}
*/
DataTableHeaderComponent.prototype.calcNewSorts = /**
* @param {?} column
* @param {?} prevValue
* @param {?} newValue
* @return {?}
*/
function (column, prevValue, newValue) {
/** @type {?} */
var idx = 0;
if (!this.sorts) {
this.sorts = [];
}
/** @type {?} */
var sorts = this.sorts.map((/**
* @param {?} s
* @param {?} i
* @return {?}
*/
function (s, i) {
s = __assign({}, 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;
};
/**
* @return {?}
*/
DataTableHeaderComponent.prototype.setStylesByGroup = /**
* @return {?}
*/
function () {
this._styleByGroup.left = this.calcStylesByGroup('left');
this._styleByGroup.center = this.calcStylesByGroup('center');
this._styleByGroup.right = this.calcStylesByGroup('right');
if (!this.destroyed) {
this.cd.detectChanges();
}
};
/**
* @param {?} group
* @return {?}
*/
DataTableHeaderComponent.prototype.calcStylesByGroup = /**
* @param {?} group
* @return {?}
*/
function (group) {
/** @type {?} */
var widths = this._columnGroupWidths;
/** @type {?} */
var offsetX = this.offsetX;
/** @type {?} */
var styles = {
width: widths[group] + "px"
};
if (group === 'center') {
translateXY(styles, offsetX * -1, 0);
}
else if (group === 'right') {
/** @type {?} */
var totalDiff = widths.total - this.innerWidth;
/** @type {?} */
var offset = totalDiff * -1;
translateXY(styles, offset, 0);
}
return styles;
};
DataTableHeaderComponent.decorators = [
{ type: Component, args: [{
selector: 'datatable-header',
template: "\n