import { __decorate, __metadata } from "tslib";
import { CommonModule } from '@angular/common';
import { ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, Directive, DoCheck, EmbeddedViewRef, EventEmitter, Input, IterableChanges, IterableDiffer, IterableDiffers, NgModule, NgZone, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, TemplateRef, TrackByFunction, ViewContainerRef, ViewRef, AfterViewInit } from '@angular/core';
import { DisplayContainerComponent } from './display.container';
import { HVirtualHelperComponent } from './horizontal.virtual.helper.component';
import { VirtualHelperComponent } from './virtual.helper.component';
import { IgxScrollInertiaModule } from './../scroll-inertia/scroll_inertia.directive';
import { IgxForOfSyncService, IgxForOfScrollSyncService } from './for_of.sync.service';
import { Subject } from 'rxjs';
import { takeUntil, filter, throttleTime, first } from 'rxjs/operators';
import ResizeObserver from 'resize-observer-polyfill';
import { VirtualHelperBaseDirective } from './base.helper.component';
/**
 *  @publicApi
 */
export class IgxForOfContext {
    constructor($implicit, index, count) {
        this.$implicit = $implicit;
        this.index = index;
        this.count = count;
    }
    /**
     * A function that returns whether the element is the first or not
     */
    get first() { return this.index === 0; }
    /**
     * A function that returns whether the element is the last or not
     */
    get last() { return this.index === this.count - 1; }
    /**
     * A function that returns whether the element is even or not
     */
    get even() { return this.index % 2 === 0; }
    /**
     * A function that returns whether the element is odd or not
     */
    get odd() { return !this.even; }
}
let IgxForOfDirective = class IgxForOfDirective {
    constructor(_viewContainer, _template, _differs, resolver, cdr, _zone, syncScrollService) {
        this._viewContainer = _viewContainer;
        this._template = _template;
        this._differs = _differs;
        this.resolver = resolver;
        this.cdr = cdr;
        this._zone = _zone;
        this.syncScrollService = syncScrollService;
        /**
         * An @Input property that specifies the scroll orientation.
         * Scroll orientation can be "vertical" or "horizontal".
         * ```html
         * <ng-template igxFor let-item [igxForOf]="data" [igxForScrollOrientation]="'horizontal'"></ng-template>
         * ```
         */
        this.igxForScrollOrientation = 'vertical';
        /**
         * The current state of the directive. It contains `startIndex` and `chunkSize`.
         * state.startIndex - The index of the item at which the current visible chunk begins.
         * state.chunkSize - The number of items the current visible chunk holds.
         * These options can be used when implementing remote virtualization as they provide the necessary state information.
         * ```typescript
         * const gridState = this.parentVirtDir.state;
         * ```
         */
        this.state = {
            startIndex: 0,
            chunkSize: 0
        };
        /**
         * The total count of the virtual data items, when using remote service.
         * ```typescript
         * this.parentVirtDir.totalItemCount = data.Count;
         * ```
         */
        this.totalItemCount = null;
        /**
         * An event that is emitted after a new chunk has been loaded.
         * ```html
         * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (onChunkLoad)="chunkLoad($event)"></ng-template>
         * ```
         * ```typescript
         * chunkLoad(e){
         * alert("chunk loaded!");
         * }
         * ```
         */
        this.onChunkLoad = new EventEmitter();
        /**
         * @hidden @internal
         * An event that is emitted when scrollbar visibility has changed.
         */
        this.onScrollbarVisibilityChanged = new EventEmitter();
        /**
         * An event that is emitted after the rendered content size of the igxForOf has been changed.
        */
        this.onContentSizeChange = new EventEmitter();
        /**
         * An event that is emitted after data has been changed.
         * ```html
         * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (onDataChanged)="dataChanged($event)"></ng-template>
         * ```
         * ```typescript
         * dataChanged(e){
         * alert("data changed!");
         * }
         * ```
         */
        this.onDataChanged = new EventEmitter();
        this.onBeforeViewDestroyed = new EventEmitter();
        /**
         * An event that is emitted on chunk loading to emit the current state information - startIndex, endIndex, totalCount.
         * Can be used for implementing remote load on demand for the igxFor data.
         * ```html
         * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (onChunkPreload)="chunkPreload($event)"></ng-template>
         * ```
         * ```typescript
         * chunkPreload(e){
         * alert("chunk is loading!");
         * }
         * ```
         */
        this.onChunkPreload = new EventEmitter();
        this._sizesCache = [];
        this._differ = null;
        this.heightCache = [];
        this.MAX_PERF_SCROLL_DIFF = 4;
        /** Height that is being virtualized. */
        this._virtHeight = 0;
        /**
         * Ratio for height that's being virtualizaed and the one visible
         * If _virtHeightRatio = 1, the visible height and the virtualized are the same, also _maxHeight > _virtHeight.
         */
        this._virtHeightRatio = 1;
        /** Internal track for scroll top that is being virtualized */
        this._virtScrollTop = 0;
        /** If the next onScroll event is triggered due to internal setting of scrollTop */
        this._bScrollInternal = false;
        // End properties related to virtual height handling
        this._embeddedViews = [];
        this.contentResizeNotify = new Subject();
        /**
         * @hidden
         */
        this.destroy$ = new Subject();
    }
    get displayContainer() {
        return this.dc.instance._viewContainer.element.nativeElement;
    }
    get virtualHelper() {
        return this.scrollComponent.nativeElement;
    }
    get sizesCache() {
        return this._sizesCache;
    }
    set sizesCache(value) {
        this._sizesCache = value;
    }
    get _isScrolledToBottom() {
        if (!this.getScroll()) {
            return true;
        }
        const scrollHeight = this.getScroll().scrollHeight;
        // Use === and not >= because `scrollTop + container size` can't be bigger than `scrollHeight`, unless something isn't updated.
        // Also use Math.round because Chrome has some inconsistencies and `scrollTop + container` can be float when zooming the page.
        return Math.round(this.getScroll().scrollTop + this.igxForContainerSize) === scrollHeight;
    }
    get _isAtBottomIndex() {
        return this.igxForOf && this.state.startIndex + this.state.chunkSize > this.igxForOf.length;
    }
    /**
     * @hidden
     */
    get isRemote() {
        return this.totalItemCount !== null;
    }
    /**
     *
     * Gets/Sets the scroll position.
     * ```typescript
     * const position = directive.scrollPosition;
     * directive.scrollPosition = value;
     * ```
     */
    get scrollPosition() {
        return this.scrollComponent.scrollAmount;
    }
    set scrollPosition(val) {
        if (val === this.scrollComponent.scrollAmount) {
            return;
        }
        if (this.igxForScrollOrientation === 'horizontal' && this.scrollComponent) {
            this.scrollComponent.nativeElement.scrollLeft = val;
        }
        else if (this.scrollComponent) {
            this.scrollComponent.nativeElement.scrollTop = val;
        }
    }
    /**
     * @hidden
     */
    removeScrollEventListeners() {
        if (this.igxForScrollOrientation === 'horizontal') {
            this._zone.runOutsideAngular(() => this.scrollComponent.nativeElement.removeEventListener('scroll', this.func));
        }
        else {
            this._zone.runOutsideAngular(() => this.scrollComponent.nativeElement.removeEventListener('scroll', this.verticalScrollHandler));
        }
    }
    verticalScrollHandler(event) {
        this.onScroll(event);
    }
    isScrollable() {
        return this.scrollComponent.size > parseInt(this.igxForContainerSize, 10);
    }
    /**
     * @hidden
     */
    ngOnInit() {
        let totalSize = 0;
        const vc = this.igxForScrollContainer ? this.igxForScrollContainer._viewContainer : this._viewContainer;
        this.igxForSizePropName = this.igxForSizePropName || 'width';
        const dcFactory = this.resolver.resolveComponentFactory(DisplayContainerComponent);
        this.dc = this._viewContainer.createComponent(dcFactory, 0);
        this.dc.instance.scrollDirection = this.igxForScrollOrientation;
        if (typeof MSGesture === 'function') {
            // On Edge and IE when scrolling on touch the page scroll instead of the grid.
            this.dc.instance._viewContainer.element.nativeElement.style.touchAction = 'none';
        }
        if (this.igxForOf && this.igxForOf.length) {
            totalSize = this.initSizesCache(this.igxForOf);
            this.scrollComponent = this.syncScrollService.getScrollMaster(this.igxForScrollOrientation);
            this.state.chunkSize = this._calculateChunkSize();
            this.dc.instance.notVirtual = !(this.igxForContainerSize && this.state.chunkSize < this.igxForOf.length);
            if (this.scrollComponent) {
                this.state.startIndex = Math.min(this.getIndexAt(this.scrollPosition, this.sizesCache, 0), this.igxForOf.length - this.state.chunkSize);
            }
            for (let i = this.state.startIndex; i < this.state.startIndex + this.state.chunkSize &&
                this.igxForOf[i] !== undefined; i++) {
                const input = this.igxForOf[i];
                const embeddedView = this.dc.instance._vcr.createEmbeddedView(this._template, new IgxForOfContext(input, this.getContextIndex(input), this.igxForOf.length));
                this._embeddedViews.push(embeddedView);
            }
        }
        if (this.igxForScrollOrientation === 'vertical') {
            this.dc.instance._viewContainer.element.nativeElement.style.top = '0px';
            const factory = this.resolver.resolveComponentFactory(VirtualHelperComponent);
            this.scrollComponent = vc.createComponent(factory).instance;
            this._maxHeight = this._calcMaxBrowserHeight();
            this.scrollComponent.size = this.igxForOf ? this._calcHeight() : 0;
            this.syncScrollService.setScrollMaster(this.igxForScrollOrientation, this.scrollComponent);
            this._zone.runOutsideAngular(() => {
                this.verticalScrollHandler = this.verticalScrollHandler.bind(this);
                this.scrollComponent.nativeElement.addEventListener('scroll', this.verticalScrollHandler);
                this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;
            });
            const destructor = takeUntil(this.destroy$);
            this.contentResizeNotify.pipe(destructor, filter(() => this.igxForContainerSize && this.igxForOf && this.igxForOf.length > 0), throttleTime(40))
                .subscribe(() => {
                this._zone.runTask(() => {
                    this.updateSizes();
                });
            });
        }
        if (this.igxForScrollOrientation === 'horizontal') {
            this.func = (evt) => { this.onHScroll(evt); };
            this.scrollComponent = this.syncScrollService.getScrollMaster(this.igxForScrollOrientation);
            if (!this.scrollComponent) {
                const hvFactory = this.resolver.resolveComponentFactory(HVirtualHelperComponent);
                this.scrollComponent = vc.createComponent(hvFactory).instance;
                this.scrollComponent.size = totalSize;
                this.syncScrollService.setScrollMaster(this.igxForScrollOrientation, this.scrollComponent);
                this._zone.runOutsideAngular(() => {
                    this.scrollComponent.nativeElement.addEventListener('scroll', this.func);
                    this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;
                });
            }
            else {
                this._zone.runOutsideAngular(() => {
                    this.scrollComponent.nativeElement.addEventListener('scroll', this.func);
                    this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;
                });
            }
            this._updateHScrollOffset();
        }
    }
    ngAfterViewInit() {
        if (this.igxForScrollOrientation === 'vertical') {
            this._zone.runOutsideAngular(() => {
                this.contentObserver = new ResizeObserver(() => this.contentResizeNotify.next());
                this.contentObserver.observe(this.dc.instance._viewContainer.element.nativeElement);
            });
        }
    }
    /**
     * @hidden
     */
    ngOnDestroy() {
        this.removeScrollEventListeners();
        this.destroy$.next(true);
        this.destroy$.complete();
        if (this.contentObserver) {
            this.contentObserver.disconnect();
        }
    }
    /**
     * @hidden
     */
    ngOnChanges(changes) {
        const forOf = 'igxForOf';
        if (forOf in changes) {
            const value = changes[forOf].currentValue;
            if (!this._differ && value) {
                try {
                    this._differ = this._differs.find(value).create(this.igxForTrackBy);
                }
                catch (e) {
                    throw new Error(`Cannot find a differ supporting object "${value}" of type "${getTypeNameForDebugging(value)}".
                     NgFor only supports binding to Iterables such as Arrays.`);
                }
            }
        }
        const defaultItemSize = 'igxForItemSize';
        if (defaultItemSize in changes && !changes[defaultItemSize].firstChange &&
            this.igxForScrollOrientation === 'vertical' && this.igxForOf) {
            // handle default item size changed.
            this.initSizesCache(this.igxForOf);
            this._applyChanges();
        }
        const containerSize = 'igxForContainerSize';
        if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {
            this._recalcOnContainerChange(changes);
        }
    }
    /**
     * @hidden
     */
    ngDoCheck() {
        if (this._differ) {
            const changes = this._differ.diff(this.igxForOf);
            if (changes) {
                //  re-init cache.
                if (!this.igxForOf) {
                    this.igxForOf = [];
                }
                this._updateSizeCache();
                this._zone.run(() => {
                    this._applyChanges();
                    this.cdr.markForCheck();
                    this._updateScrollOffset();
                    this.onDataChanged.emit();
                });
            }
        }
    }
    /**
     * Shifts the scroll thumb position.
     * ```typescript
     * this.parentVirtDir.addScrollTop(5);
     * ```
     * @param addTop negative value to scroll up and positive to scroll down;
     */
    addScrollTop(addTop) {
        if (addTop === 0 && this.igxForScrollOrientation === 'horizontal') {
            return false;
        }
        const originalVirtScrollTop = this._virtScrollTop;
        const containerSize = parseInt(this.igxForContainerSize, 10);
        const maxVirtScrollTop = this._virtHeight - containerSize;
        this._bScrollInternal = true;
        this._virtScrollTop += addTop;
        this._virtScrollTop = this._virtScrollTop > 0 ?
            (this._virtScrollTop < maxVirtScrollTop ? this._virtScrollTop : maxVirtScrollTop) :
            0;
        this.scrollPosition += addTop / this._virtHeightRatio;
        if (Math.abs(addTop / this._virtHeightRatio) < 1) {
            // Actual scroll delta that was added is smaller than 1 and onScroll handler doesn't trigger when scrolling < 1px
            const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);
            // scrollOffset = scrollOffset !== parseInt(this.igxForItemSize, 10) ? scrollOffset : 0;
            this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';
        }
        const maxRealScrollTop = this.scrollComponent.nativeElement.scrollHeight - containerSize;
        if ((this._virtScrollTop > 0 && this.scrollPosition === 0) ||
            (this._virtScrollTop < maxVirtScrollTop && this.scrollPosition === maxRealScrollTop)) {
            // Actual scroll position is at the top or bottom, but virtual one is not at the top or bottom (there's more to scroll)
            // Recalculate actual scroll position based on the virtual scroll.
            this.scrollPosition = this._virtScrollTop / this._virtHeightRatio;
        }
        else if (this._virtScrollTop === 0 && this.scrollPosition > 0) {
            // Actual scroll position is not at the top, but virtual scroll is. Just update the actual scroll
            this.scrollPosition = 0;
        }
        else if (this._virtScrollTop === maxVirtScrollTop && this.scrollPosition < maxRealScrollTop) {
            // Actual scroll position is not at the bottom, but virtual scroll is. Just update the acual scroll
            this.scrollPosition = maxRealScrollTop;
        }
        return this._virtScrollTop !== originalVirtScrollTop;
    }
    /**
     * Scrolls to the specified index.
     * ```typescript
     * this.parentVirtDir.scrollTo(5);
     * ```
     * @param index
     */
    scrollTo(index) {
        if (index < 0 || index > (this.isRemote ? this.totalItemCount : this.igxForOf.length) - 1) {
            return;
        }
        const containerSize = parseInt(this.igxForContainerSize, 10);
        const isPrevItem = index < this.state.startIndex || this.scrollPosition > this.sizesCache[index];
        let nextScroll = isPrevItem ? this.sizesCache[index] : this.sizesCache[index + 1] - containerSize;
        if (nextScroll < 0) {
            return;
        }
        if (this.igxForScrollOrientation === 'horizontal') {
            this.scrollPosition = nextScroll;
        }
        else {
            const maxVirtScrollTop = this._virtHeight - containerSize;
            if (nextScroll > maxVirtScrollTop) {
                nextScroll = maxVirtScrollTop;
            }
            this._bScrollInternal = true;
            this._virtScrollTop = nextScroll;
            this.scrollPosition = this._virtScrollTop / this._virtHeightRatio;
            this._adjustToIndex = !isPrevItem ? index : null;
        }
    }
    /**
     * Scrolls by one item into the appropriate next direction.
     * For "horizontal" orientation that will be the right column and for "vertical" that is the lower row.
     * ```typescript
     * this.parentVirtDir.scrollNext();
     * ```
     */
    scrollNext() {
        const scr = Math.ceil(this.scrollPosition);
        const endIndex = this.getIndexAt(scr + parseInt(this.igxForContainerSize, 10), this.sizesCache, 0);
        this.scrollTo(endIndex);
    }
    /**
     * Scrolls by one item into the appropriate previous direction.
     * For "horizontal" orientation that will be the left column and for "vertical" that is the upper row.
     * ```typescript
     * this.parentVirtDir.scrollPrev();
     * ```
     */
    scrollPrev() {
        this.scrollTo(this.state.startIndex - 1);
    }
    /**
     * Scrolls by one page into the appropriate next direction.
     * For "horizontal" orientation that will be one view to the right and for "vertical" that is one view to the bottom.
     * ```typescript
     * this.parentVirtDir.scrollNextPage();
     * ```
     */
    scrollNextPage() {
        if (this.igxForScrollOrientation === 'horizontal') {
            this.scrollPosition += parseInt(this.igxForContainerSize, 10);
        }
        else {
            this.addScrollTop(parseInt(this.igxForContainerSize, 10));
        }
    }
    /**
     * Scrolls by one page into the appropriate previous direction.
     * For "horizontal" orientation that will be one view to the left and for "vertical" that is one view to the top.
     * ```typescript
     * this.parentVirtDir.scrollPrevPage();
     * ```
     */
    scrollPrevPage() {
        if (this.igxForScrollOrientation === 'horizontal') {
            this.scrollPosition -= parseInt(this.igxForContainerSize, 10);
        }
        else {
            const containerSize = (parseInt(this.igxForContainerSize, 10));
            this.addScrollTop(-containerSize);
        }
    }
    /**
     * @hidden
     */
    getColumnScrollLeft(colIndex) {
        return this.sizesCache[colIndex];
    }
    /**
     * Returns the total number of items that are fully visible.
     * ```typescript
     * this.parentVirtDir.getItemCountInView();
     * ```
     */
    getItemCountInView() {
        let startIndex = this.getIndexAt(this.scrollPosition, this.sizesCache, 0);
        if (this.scrollPosition - this.sizesCache[startIndex] > 0) {
            // fisrt item is not fully in view
            startIndex++;
        }
        const endIndex = this.getIndexAt(this.scrollPosition + parseInt(this.igxForContainerSize, 10), this.sizesCache, 0);
        return endIndex - startIndex;
    }
    /**
     * Returns a reference to the scrollbar DOM element.
     * This is either a vertical or horizontal scrollbar depending on the specified igxForScrollOrientation.
     * ```typescript
     * dir.getScroll();
     * ```
     */
    getScroll() {
        return this.scrollComponent.nativeElement;
    }
    /**
     * Returns the size of the element at the specified index.
     * ```typescript
     * this.parentVirtDir.getSizeAt(1);
     * ```
     */
    getSizeAt(index) {
        return this.sizesCache[index + 1] - this.sizesCache[index];
    }
    /**
     * Returns the scroll offset of the element at the specified index.
     * ```typescript
     * this.parentVirtDir.getScrollForIndex(1);
     * ```
     */
    getScrollForIndex(index, bottom) {
        const containerSize = parseInt(this.igxForContainerSize, 10);
        const scroll = bottom ? Math.max(0, this.sizesCache[index + 1] - containerSize) : this.sizesCache[index];
        return scroll;
    }
    /**
     * @hidden
     * Function that is called when scrolling vertically
     */
    onScroll(event) {
        /* in certain situations this may be called when no scrollbar is visible */
        if (!parseInt(this.scrollComponent.nativeElement.style.height, 10)) {
            return;
        }
        const containerSize = parseInt(this.igxForContainerSize, 10);
        const maxRealScrollTop = event.target.children[0].scrollHeight - containerSize;
        const realPercentScrolled = maxRealScrollTop !== 0 ? event.target.scrollTop / maxRealScrollTop : 0;
        if (!this._bScrollInternal) {
            const maxVirtScrollTop = this._virtHeight - containerSize;
            this._virtScrollTop = realPercentScrolled * maxVirtScrollTop;
        }
        else {
            this._bScrollInternal = false;
        }
        const prevStartIndex = this.state.startIndex;
        const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);
        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';
        this.dc.changeDetectorRef.detectChanges();
        if (prevStartIndex !== this.state.startIndex) {
            this.onChunkLoad.emit(this.state);
        }
    }
    updateSizes() {
        this.recalcUpdateSizes();
        this._applyChanges();
        this._updateScrollOffset();
        this.onContentSizeChange.emit();
    }
    /**
     * @hidden
     * Function that recaculates and updates cache sizes.
     */
    recalcUpdateSizes() {
        const dimension = this.igxForScrollOrientation === 'horizontal' ?
            this.igxForSizePropName : 'height';
        const diffs = [];
        let totalDiff = 0;
        const l = this._embeddedViews.length;
        const rNodes = this._embeddedViews.map(view => view.rootNodes.find(node => node.nodeType === Node.ELEMENT_NODE) || view.rootNodes[0].nextElementSibling);
        for (let i = 0; i < l; i++) {
            const rNode = rNodes[i];
            if (rNode) {
                const h = rNode.offsetHeight || parseInt(this.igxForItemSize, 10);
                const index = this.state.startIndex + i;
                if (!this.isRemote && !this.igxForOf[index]) {
                    continue;
                }
                const oldVal = dimension === 'height' ? this.heightCache[index] : this.igxForOf[index][dimension];
                const newVal = dimension === 'height' ? h : rNode.clientWidth;
                if (dimension === 'height') {
                    this.heightCache[index] = newVal;
                }
                else {
                    this.igxForOf[index][dimension] = newVal;
                }
                const currDiff = newVal - oldVal;
                diffs.push(currDiff);
                totalDiff += currDiff;
                this.sizesCache[index + 1] += totalDiff;
            }
        }
        // update cache
        if (Math.abs(totalDiff) > 0) {
            for (let j = this.state.startIndex + this.state.chunkSize + 1; j < this.sizesCache.length; j++) {
                this.sizesCache[j] += totalDiff;
            }
            // update scrBar heights/widths
            if (this.igxForScrollOrientation === 'horizontal') {
                const totalWidth = parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10) + totalDiff;
                this.scrollComponent.nativeElement.children[0].style.width = totalWidth + 'px';
            }
            const reducer = (acc, val) => acc + val;
            if (this.igxForScrollOrientation === 'vertical') {
                const scrToBottom = this._isScrolledToBottom && !this.dc.instance.notVirtual;
                const hSum = this.heightCache.reduce(reducer);
                if (hSum > this._maxHeight) {
                    this._virtHeightRatio = hSum / this._maxHeight;
                }
                this.scrollComponent.size = Math.min(this.scrollComponent.size + totalDiff, this._maxHeight);
                this._virtHeight = hSum;
                if (!this.scrollComponent.destroyed) {
                    this.scrollComponent.cdr.detectChanges();
                }
                if (scrToBottom && !this._isAtBottomIndex) {
                    const containerSize = parseInt(this.igxForContainerSize, 10);
                    const maxVirtScrollTop = this._virtHeight - containerSize;
                    this._bScrollInternal = true;
                    this._virtScrollTop = maxVirtScrollTop;
                    this.scrollPosition = maxVirtScrollTop;
                    return;
                }
                if (this._adjustToIndex) {
                    // in case scrolled to specific index where after scroll heights are changed
                    // need to adjust the offsets so that item is last in view.
                    const updatesToIndex = this._adjustToIndex - this.state.startIndex + 1;
                    const sumDiffs = diffs.slice(0, updatesToIndex).reduce(reducer);
                    const currOffset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);
                    this.dc.instance._viewContainer.element.nativeElement.style.top = (currOffset - sumDiffs) + 'px';
                    this._adjustToIndex = null;
                }
            }
        }
    }
    /**
     * @hidden
     */
    fixedUpdateAllElements(inScrollTop) {
        const count = this.isRemote ? this.totalItemCount : this.igxForOf.length;
        let newStart = this.getIndexAt(inScrollTop, this.sizesCache, 0);
        if (newStart + this.state.chunkSize > count) {
            newStart = count - this.state.chunkSize;
        }
        const prevStart = this.state.startIndex;
        const diff = newStart - this.state.startIndex;
        this.state.startIndex = newStart;
        if (diff) {
            this.onChunkPreload.emit(this.state);
            if (!this.isRemote) {
                /*recalculate and apply page size.*/
                if (diff > 0 && diff <= this.MAX_PERF_SCROLL_DIFF) {
                    this.moveApplyScrollNext(prevStart);
                }
                else if (diff < 0 && Math.abs(diff) <= this.MAX_PERF_SCROLL_DIFF) {
                    this.moveApplyScrollPrev(prevStart);
                }
                else {
                    this.fixedApplyScroll();
                }
            }
        }
        return inScrollTop - this.sizesCache[this.state.startIndex];
    }
    /**
     * @hidden
     * The function applies an optimized state change for scrolling down/right employing context change with view rearrangement
     */
    moveApplyScrollNext(prevIndex) {
        const start = prevIndex + this.state.chunkSize;
        for (let i = start; i < start + this.state.startIndex - prevIndex && this.igxForOf[i] !== undefined; i++) {
            const input = this.igxForOf[i];
            const embView = this._embeddedViews.shift();
            const cntx = embView.context;
            cntx.$implicit = input;
            cntx.index = this.getContextIndex(input);
            cntx.count = this.igxForOf.length;
            const view = this.dc.instance._vcr.detach(0);
            this.dc.instance._vcr.insert(view);
            this._embeddedViews.push(embView);
        }
    }
    /**
     * @hidden
     * The function applies an optimized state change for scrolling up/left employing context change with view rearrangement
     */
    moveApplyScrollPrev(prevIndex) {
        for (let i = prevIndex - 1; i >= this.state.startIndex && this.igxForOf[i] !== undefined; i--) {
            const input = this.igxForOf[i];
            const embView = this._embeddedViews.pop();
            const cntx = embView.context;
            cntx.$implicit = input;
            cntx.index = this.getContextIndex(input);
            const view = this.dc.instance._vcr.detach(this.dc.instance._vcr.length - 1);
            this.dc.instance._vcr.insert(view, 0);
            this._embeddedViews.unshift(embView);
        }
    }
    /**
     * @hidden
    */
    getContextIndex(input) {
        return this.isRemote ? this.state.startIndex + this.igxForOf.indexOf(input) : this.igxForOf.indexOf(input);
    }
    /**
     * @hidden
     * The function applies an optimized state change through context change for each view
     */
    fixedApplyScroll() {
        let j = 0;
        const endIndex = this.state.startIndex + this.state.chunkSize;
        for (let i = this.state.startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {
            const input = this.igxForOf[i];
            const embView = this._embeddedViews[j++];
            const cntx = embView.context;
            cntx.$implicit = input;
            cntx.index = this.getContextIndex(input);
            cntx.count = this.igxForOf.length;
        }
    }
    /**
     * @hidden
     * Function that is called when scrolling horizontally
     */
    onHScroll(event) {
        /* in certain situations this may be called when no scrollbar is visible */
        if (!parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10)) {
            return;
        }
        const prevStartIndex = this.state.startIndex;
        // Updating horizontal chunks
        const scrollOffset = this.fixedUpdateAllElements(event.target.scrollLeft);
        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';
        this.dc.changeDetectorRef.detectChanges();
        if (prevStartIndex !== this.state.startIndex) {
            this.onChunkLoad.emit(this.state);
        }
    }
    /**
     * Gets the function used to track changes in the items collection.
     * By default the object references are compared. However this can be optimized if you have unique identifier
     * value that can be used for the comparison instead of the object ref or if you have some other property values
     * in the item object that should be tracked for changes.
     * This option is similar to ngForTrackBy.
     * ```typescript
     * const trackFunc = this.parentVirtDir.igxForTrackBy;
     * ```
     */
    get igxForTrackBy() { return this._trackByFn; }
    /**
     * Sets the function used to track changes in the items collection.
     * This function can be set in scenarios where you want to optimize or
     * customize the tracking of changes for the items in the collection.
     * The igxForTrackBy function takes the index and the current item as arguments and needs to return the unique identifier for this item.
     * ```typescript
     * this.parentVirtDir.igxForTrackBy = (index, item) => {
     *      return item.id + item.width;
     * };
     * ```
     */
    set igxForTrackBy(fn) { this._trackByFn = fn; }
    /**
     * @hidden
     */
    _applyChanges() {
        const prevChunkSize = this.state.chunkSize;
        this.applyChunkSizeChange();
        this._recalcScrollBarSize();
        if (this.igxForOf && this.igxForOf.length && this.dc) {
            const embeddedViewCopy = Object.assign([], this._embeddedViews);
            let startIndex = this.state.startIndex;
            let endIndex = this.state.chunkSize + this.state.startIndex;
            if (this.isRemote) {
                startIndex = 0;
                endIndex = this.igxForOf.length;
            }
            for (let i = startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {
                const input = this.igxForOf[i];
                const embView = embeddedViewCopy.shift();
                const cntx = embView.context;
                cntx.$implicit = input;
                cntx.index = this.getContextIndex(input);
                cntx.count = this.igxForOf.length;
            }
            if (prevChunkSize !== this.state.chunkSize) {
                this.onChunkLoad.emit(this.state);
            }
        }
    }
    /**
     * @hidden
     */
    _calcMaxBrowserHeight() {
        const div = document.createElement('div');
        const style = div.style;
        style.position = 'absolute';
        style.top = '9999999999999999px';
        document.body.appendChild(div);
        const size = Math.abs(div.getBoundingClientRect()['top']);
        document.body.removeChild(div);
        return size;
    }
    /**
     * @hidden
     * Recalculates the chunkSize based on current startIndex and returns the new size.
     * This should be called after this.state.startIndex is updated, not before.
     */
    _calculateChunkSize() {
        let chunkSize = 0;
        if (this.igxForContainerSize !== null && this.igxForContainerSize !== undefined) {
            if (!this.sizesCache) {
                this.initSizesCache(this.igxForOf);
            }
            chunkSize = this._calcMaxChunkSize();
            if (this.igxForOf && chunkSize > this.igxForOf.length) {
                chunkSize = this.igxForOf.length;
            }
        }
        else {
            if (this.igxForOf) {
                chunkSize = this.igxForOf.length;
            }
        }
        return chunkSize;
    }
    /**
     * @hidden
     */
    getElement(viewref, nodeName) {
        const elem = viewref.element.nativeElement.parentNode.getElementsByTagName(nodeName);
        return elem.length > 0 ? elem[0] : null;
    }
    /**
     * @hidden
     */
    initSizesCache(items) {
        let totalSize = 0;
        let size = 0;
        const dimension = this.igxForScrollOrientation === 'horizontal' ?
            this.igxForSizePropName : 'height';
        let i = 0;
        this.sizesCache = [];
        this.heightCache = [];
        this.sizesCache.push(0);
        const count = this.isRemote ? this.totalItemCount : items.length;
        for (i; i < count; i++) {
            if (dimension === 'height') {
                // cols[i][dimension] = parseInt(this.igxForItemSize, 10) || 0;
                size = parseInt(this.igxForItemSize, 10) || 0;
                this.heightCache.push(size);
            }
            else {
                size = this._getItemSize(items[i], dimension);
            }
            totalSize += size;
            this.sizesCache.push(totalSize);
        }
        return totalSize;
    }
    _updateSizeCache() {
        if (this.igxForScrollOrientation === 'horizontal') {
            this.initSizesCache(this.igxForOf);
            return;
        }
        const oldHeight = this.heightCache.length > 0 ? this.heightCache.reduce((acc, val) => acc + val) : 0;
        const newHeight = this.initSizesCache(this.igxForOf);
        const diff = oldHeight - newHeight;
        // if data has been changed while container is scrolled
        // should update scroll top/left according to change so that same startIndex is in view
        if (Math.abs(diff) > 0 && this.scrollPosition > 0) {
            this.recalcUpdateSizes();
            const offset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);
            this.scrollPosition = this.sizesCache[this.state.startIndex] - offset;
        }
    }
    /**
     * @hidden
     */
    _calcMaxChunkSize() {
        let i = 0;
        let length = 0;
        let maxLength = 0;
        const arr = [];
        let sum = 0;
        const availableSize = parseInt(this.igxForContainerSize, 10);
        if (!availableSize) {
            return 0;
        }
        const dimension = this.igxForScrollOrientation === 'horizontal' ?
            this.igxForSizePropName : 'height';
        const reducer = (accumulator, currentItem) => accumulator + this._getItemSize(currentItem, dimension);
        for (i; i < this.igxForOf.length; i++) {
            let item = this.igxForOf[i];
            if (dimension === 'height') {
                item = { value: this.igxForOf[i], height: this.heightCache[i] };
            }
            const size = dimension === 'height' ?
                this.heightCache[i] :
                this._getItemSize(item, dimension);
            sum = arr.reduce(reducer, size);
            if (sum < availableSize) {
                arr.push(item);
                length = arr.length;
                if (i === this.igxForOf.length - 1) {
                    // reached end without exceeding
                    // include prev items until size is filled or first item is reached.
                    let curItem = dimension === 'height' ? arr[0].value : arr[0];
                    let prevIndex = this.igxForOf.indexOf(curItem) - 1;
                    while (prevIndex >= 0 && sum <= availableSize) {
                        curItem = dimension === 'height' ? arr[0].value : arr[0];
                        prevIndex = this.igxForOf.indexOf(curItem) - 1;
                        const prevItem = this.igxForOf[prevIndex];
                        const prevSize = dimension === 'height' ?
                            this.heightCache[prevIndex] :
                            parseInt(prevItem[dimension], 10);
                        sum = arr.reduce(reducer, prevSize);
                        arr.unshift(prevItem);
                        length = arr.length;
                    }
                }
            }
            else {
                arr.push(item);
                length = arr.length + 1;
                arr.shift();
            }
            if (length > maxLength) {
                maxLength = length;
            }
        }
        return maxLength;
    }
    /**
     * @hidden
     */
    getIndexAt(left, set, index) {
        let start = 0;
        let end = set.length - 1;
        if (left === 0) {
            return 0;
        }
        while (start <= end) {
            const midIdx = Math.floor((start + end) / 2);
            const midLeft = set[midIdx];
            const cmp = left - midLeft;
            if (cmp > 0) {
                start = midIdx + 1;
            }
            else if (cmp < 0) {
                end = midIdx - 1;
            }
            else {
                return midIdx;
            }
        }
        return end;
    }
    _recalcScrollBarSize() {
        const count = this.isRemote ? this.totalItemCount : (this.igxForOf ? this.igxForOf.length : 0);
        this.dc.instance.notVirtual = !(this.igxForContainerSize && this.dc && this.state.chunkSize < count);
        const scrollable = this.isScrollable();
        if (this.igxForScrollOrientation === 'horizontal') {
            const totalWidth = this.igxForContainerSize ? this.initSizesCache(this.igxForOf) : 0;
            this.scrollComponent.nativeElement.style.width = this.igxForContainerSize + 'px';
            this.scrollComponent.size = totalWidth;
            if (totalWidth <= parseInt(this.igxForContainerSize, 10)) {
                this.scrollPosition = 0;
            }
        }
        if (this.igxForScrollOrientation === 'vertical') {
            this.scrollComponent.nativeElement.style.height = parseInt(this.igxForContainerSize, 10) + 'px';
            this.scrollComponent.size = this._calcHeight();
            if (this.scrollComponent.size <= parseInt(this.igxForContainerSize, 10)) {
                this.scrollPosition = 0;
            }
        }
        if (scrollable !== this.isScrollable()) {
            // scrollbar visibility has changed
            this.onScrollbarVisibilityChanged.emit();
        }
    }
    _calcHeight() {
        let height;
        if (this.heightCache) {
            height = this.heightCache.reduce((acc, val) => acc + val, 0);
        }
        else {
            height = this.initSizesCache(this.igxForOf);
        }
        this._virtHeight = height;
        if (height > this._maxHeight) {
            this._virtHeightRatio = height / this._maxHeight;
            height = this._maxHeight;
        }
        return height;
    }
    _recalcOnContainerChange(changes) {
        this.dc.instance._viewContainer.element.nativeElement.style.top = '0px';
        this.dc.instance._viewContainer.element.nativeElement.style.left = '0px';
        const prevChunkSize = this.state.chunkSize;
        this.applyChunkSizeChange();
        this._recalcScrollBarSize();
        if (prevChunkSize !== this.state.chunkSize) {
            this.onChunkLoad.emit(this.state);
        }
        if (this.sizesCache && this.igxForScrollOrientation === 'horizontal') {
            // Updating horizontal chunks and offsets based on the new scrollLeft
            const scrollOffset = this.fixedUpdateAllElements(this.scrollPosition);
            this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';
        }
    }
    /**
     * @hidden
     * Removes an elemenet from the embedded views and updates chunkSize.
     */
    removeLastElem() {
        const oldElem = this._embeddedViews.pop();
        this.onBeforeViewDestroyed.emit(oldElem);
        // also detach from ViewContainerRef to make absolutely sure this is removed from the view container.
        this.dc.instance._vcr.detach(this.dc.instance._vcr.length - 1);
        oldElem.destroy();
        this.state.chunkSize--;
    }
    /**
     * @hidden
     * If there exists an element that we can create embedded view for creates it, appends it and updates chunkSize
     */
    addLastElem() {
        let elemIndex = this.state.startIndex + this.state.chunkSize;
        if (!this.isRemote && !this.igxForOf) {
            return;
        }
        if (elemIndex >= this.igxForOf.length) {
            elemIndex = this.igxForOf.length - this.state.chunkSize;
        }
        const input = this.igxForOf[elemIndex];
        const embeddedView = this.dc.instance._vcr.createEmbeddedView(this._template, new IgxForOfContext(input, this.getContextIndex(input), this.igxForOf.length));
        this._embeddedViews.push(embeddedView);
        this.state.chunkSize++;
        this._zone.run(() => {
            this.cdr.markForCheck();
        });
    }
    /**
     * Recalculates chunkSize and adds/removes elements if need due to the change.
     * this.state.chunkSize is updated in @addLastElem() or @removeLastElem()
     */
    applyChunkSizeChange() {
        const chunkSize = this.isRemote ? (this.igxForOf ? this.igxForOf.length : 0) : this._calculateChunkSize();
        if (chunkSize > this.state.chunkSize) {
            const diff = chunkSize - this.state.chunkSize;
            for (let i = 0; i < diff; i++) {
                this.addLastElem();
            }
        }
        else if (chunkSize < this.state.chunkSize) {
            const diff = this.state.chunkSize - chunkSize;
            for (let i = 0; i < diff; i++) {
                this.removeLastElem();
            }
        }
    }
    _updateScrollOffset() {
        if (this.igxForScrollOrientation === 'horizontal') {
            this._updateHScrollOffset();
        }
        else {
            this._updateVScrollOffset();
        }
    }
    _updateVScrollOffset() {
        let scrollOffset = 0;
        const vScroll = this.scrollComponent.nativeElement;
        scrollOffset = vScroll && this.scrollComponent.size ?
            this.scrollPosition - this.sizesCache[this.state.startIndex] : 0;
        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';
    }
    _updateHScrollOffset() {
        let scrollOffset = 0;
        scrollOffset = this.scrollComponent.nativeElement &&
            this.scrollComponent.size ?
            this.scrollPosition - this.sizesCache[this.state.startIndex] : 0;
        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';
    }
    _getItemSize(item, dimension) {
        const dim = item[dimension];
        return typeof dim === 'number' ? dim : parseInt(this.igxForItemSize, 10) || 0;
    }
};
IgxForOfDirective.ctorParameters = () => [
    { type: ViewContainerRef },
    { type: TemplateRef },
    { type: IterableDiffers },
    { type: ComponentFactoryResolver },
    { type: ChangeDetectorRef },
    { type: NgZone },
    { type: IgxForOfScrollSyncService }
];
__decorate([
    Input(),
    __metadata("design:type", Array)
], IgxForOfDirective.prototype, "igxForOf", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "igxForSizePropName", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "igxForScrollOrientation", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "igxForScrollContainer", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "igxForContainerSize", void 0);
__decorate([
    Input(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "igxForItemSize", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onChunkLoad", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onScrollbarVisibilityChanged", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onContentSizeChange", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onDataChanged", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onBeforeViewDestroyed", void 0);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxForOfDirective.prototype, "onChunkPreload", void 0);
__decorate([
    Input(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Function])
], IgxForOfDirective.prototype, "igxForTrackBy", null);
IgxForOfDirective = __decorate([
    Directive({ selector: '[igxFor][igxForOf]' }),
    __metadata("design:paramtypes", [ViewContainerRef,
        TemplateRef,
        IterableDiffers,
        ComponentFactoryResolver,
        ChangeDetectorRef,
        NgZone,
        IgxForOfScrollSyncService])
], IgxForOfDirective);
export { IgxForOfDirective };
export function getTypeNameForDebugging(type) {
    const name = 'name';
    return type[name] || typeof type;
}
let IgxGridForOfDirective = class IgxGridForOfDirective extends IgxForOfDirective {
    constructor(_viewContainer, _template, _differs, resolver, cdr, _zone, syncScrollService, syncService) {
        super(_viewContainer, _template, _differs, resolver, cdr, _zone, syncScrollService);
        this.syncScrollService = syncScrollService;
        this.syncService = syncService;
        /**
         * @hidden @internal
         * An event that is emitted after data has been changed but before the view is refreshed
         */
        this.onDataChanging = new EventEmitter();
    }
    set igxGridForOf(value) {
        this.igxForOf = value;
    }
    get igxGridForOf() {
        return this.igxForOf;
    }
    ngOnInit() {
        this.syncService.setMaster(this);
        super.ngOnInit();
        this.removeScrollEventListeners();
    }
    ngOnChanges(changes) {
        const forOf = 'igxGridForOf';
        this.syncService.setMaster(this);
        if (forOf in changes) {
            const value = changes[forOf].currentValue;
            if (!this._differ && value) {
                try {
                    this._differ = this._differs.find(value).create(this.igxForTrackBy);
                }
                catch (e) {
                    throw new Error(`Cannot find a differ supporting object "${value}" of type "${getTypeNameForDebugging(value)}".
                     NgFor only supports binding to Iterables such as Arrays.`);
                }
            }
        }
        const defaultItemSize = 'igxForItemSize';
        if (defaultItemSize in changes && !changes[defaultItemSize].firstChange &&
            this.igxForScrollOrientation === 'vertical' && this.igxForOf) {
            // handle default item size changed.
            this.initSizesCache(this.igxForOf);
        }
        const containerSize = 'igxForContainerSize';
        if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {
            this._recalcOnContainerChange(changes);
        }
    }
    /**
     * @hidden
     * @internal
     */
    get sizesCache() {
        if (this.syncService.isMaster(this)) {
            return this._sizesCache;
        }
        return this.syncService.sizesCache(this.igxForScrollOrientation);
    }
    /**
     * @hidden
     * @internal
     */
    set sizesCache(value) {
        this._sizesCache = value;
    }
    get itemsDimension() {
        return this.igxForScrollOrientation === 'horizontal' ? this.igxForSizePropName : 'height';
    }
    getItemSize(item) {
        let size = 0;
        const dimension = this.igxForScrollOrientation === 'horizontal' ?
            this.igxForSizePropName : 'height';
        if (dimension === 'height') {
            size = parseInt(this.igxForItemSize, 10) || 0;
            if (item && item.summaries) {
                size = item.max;
            }
            else if (item && item.groups && item.height) {
                size = item.height;
            }
        }
        else {
            size = parseInt(item[dimension], 10) || 0;
        }
        return size;
    }
    initSizesCache(items) {
        if (!this.syncService.isMaster(this)) {
            const masterSizesCache = this.syncService.sizesCache(this.igxForScrollOrientation);
            return masterSizesCache[masterSizesCache.length - 1];
        }
        let totalSize = 0;
        let size = 0;
        let i = 0;
        this.sizesCache = [];
        this.heightCache = [];
        this.sizesCache.push(0);
        const count = this.isRemote ? this.totalItemCount : items.length;
        for (i; i < count; i++) {
            size = this.getItemSize(items[i]);
            if (this.itemsDimension === 'height') {
                this.heightCache.push(size);
            }
            totalSize += size;
            this.sizesCache.push(totalSize);
        }
        return totalSize;
    }
    _updateSizeCache(changes = null) {
        if (this.igxForScrollOrientation === 'horizontal') {
            this.initSizesCache(this.igxForOf);
            return;
        }
        const oldHeight = this.heightCache.length > 0 ? this.heightCache.reduce((acc, val) => acc + val) : 0;
        let newHeight = oldHeight;
        if (changes && !this.isRemote) {
            newHeight = this.handleCacheChanges(changes);
        }
        else {
            newHeight = this.initSizesCache(this.igxForOf);
        }
        const diff = oldHeight - newHeight;
        // if data has been changed while container is scrolled
        // should update scroll top/left according to change so that same startIndex is in view
        if (Math.abs(diff) > 0) {
            // TODO: This code can be removed. However tests need to be rewritten in a way that they wait for ResizeObserved to complete.
            // So leaving as is for the moment.
            requestAnimationFrame(() => {
                this.recalcUpdateSizes();
                const offset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);
                if (this.scrollPosition !== 0) {
                    this.scrollPosition = this.sizesCache[this.state.startIndex] - offset;
                }
                else {
                    this._updateScrollOffset();
                }
            });
        }
    }
    handleCacheChanges(changes) {
        const identityChanges = [];
        const newHeightCache = [];
        const newSizesCache = [];
        newSizesCache.push(0);
        let newHeight = 0;
        // When there are more than one removed items the changes are not reliable so those with identity change should be default size.
        let numRemovedItems = 0;
        changes.forEachRemovedItem(() => numRemovedItems++);
        // Get the identity changes to determine later if those that have changed their indexes should be assigned default item size.
        changes.forEachIdentityChange((item) => {
            if (item.currentIndex !== item.previousIndex) {
                // Filter out ones that have not changed their index.
                identityChanges[item.currentIndex] = item;
            }
        });
        // Processing each item that is passed to the igxForOf so far seem to be most reliable. We parse the updated list of items.
        changes.forEachItem((item) => {
            if (item.previousIndex !== null &&
                (numRemovedItems < 2 || !identityChanges.length || identityChanges[item.currentIndex])) {
                // Reuse cache on those who have previousIndex.
                // When there are more than one removed items currently the changes are not readable so ones with identity change
                // should be racalculated.
                newHeightCache[item.currentIndex] = this.heightCache[item.previousIndex];
            }
            else {
                // Assign default item size.
                newHeightCache[item.currentIndex] = this.getItemSize(item.item);
            }
            newSizesCache[item.currentIndex + 1] = newSizesCache[item.currentIndex] + newHeightCache[item.currentIndex];
            newHeight += newHeightCache[item.currentIndex];
        });
        this.heightCache = newHeightCache;
        this.sizesCache = newSizesCache;
        return newHeight;
    }
    /**
     * @hidden
     * @internal
     */
    assumeMaster() {
        this._sizesCache = this.syncService.sizesCache(this.igxForScrollOrientation);
        this.syncService.setMaster(this, true);
    }
    ngDoCheck() {
        if (this._differ) {
            const changes = this._differ.diff(this.igxForOf);
            if (changes) {
                const args = {
                    containerSize: this.igxForContainerSize
                };
                this.onDataChanging.emit(args);
                //  re-init cache.
                if (!this.igxForOf) {
                    this.igxForOf = [];
                }
                /* we need to reset the master dir if all rows are removed
                (e.g. because of filtering); if all columns are hidden, rows are
                still rendered empty, so we should not reset master */
                if (!this.igxForOf.length &&
                    this.igxForScrollOrientation === 'vertical') {
                    this.syncService.resetMaster();
                }
                this.syncService.setMaster(this);
                this.igxForContainerSize = args.containerSize;
                this._updateSizeCache(changes);
                this._applyChanges();
                this._updateScrollOffset();
                this.onDataChanged.emit();
            }
        }
    }
    onScroll(event) {
        if (!parseInt(this.scrollComponent.nativeElement.style.height, 10)) {
            return;
        }
        const containerSize = parseInt(this.igxForContainerSize, 10);
        const maxRealScrollTop = event.target.children[0].scrollHeight - containerSize;
        const realPercentScrolled = maxRealScrollTop !== 0 ? event.target.scrollTop / maxRealScrollTop : 0;
        if (!this._bScrollInternal) {
            const maxVirtScrollTop = this._virtHeight - containerSize;
            this._virtScrollTop = realPercentScrolled * maxVirtScrollTop;
        }
        else {
            this._bScrollInternal = false;
        }
        const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);
        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';
        this._zone.onStable.pipe(first()).subscribe(() => {
            this.recalcUpdateSizes();
        });
        this.cdr.markForCheck();
    }
    onHScroll(scrollAmount) {
        /* in certain situations this may be called when no scrollbar is visible */
        if (!this.scrollComponent || !parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10)) {
            return;
        }
        // Updating horizontal chunks
        const scrollOffset = this.fixedUpdateAllElements(scrollAmount);
        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';
    }
    addLastElem() {
        let elemIndex = this.state.startIndex + this.state.chunkSize;
        if (!this.isRemote && !this.igxForOf) {
            return;
        }
        if (elemIndex >= this.igxForOf.length) {
            elemIndex = this.igxForOf.length - this.state.chunkSize;
        }
        const input = this.igxForOf[elemIndex];
        const embeddedView = this.dc.instance._vcr.createEmbeddedView(this._template, new IgxForOfContext(input, this.getContextIndex(input), this.igxForOf.length));
        this._embeddedViews.push(embeddedView);
        this.state.chunkSize++;
    }
    _updateViews(prevChunkSize) {
        if (this.igxForOf && this.igxForOf.length && this.dc) {
            const embeddedViewCopy = Object.assign([], this._embeddedViews);
            let startIndex;
            let endIndex;
            if (this.isRemote) {
                startIndex = 0;
                endIndex = this.igxForOf.length;
            }
            else {
                startIndex = this.getIndexAt(this.scrollPosition, this.sizesCache, 0);
                if (startIndex + this.state.chunkSize > this.igxForOf.length) {
                    startIndex = this.igxForOf.length - this.state.chunkSize;
                }
                this.state.startIndex = startIndex;
                endIndex = this.state.chunkSize + this.state.startIndex;
            }
            for (let i = startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {
                const input = this.igxForOf[i];
                const embView = embeddedViewCopy.shift();
                const cntx = embView.context;
                cntx.$implicit = input;
                cntx.index = this.getContextIndex(input);
                cntx.count = this.igxForOf.length;
            }
            if (prevChunkSize !== this.state.chunkSize) {
                this.onChunkLoad.emit(this.state);
            }
        }
    }
    _applyChanges() {
        const prevChunkSize = this.state.chunkSize;
        this.applyChunkSizeChange();
        this._recalcScrollBarSize();
        this._updateViews(prevChunkSize);
    }
    /**
     * @hidden
     */
    _calcMaxChunkSize() {
        if (this.syncService.isMaster(this)) {
            return super._calcMaxChunkSize();
        }
        return this.syncService.chunkSize(this.igxForScrollOrientation);
    }
};
IgxGridForOfDirective.ctorParameters = () => [
    { type: ViewContainerRef },
    { type: TemplateRef },
    { type: IterableDiffers },
    { type: ComponentFactoryResolver },
    { type: ChangeDetectorRef },
    { type: NgZone },
    { type: IgxForOfScrollSyncService },
    { type: IgxForOfSyncService }
];
__decorate([
    Input(),
    __metadata("design:type", Object),
    __metadata("design:paramtypes", [Object])
], IgxGridForOfDirective.prototype, "igxGridForOf", null);
__decorate([
    Output(),
    __metadata("design:type", Object)
], IgxGridForOfDirective.prototype, "onDataChanging", void 0);
IgxGridForOfDirective = __decorate([
    Directive({
        selector: '[igxGridFor][igxGridForOf]'
    }),
    __metadata("design:paramtypes", [ViewContainerRef,
        TemplateRef,
        IterableDiffers,
        ComponentFactoryResolver,
        ChangeDetectorRef,
        NgZone,
        IgxForOfScrollSyncService,
        IgxForOfSyncService])
], IgxGridForOfDirective);
export { IgxGridForOfDirective };
/**
 * @hidden
 */
let IgxForOfModule = class IgxForOfModule {
};
IgxForOfModule = __decorate([
    NgModule({
        declarations: [IgxForOfDirective, IgxGridForOfDirective, DisplayContainerComponent, VirtualHelperComponent,
            HVirtualHelperComponent, VirtualHelperBaseDirective],
        entryComponents: [DisplayContainerComponent, VirtualHelperComponent, HVirtualHelperComponent],
        exports: [IgxForOfDirective, IgxGridForOfDirective],
        imports: [IgxScrollInertiaModule, CommonModule]
    })
], IgxForOfModule);
export { IgxForOfModule };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"for_of.directive.js","sourceRoot":"ng://igniteui-angular/","sources":["lib/directives/for-of/for_of.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule, NgForOfContext } from '@angular/common';\nimport {\n    ChangeDetectorRef,\n    ComponentFactory,\n    ComponentFactoryResolver,\n    ComponentRef,\n    Directive,\n    DoCheck,\n    EmbeddedViewRef,\n    EventEmitter,\n    Input,\n    IterableChanges,\n    IterableDiffer,\n    IterableDiffers,\n    NgModule,\n    NgZone,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    SimpleChanges,\n    TemplateRef,\n    TrackByFunction,\n    ViewContainerRef,\n    ViewRef,\n    AfterViewInit\n} from '@angular/core';\n\nimport { DisplayContainerComponent } from './display.container';\nimport { HVirtualHelperComponent } from './horizontal.virtual.helper.component';\nimport { VirtualHelperComponent } from './virtual.helper.component';\nimport { IgxScrollInertiaModule } from './../scroll-inertia/scroll_inertia.directive';\nimport { IgxForOfSyncService, IgxForOfScrollSyncService } from './for_of.sync.service';\nimport { Subject } from 'rxjs';\nimport { takeUntil, filter, throttleTime, first } from 'rxjs/operators';\nimport ResizeObserver from 'resize-observer-polyfill';\nimport { IBaseEventArgs } from '../../core/utils';\nimport { VirtualHelperBaseDirective } from './base.helper.component';\n\n/**\n *  @publicApi\n */\nexport class IgxForOfContext<T> {\n    constructor(\n       public $implicit: T,\n       public index: number,\n       public count: number\n    ) {}\n\n    /**\n     * A function that returns whether the element is the first or not\n     */\n    get first(): boolean { return this.index === 0; }\n\n    /**\n     * A function that returns whether the element is the last or not\n     */\n    get last(): boolean { return this.index === this.count - 1; }\n\n    /**\n     * A function that returns whether the element is even or not\n     */\n    get even(): boolean { return this.index % 2 === 0; }\n\n    /**\n     * A function that returns whether the element is odd or not\n     */\n    get odd(): boolean { return !this.even; }\n\n}\n\n@Directive({ selector: '[igxFor][igxForOf]' })\nexport class IgxForOfDirective<T> implements OnInit, OnChanges, DoCheck, OnDestroy, AfterViewInit {\n\n    /**\n     * An @Input property that sets the data to be rendered.\n     * ```html\n     * <ng-template igxFor let-item [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\"></ng-template>\n     * ```\n     */\n    @Input()\n    public igxForOf: any[];\n\n    /**\n     * An @Input property that sets the property name from which to read the size in the data object.\n     */\n    @Input()\n    public igxForSizePropName;\n\n    /**\n     * An @Input property that specifies the scroll orientation.\n     * Scroll orientation can be \"vertical\" or \"horizontal\".\n     * ```html\n     * <ng-template igxFor let-item [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\"></ng-template>\n     * ```\n     */\n    @Input()\n    public igxForScrollOrientation = 'vertical';\n\n    /**\n     * Optionally pass the parent `igxFor` instance to create a virtual template scrolling both horizontally and vertically.\n     * ```html\n     * <ng-template #scrollContainer igxFor let-rowData [igxForOf]=\"data\"\n     *       [igxForScrollOrientation]=\"'vertical'\"\n     *       [igxForContainerSize]=\"'500px'\"\n     *       [igxForItemSize]=\"'50px'\"\n     *       let-rowIndex=\"index\">\n     *       <div [style.display]=\"'flex'\" [style.height]=\"'50px'\">\n     *           <ng-template #childContainer igxFor let-item [igxForOf]=\"data\"\n     *               [igxForScrollOrientation]=\"'horizontal'\"\n     *               [igxForScrollContainer]=\"parentVirtDir\"\n     *               [igxForContainerSize]=\"'500px'\">\n     *                   <div [style.min-width]=\"'50px'\">{{rowIndex}} : {{item.text}}</div>\n     *           </ng-template>\n     *       </div>\n     * </ng-template>\n     * ```\n     */\n    @Input()\n    public igxForScrollContainer: any;\n\n    /**\n     * An @Input property that sets the px-affixed size of the container along the axis of scrolling.\n     * For \"horizontal\" orientation this value is the width of the container and for \"vertical\" is the height.\n     * ```html\n     * <ng-template igxFor let-item [igxForOf]=\"data\" [igxForContainerSize]=\"'500px'\"\n     *      [igxForScrollOrientation]=\"'horizontal'\">\n     * </ng-template>\n     * ```\n     */\n    @Input()\n    public igxForContainerSize: any;\n\n    /**\n     * An @Input property that sets the px-affixed size of the item along the axis of scrolling.\n     * For \"horizontal\" orientation this value is the width of the column and for \"vertical\" is the height or the row.\n     * ```html\n     * <ng-template igxFor let-item [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\" [igxForItemSize]=\"'50px'\"></ng-template>\n     * ```\n     */\n    @Input()\n    public igxForItemSize: any;\n\n    /**\n     * @hidden\n     */\n    public dc: ComponentRef<DisplayContainerComponent>;\n\n    /**\n     * The current state of the directive. It contains `startIndex` and `chunkSize`.\n     * state.startIndex - The index of the item at which the current visible chunk begins.\n     * state.chunkSize - The number of items the current visible chunk holds.\n     * These options can be used when implementing remote virtualization as they provide the necessary state information.\n     * ```typescript\n     * const gridState = this.parentVirtDir.state;\n     * ```\n     */\n    public state: IForOfState = {\n        startIndex: 0,\n        chunkSize: 0\n    };\n    /**\n     * The total count of the virtual data items, when using remote service.\n     * ```typescript\n     * this.parentVirtDir.totalItemCount = data.Count;\n     * ```\n     */\n    public totalItemCount: number = null;\n\n    /**\n     * An event that is emitted after a new chunk has been loaded.\n     * ```html\n     * <ng-template igxFor [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\" (onChunkLoad)=\"chunkLoad($event)\"></ng-template>\n     * ```\n     * ```typescript\n     * chunkLoad(e){\n     * alert(\"chunk loaded!\");\n     * }\n     * ```\n     */\n    @Output()\n    public onChunkLoad = new EventEmitter<IForOfState>();\n\n    /**\n     * @hidden @internal\n     * An event that is emitted when scrollbar visibility has changed.\n     */\n    @Output()\n    public onScrollbarVisibilityChanged = new EventEmitter<any>();\n\n    /**\n     * An event that is emitted after the rendered content size of the igxForOf has been changed.\n    */\n    @Output()\n    public onContentSizeChange = new EventEmitter<any>();\n\n    /**\n     * An event that is emitted after data has been changed.\n     * ```html\n     * <ng-template igxFor [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\" (onDataChanged)=\"dataChanged($event)\"></ng-template>\n     * ```\n     * ```typescript\n     * dataChanged(e){\n     * alert(\"data changed!\");\n     * }\n     * ```\n     */\n    @Output()\n    public onDataChanged = new EventEmitter<any>();\n\n    @Output()\n    public onBeforeViewDestroyed = new EventEmitter<EmbeddedViewRef<any>>();\n\n    /**\n     * An event that is emitted on chunk loading to emit the current state information - startIndex, endIndex, totalCount.\n     * Can be used for implementing remote load on demand for the igxFor data.\n     * ```html\n     * <ng-template igxFor [igxForOf]=\"data\" [igxForScrollOrientation]=\"'horizontal'\" (onChunkPreload)=\"chunkPreload($event)\"></ng-template>\n     * ```\n     * ```typescript\n     * chunkPreload(e){\n     * alert(\"chunk is loading!\");\n     * }\n     * ```\n     */\n    @Output()\n    public onChunkPreload = new EventEmitter<IForOfState>();\n    protected func;\n    protected _sizesCache: number[] = [];\n    protected scrollComponent: VirtualHelperBaseDirective;\n    protected _differ: IterableDiffer<T> | null = null;\n    protected _trackByFn: TrackByFunction<T>;\n    protected heightCache = [];\n    private _adjustToIndex;\n    private MAX_PERF_SCROLL_DIFF = 4;\n\n\n    public get displayContainer(): HTMLElement | undefined {\n        return this.dc.instance._viewContainer.element.nativeElement;\n    }\n\n    public get virtualHelper() {\n        return this.scrollComponent.nativeElement;\n    }\n\n    protected get sizesCache(): number[] {\n        return this._sizesCache;\n    }\n    protected set sizesCache(value: number[]) {\n        this._sizesCache = value;\n    }\n\n    private get _isScrolledToBottom() {\n        if (!this.getScroll()) {\n            return true;\n        }\n        const scrollHeight = this.getScroll().scrollHeight;\n        // Use === and not >= because `scrollTop + container size` can't be bigger than `scrollHeight`, unless something isn't updated.\n        // Also use Math.round because Chrome has some inconsistencies and `scrollTop + container` can be float when zooming the page.\n        return Math.round(this.getScroll().scrollTop + this.igxForContainerSize) === scrollHeight;\n    }\n\n    private get _isAtBottomIndex() {\n        return this.igxForOf && this.state.startIndex + this.state.chunkSize > this.igxForOf.length;\n    }\n\n    // Start properties related to virtual height handling due to browser limitation\n    /** Maximum height for an element of the browser. */\n    private _maxHeight;\n\n    /** Height that is being virtualized. */\n    protected _virtHeight = 0;\n\n    /**\n     * Ratio for height that's being virtualizaed and the one visible\n     * If _virtHeightRatio = 1, the visible height and the virtualized are the same, also _maxHeight > _virtHeight.\n     */\n    private _virtHeightRatio = 1;\n\n    /** Internal track for scroll top that is being virtualized */\n    protected _virtScrollTop = 0;\n\n    /** If the next onScroll event is triggered due to internal setting of scrollTop */\n    protected _bScrollInternal = false;\n    // End properties related to virtual height handling\n\n    protected _embeddedViews: Array<EmbeddedViewRef<any>> = [];\n\n    protected contentResizeNotify = new Subject();\n    protected contentObserver: ResizeObserver;\n\n    /**\n     * @hidden\n     */\n    protected destroy$ = new Subject<any>();\n\n    constructor(\n        private _viewContainer: ViewContainerRef,\n        protected _template: TemplateRef<NgForOfContext<T>>,\n        protected _differs: IterableDiffers,\n        private resolver: ComponentFactoryResolver,\n        public cdr: ChangeDetectorRef,\n        protected _zone: NgZone,\n        protected syncScrollService: IgxForOfScrollSyncService) { }\n\n    /**\n     * @hidden\n     */\n    protected get isRemote(): boolean {\n        return this.totalItemCount !== null;\n    }\n\n    /**\n     *\n     * Gets/Sets the scroll position.\n     * ```typescript\n     * const position = directive.scrollPosition;\n     * directive.scrollPosition = value;\n     * ```\n     */\n    public get scrollPosition(): number {\n        return this.scrollComponent.scrollAmount;\n    }\n    public set scrollPosition(val: number) {\n        if (val === this.scrollComponent.scrollAmount) {\n            return;\n        }\n        if (this.igxForScrollOrientation === 'horizontal' && this.scrollComponent) {\n            this.scrollComponent.nativeElement.scrollLeft = val;\n        } else if (this.scrollComponent) {\n            this.scrollComponent.nativeElement.scrollTop = val;\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    protected removeScrollEventListeners() {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this._zone.runOutsideAngular(() =>\n                this.scrollComponent.nativeElement.removeEventListener('scroll', this.func)\n            );\n        } else {\n            this._zone.runOutsideAngular(() =>\n                this.scrollComponent.nativeElement.removeEventListener('scroll', this.verticalScrollHandler)\n            );\n        }\n    }\n\n    public verticalScrollHandler(event) {\n        this.onScroll(event);\n    }\n\n    public isScrollable() {\n        return this.scrollComponent.size > parseInt(this.igxForContainerSize, 10);\n    }\n\n    /**\n     * @hidden\n     */\n    public ngOnInit(): void {\n        let totalSize = 0;\n        const vc = this.igxForScrollContainer ? this.igxForScrollContainer._viewContainer : this._viewContainer;\n        this.igxForSizePropName = this.igxForSizePropName || 'width';\n\n        const dcFactory: ComponentFactory<DisplayContainerComponent> = this.resolver.resolveComponentFactory(DisplayContainerComponent);\n        this.dc = this._viewContainer.createComponent(dcFactory, 0);\n        this.dc.instance.scrollDirection = this.igxForScrollOrientation;\n        if (typeof MSGesture === 'function') {\n            // On Edge and IE when scrolling on touch the page scroll instead of the grid.\n            this.dc.instance._viewContainer.element.nativeElement.style.touchAction = 'none';\n        }\n        if (this.igxForOf && this.igxForOf.length) {\n            totalSize = this.initSizesCache(this.igxForOf);\n            this.scrollComponent = this.syncScrollService.getScrollMaster(this.igxForScrollOrientation);\n            this.state.chunkSize = this._calculateChunkSize();\n            this.dc.instance.notVirtual = !(this.igxForContainerSize && this.state.chunkSize < this.igxForOf.length);\n            if (this.scrollComponent) {\n                this.state.startIndex = Math.min(this.getIndexAt(this.scrollPosition, this.sizesCache, 0),\n                    this.igxForOf.length - this.state.chunkSize);\n            }\n            for (let i = this.state.startIndex; i < this.state.startIndex + this.state.chunkSize &&\n                    this.igxForOf[i] !== undefined; i++) {\n                const input = this.igxForOf[i];\n                const embeddedView = this.dc.instance._vcr.createEmbeddedView(\n                    this._template,\n                    new IgxForOfContext<T>(input, this.getContextIndex(input), this.igxForOf.length)\n                );\n                this._embeddedViews.push(embeddedView);\n            }\n        }\n\n        if (this.igxForScrollOrientation === 'vertical') {\n            this.dc.instance._viewContainer.element.nativeElement.style.top = '0px';\n            const factory: ComponentFactory<VirtualHelperComponent> = this.resolver.resolveComponentFactory(VirtualHelperComponent);\n            this.scrollComponent = vc.createComponent(factory).instance;\n            this._maxHeight = this._calcMaxBrowserHeight();\n            this.scrollComponent.size = this.igxForOf ? this._calcHeight() : 0;\n            this.syncScrollService.setScrollMaster(this.igxForScrollOrientation, this.scrollComponent);\n            this._zone.runOutsideAngular(() => {\n                this.verticalScrollHandler = this.verticalScrollHandler.bind(this);\n                this.scrollComponent.nativeElement.addEventListener('scroll', this.verticalScrollHandler);\n                this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;\n            });\n            const destructor = takeUntil<any>(this.destroy$);\n            this.contentResizeNotify.pipe(destructor,\n            filter(() => this.igxForContainerSize && this.igxForOf && this.igxForOf.length > 0), throttleTime(40))\n            .subscribe(() => {\n                this._zone.runTask(() => {\n                    this.updateSizes();\n                });\n            });\n        }\n\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.func = (evt) => { this.onHScroll(evt); };\n            this.scrollComponent = this.syncScrollService.getScrollMaster(this.igxForScrollOrientation);\n            if (!this.scrollComponent) {\n                const hvFactory: ComponentFactory<HVirtualHelperComponent> =\n                    this.resolver.resolveComponentFactory(HVirtualHelperComponent);\n                this.scrollComponent = vc.createComponent(hvFactory).instance;\n                this.scrollComponent.size = totalSize;\n                this.syncScrollService.setScrollMaster(this.igxForScrollOrientation, this.scrollComponent);\n                this._zone.runOutsideAngular(() => {\n                    this.scrollComponent.nativeElement.addEventListener('scroll', this.func);\n                    this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;\n                });\n            } else {\n                this._zone.runOutsideAngular(() => {\n                    this.scrollComponent.nativeElement.addEventListener('scroll', this.func);\n                    this.dc.instance.scrollContainer = this.scrollComponent.nativeElement;\n                });\n            }\n            this._updateHScrollOffset();\n        }\n    }\n\n    ngAfterViewInit(): void {\n        if (this.igxForScrollOrientation === 'vertical') {\n            this._zone.runOutsideAngular(() => {\n                this.contentObserver = new ResizeObserver(() => this.contentResizeNotify.next());\n                this.contentObserver.observe(this.dc.instance._viewContainer.element.nativeElement);\n            });\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    public ngOnDestroy() {\n        this.removeScrollEventListeners();\n        this.destroy$.next(true);\n        this.destroy$.complete();\n        if (this.contentObserver) {\n            this.contentObserver.disconnect();\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    public ngOnChanges(changes: SimpleChanges): void {\n        const forOf = 'igxForOf';\n        if (forOf in changes) {\n            const value = changes[forOf].currentValue;\n            if (!this._differ && value) {\n                try {\n                    this._differ = this._differs.find(value).create(this.igxForTrackBy);\n                } catch (e) {\n                    throw new Error(\n                        `Cannot find a differ supporting object \"${value}\" of type \"${getTypeNameForDebugging(value)}\".\n                     NgFor only supports binding to Iterables such as Arrays.`);\n                }\n            }\n        }\n        const defaultItemSize = 'igxForItemSize';\n        if (defaultItemSize in changes && !changes[defaultItemSize].firstChange &&\n            this.igxForScrollOrientation === 'vertical' && this.igxForOf) {\n            // handle default item size changed.\n            this.initSizesCache(this.igxForOf);\n            this._applyChanges();\n        }\n        const containerSize = 'igxForContainerSize';\n        if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {\n            this._recalcOnContainerChange(changes);\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    public ngDoCheck(): void {\n        if (this._differ) {\n            const changes = this._differ.diff(this.igxForOf);\n            if (changes) {\n                //  re-init cache.\n                if (!this.igxForOf) {\n                    this.igxForOf = [];\n                }\n                this._updateSizeCache();\n                this._zone.run(() => {\n                    this._applyChanges();\n                    this.cdr.markForCheck();\n                    this._updateScrollOffset();\n                    this.onDataChanged.emit();\n                });\n            }\n        }\n    }\n\n    /**\n     * Shifts the scroll thumb position.\n     * ```typescript\n     * this.parentVirtDir.addScrollTop(5);\n     * ```\n     * @param addTop negative value to scroll up and positive to scroll down;\n     */\n    public addScrollTop(addTop: number): boolean {\n        if (addTop === 0 && this.igxForScrollOrientation === 'horizontal') {\n            return false;\n        }\n        const originalVirtScrollTop = this._virtScrollTop;\n        const containerSize = parseInt(this.igxForContainerSize, 10);\n        const maxVirtScrollTop = this._virtHeight - containerSize;\n\n        this._bScrollInternal = true;\n        this._virtScrollTop += addTop;\n        this._virtScrollTop = this._virtScrollTop > 0 ?\n            (this._virtScrollTop < maxVirtScrollTop ? this._virtScrollTop : maxVirtScrollTop) :\n            0;\n\n        this.scrollPosition += addTop / this._virtHeightRatio;\n        if (Math.abs(addTop / this._virtHeightRatio) < 1) {\n            // Actual scroll delta that was added is smaller than 1 and onScroll handler doesn't trigger when scrolling < 1px\n            const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);\n            // scrollOffset = scrollOffset !== parseInt(this.igxForItemSize, 10) ? scrollOffset : 0;\n            this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';\n        }\n\n        const maxRealScrollTop = this.scrollComponent.nativeElement.scrollHeight - containerSize;\n        if ((this._virtScrollTop > 0 && this.scrollPosition === 0) ||\n            (this._virtScrollTop < maxVirtScrollTop && this.scrollPosition === maxRealScrollTop)) {\n            // Actual scroll position is at the top or bottom, but virtual one is not at the top or bottom (there's more to scroll)\n            // Recalculate actual scroll position based on the virtual scroll.\n            this.scrollPosition = this._virtScrollTop / this._virtHeightRatio;\n        } else if (this._virtScrollTop === 0 && this.scrollPosition > 0) {\n            // Actual scroll position is not at the top, but virtual scroll is. Just update the actual scroll\n            this.scrollPosition = 0;\n        } else if (this._virtScrollTop === maxVirtScrollTop && this.scrollPosition < maxRealScrollTop) {\n            // Actual scroll position is not at the bottom, but virtual scroll is. Just update the acual scroll\n            this.scrollPosition = maxRealScrollTop;\n        }\n        return this._virtScrollTop !== originalVirtScrollTop;\n    }\n\n    /**\n     * Scrolls to the specified index.\n     * ```typescript\n     * this.parentVirtDir.scrollTo(5);\n     * ```\n     * @param index\n     */\n    public scrollTo(index) {\n        if (index < 0 || index > (this.isRemote ? this.totalItemCount : this.igxForOf.length) - 1) {\n            return;\n        }\n        const containerSize = parseInt(this.igxForContainerSize, 10);\n        const isPrevItem = index < this.state.startIndex || this.scrollPosition > this.sizesCache[index];\n        let nextScroll = isPrevItem ? this.sizesCache[index] : this.sizesCache[index + 1] - containerSize;\n        if (nextScroll < 0) {\n            return;\n        }\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.scrollPosition = nextScroll;\n        } else {\n            const maxVirtScrollTop = this._virtHeight - containerSize;\n            if (nextScroll > maxVirtScrollTop) {\n                nextScroll = maxVirtScrollTop;\n            }\n            this._bScrollInternal = true;\n            this._virtScrollTop = nextScroll;\n            this.scrollPosition = this._virtScrollTop / this._virtHeightRatio;\n            this._adjustToIndex = !isPrevItem ? index : null;\n        }\n    }\n\n    /**\n     * Scrolls by one item into the appropriate next direction.\n     * For \"horizontal\" orientation that will be the right column and for \"vertical\" that is the lower row.\n     * ```typescript\n     * this.parentVirtDir.scrollNext();\n     * ```\n     */\n    public scrollNext() {\n        const scr = Math.ceil(this.scrollPosition);\n        const endIndex = this.getIndexAt(\n            scr + parseInt(this.igxForContainerSize, 10),\n            this.sizesCache,\n            0\n        );\n        this.scrollTo(endIndex);\n    }\n\n    /**\n     * Scrolls by one item into the appropriate previous direction.\n     * For \"horizontal\" orientation that will be the left column and for \"vertical\" that is the upper row.\n     * ```typescript\n     * this.parentVirtDir.scrollPrev();\n     * ```\n     */\n    public scrollPrev() {\n        this.scrollTo(this.state.startIndex - 1);\n    }\n\n    /**\n     * Scrolls by one page into the appropriate next direction.\n     * For \"horizontal\" orientation that will be one view to the right and for \"vertical\" that is one view to the bottom.\n     * ```typescript\n     * this.parentVirtDir.scrollNextPage();\n     * ```\n     */\n    public scrollNextPage() {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.scrollPosition += parseInt(this.igxForContainerSize, 10);\n        } else {\n            this.addScrollTop(parseInt(this.igxForContainerSize, 10));\n        }\n    }\n\n    /**\n     * Scrolls by one page into the appropriate previous direction.\n     * For \"horizontal\" orientation that will be one view to the left and for \"vertical\" that is one view to the top.\n     * ```typescript\n     * this.parentVirtDir.scrollPrevPage();\n     * ```\n     */\n    public scrollPrevPage() {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.scrollPosition -= parseInt(this.igxForContainerSize, 10);\n        } else {\n            const containerSize = (parseInt(this.igxForContainerSize, 10));\n            this.addScrollTop(-containerSize);\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    public getColumnScrollLeft(colIndex) {\n        return this.sizesCache[colIndex];\n    }\n\n    /**\n     * Returns the total number of items that are fully visible.\n     * ```typescript\n     * this.parentVirtDir.getItemCountInView();\n     * ```\n     */\n    public getItemCountInView() {\n        let startIndex = this.getIndexAt(\n            this.scrollPosition,\n            this.sizesCache,\n            0\n        );\n        if (this.scrollPosition - this.sizesCache[startIndex] > 0) {\n            // fisrt item is not fully in view\n            startIndex++;\n        }\n        const endIndex = this.getIndexAt(\n            this.scrollPosition + parseInt(this.igxForContainerSize, 10),\n            this.sizesCache,\n            0\n        );\n        return endIndex - startIndex;\n    }\n\n    /**\n     * Returns a reference to the scrollbar DOM element.\n     * This is either a vertical or horizontal scrollbar depending on the specified igxForScrollOrientation.\n     * ```typescript\n     * dir.getScroll();\n     * ```\n     */\n    public getScroll() {\n        return this.scrollComponent.nativeElement;\n    }\n    /**\n     * Returns the size of the element at the specified index.\n     * ```typescript\n     * this.parentVirtDir.getSizeAt(1);\n     * ```\n     */\n    public getSizeAt(index: number) {\n        return this.sizesCache[index + 1] - this.sizesCache[index];\n    }\n\n    /**\n     * Returns the scroll offset of the element at the specified index.\n     * ```typescript\n     * this.parentVirtDir.getScrollForIndex(1);\n     * ```\n     */\n    public getScrollForIndex(index: number, bottom?: boolean) {\n        const containerSize = parseInt(this.igxForContainerSize, 10);\n        const scroll = bottom ? Math.max(0, this.sizesCache[index + 1] - containerSize) : this.sizesCache[index];\n        return scroll;\n    }\n\n    /**\n     * @hidden\n     * Function that is called when scrolling vertically\n     */\n    protected onScroll(event) {\n        /* in certain situations this may be called when no scrollbar is visible */\n        if (!parseInt(this.scrollComponent.nativeElement.style.height, 10)) {\n            return;\n        }\n\n        const containerSize = parseInt(this.igxForContainerSize, 10);\n        const maxRealScrollTop = event.target.children[0].scrollHeight - containerSize;\n        const realPercentScrolled = maxRealScrollTop !== 0 ?  event.target.scrollTop / maxRealScrollTop : 0;\n        if (!this._bScrollInternal) {\n            const maxVirtScrollTop = this._virtHeight - containerSize;\n            this._virtScrollTop = realPercentScrolled * maxVirtScrollTop;\n        } else {\n            this._bScrollInternal = false;\n        }\n        const prevStartIndex = this.state.startIndex;\n        const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);\n\n        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';\n\n        this.dc.changeDetectorRef.detectChanges();\n        if (prevStartIndex !== this.state.startIndex) {\n            this.onChunkLoad.emit(this.state);\n        }\n    }\n\n    protected updateSizes() {\n        this.recalcUpdateSizes();\n        this._applyChanges();\n        this._updateScrollOffset();\n        this.onContentSizeChange.emit();\n    }\n\n    /**\n     * @hidden\n     * Function that recaculates and updates cache sizes.\n     */\n    public recalcUpdateSizes() {\n        const dimension = this.igxForScrollOrientation === 'horizontal' ?\n            this.igxForSizePropName : 'height';\n        const diffs = [];\n        let totalDiff = 0;\n        const l = this._embeddedViews.length;\n        const rNodes = this._embeddedViews.map(view =>\n            view.rootNodes.find(node => node.nodeType === Node.ELEMENT_NODE) || view.rootNodes[0].nextElementSibling);\n        for (let i = 0; i < l; i++) {\n            const rNode = rNodes[i];\n            if (rNode) {\n                const h = rNode.offsetHeight || parseInt(this.igxForItemSize, 10);\n                const index = this.state.startIndex + i;\n                if (!this.isRemote && !this.igxForOf[index]) {\n                    continue;\n                }\n                const oldVal = dimension === 'height' ? this.heightCache[index] : this.igxForOf[index][dimension];\n                const newVal = dimension === 'height' ? h : rNode.clientWidth;\n                if (dimension === 'height') {\n                    this.heightCache[index] = newVal;\n                } else {\n                    this.igxForOf[index][dimension] = newVal;\n                }\n                const currDiff = newVal - oldVal;\n                diffs.push(currDiff);\n                totalDiff += currDiff;\n                this.sizesCache[index + 1] += totalDiff;\n            }\n        }\n        // update cache\n        if (Math.abs(totalDiff) > 0) {\n            for (let j = this.state.startIndex + this.state.chunkSize + 1; j < this.sizesCache.length; j++) {\n                this.sizesCache[j] += totalDiff;\n            }\n\n            // update scrBar heights/widths\n            if (this.igxForScrollOrientation === 'horizontal') {\n                const totalWidth = parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10) + totalDiff;\n                this.scrollComponent.nativeElement.children[0].style.width = totalWidth + 'px';\n            }\n            const reducer = (acc, val) => acc + val;\n            if (this.igxForScrollOrientation === 'vertical') {\n                const scrToBottom = this._isScrolledToBottom && !this.dc.instance.notVirtual;\n                const hSum = this.heightCache.reduce(reducer);\n                if (hSum > this._maxHeight) {\n                    this._virtHeightRatio = hSum / this._maxHeight;\n                }\n                this.scrollComponent.size = Math.min(this.scrollComponent.size + totalDiff, this._maxHeight);\n                this._virtHeight = hSum;\n                if (!this.scrollComponent.destroyed) {\n                    this.scrollComponent.cdr.detectChanges();\n                }\n                if (scrToBottom && !this._isAtBottomIndex) {\n                    const containerSize = parseInt(this.igxForContainerSize, 10);\n                    const maxVirtScrollTop = this._virtHeight - containerSize;\n                    this._bScrollInternal = true;\n                    this._virtScrollTop = maxVirtScrollTop;\n                    this.scrollPosition = maxVirtScrollTop;\n                    return;\n                }\n                if (this._adjustToIndex) {\n                    // in case scrolled to specific index where after scroll heights are changed\n                    // need to adjust the offsets so that item is last in view.\n                    const updatesToIndex = this._adjustToIndex - this.state.startIndex + 1;\n                    const sumDiffs = diffs.slice(0, updatesToIndex).reduce(reducer);\n                    const currOffset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);\n                    this.dc.instance._viewContainer.element.nativeElement.style.top = (currOffset - sumDiffs) + 'px';\n                    this._adjustToIndex = null;\n                }\n            }\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    protected fixedUpdateAllElements(inScrollTop: number): number {\n        const count = this.isRemote ? this.totalItemCount : this.igxForOf.length;\n        let newStart = this.getIndexAt(\n            inScrollTop,\n            this.sizesCache,\n            0\n        );\n        if (newStart + this.state.chunkSize > count) {\n            newStart = count - this.state.chunkSize;\n        }\n        const prevStart = this.state.startIndex;\n        const diff = newStart - this.state.startIndex;\n        this.state.startIndex = newStart;\n        if (diff) {\n            this.onChunkPreload.emit(this.state);\n            if (!this.isRemote) {\n                /*recalculate and apply page size.*/\n                if (diff > 0 && diff <= this.MAX_PERF_SCROLL_DIFF) {\n                    this.moveApplyScrollNext(prevStart);\n                } else if (diff < 0 && Math.abs(diff) <= this.MAX_PERF_SCROLL_DIFF) {\n                    this.moveApplyScrollPrev(prevStart);\n                } else {\n                    this.fixedApplyScroll();\n                }\n            }\n        }\n        return inScrollTop - this.sizesCache[this.state.startIndex];\n    }\n\n    /**\n     * @hidden\n     * The function applies an optimized state change for scrolling down/right employing context change with view rearrangement\n     */\n    protected moveApplyScrollNext(prevIndex: number): void {\n        const start = prevIndex + this.state.chunkSize;\n        for (let i = start; i < start + this.state.startIndex - prevIndex && this.igxForOf[i] !== undefined; i++) {\n            const input = this.igxForOf[i];\n            const embView = this._embeddedViews.shift();\n            const cntx = embView.context;\n            cntx.$implicit = input;\n            cntx.index = this.getContextIndex(input);\n            cntx.count = this.igxForOf.length;\n            const view: ViewRef = this.dc.instance._vcr.detach(0);\n            this.dc.instance._vcr.insert(view);\n            this._embeddedViews.push(embView);\n        }\n    }\n\n    /**\n     * @hidden\n     * The function applies an optimized state change for scrolling up/left employing context change with view rearrangement\n     */\n    protected moveApplyScrollPrev(prevIndex: number): void {\n        for (let i = prevIndex - 1; i >= this.state.startIndex && this.igxForOf[i] !== undefined; i--) {\n            const input = this.igxForOf[i];\n            const embView = this._embeddedViews.pop();\n            const cntx = embView.context;\n            cntx.$implicit = input;\n            cntx.index = this.getContextIndex(input);\n            const view: ViewRef = this.dc.instance._vcr.detach(this.dc.instance._vcr.length - 1);\n            this.dc.instance._vcr.insert(view, 0);\n            this._embeddedViews.unshift(embView);\n        }\n    }\n\n    /**\n     * @hidden\n    */\n    protected getContextIndex(input) {\n        return this.isRemote ? this.state.startIndex + this.igxForOf.indexOf(input) : this.igxForOf.indexOf(input);\n    }\n\n    /**\n     * @hidden\n     * The function applies an optimized state change through context change for each view\n     */\n    protected fixedApplyScroll(): void {\n        let j = 0;\n        const endIndex = this.state.startIndex + this.state.chunkSize;\n        for (let i = this.state.startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {\n            const input = this.igxForOf[i];\n            const embView = this._embeddedViews[j++];\n            const cntx = (embView as EmbeddedViewRef<any>).context;\n            cntx.$implicit = input;\n            cntx.index = this.getContextIndex(input);\n            cntx.count = this.igxForOf.length;\n        }\n    }\n\n    /**\n     * @hidden\n     * Function that is called when scrolling horizontally\n     */\n    protected onHScroll(event) {\n        /* in certain situations this may be called when no scrollbar is visible */\n        if (!parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10)) {\n            return;\n        }\n        const prevStartIndex = this.state.startIndex;\n        // Updating horizontal chunks\n        const scrollOffset = this.fixedUpdateAllElements(event.target.scrollLeft);\n        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';\n\n        this.dc.changeDetectorRef.detectChanges();\n        if (prevStartIndex !== this.state.startIndex) {\n            this.onChunkLoad.emit(this.state);\n        }\n    }\n\n    /**\n     * Gets the function used to track changes in the items collection.\n     * By default the object references are compared. However this can be optimized if you have unique identifier\n     * value that can be used for the comparison instead of the object ref or if you have some other property values\n     * in the item object that should be tracked for changes.\n     * This option is similar to ngForTrackBy.\n     * ```typescript\n     * const trackFunc = this.parentVirtDir.igxForTrackBy;\n     * ```\n     */\n    @Input()\n    get igxForTrackBy(): TrackByFunction<T> { return this._trackByFn; }\n\n    /**\n     * Sets the function used to track changes in the items collection.\n     * This function can be set in scenarios where you want to optimize or\n     * customize the tracking of changes for the items in the collection.\n     * The igxForTrackBy function takes the index and the current item as arguments and needs to return the unique identifier for this item.\n     * ```typescript\n     * this.parentVirtDir.igxForTrackBy = (index, item) => {\n     *      return item.id + item.width;\n     * };\n     * ```\n     */\n    set igxForTrackBy(fn: TrackByFunction<T>) { this._trackByFn = fn; }\n\n    /**\n     * @hidden\n     */\n    protected _applyChanges() {\n        const prevChunkSize = this.state.chunkSize;\n        this.applyChunkSizeChange();\n        this._recalcScrollBarSize();\n        if (this.igxForOf && this.igxForOf.length && this.dc) {\n            const embeddedViewCopy = Object.assign([], this._embeddedViews);\n            let startIndex = this.state.startIndex;\n            let endIndex = this.state.chunkSize + this.state.startIndex;\n            if (this.isRemote) {\n                startIndex = 0;\n                endIndex = this.igxForOf.length;\n            }\n            for (let i = startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {\n                const input = this.igxForOf[i];\n                const embView = embeddedViewCopy.shift();\n                const cntx = (embView as EmbeddedViewRef<any>).context;\n                cntx.$implicit = input;\n                cntx.index = this.getContextIndex(input);\n                cntx.count = this.igxForOf.length;\n            }\n            if (prevChunkSize !== this.state.chunkSize) {\n                this.onChunkLoad.emit(this.state);\n            }\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    protected _calcMaxBrowserHeight(): number {\n        const div = document.createElement('div');\n        const style = div.style;\n        style.position = 'absolute';\n        style.top = '9999999999999999px';\n        document.body.appendChild(div);\n        const size = Math.abs(div.getBoundingClientRect()['top']);\n        document.body.removeChild(div);\n        return size;\n    }\n\n    /**\n     * @hidden\n     * Recalculates the chunkSize based on current startIndex and returns the new size.\n     * This should be called after this.state.startIndex is updated, not before.\n     */\n    protected _calculateChunkSize(): number {\n        let chunkSize = 0;\n        if (this.igxForContainerSize !== null && this.igxForContainerSize !== undefined) {\n            if (!this.sizesCache) {\n                this.initSizesCache(this.igxForOf);\n            }\n            chunkSize = this._calcMaxChunkSize();\n            if (this.igxForOf && chunkSize > this.igxForOf.length) {\n                chunkSize = this.igxForOf.length;\n            }\n        } else {\n            if (this.igxForOf) {\n                chunkSize = this.igxForOf.length;\n            }\n        }\n        return chunkSize;\n    }\n\n    /**\n     * @hidden\n     */\n    protected getElement(viewref, nodeName) {\n        const elem = viewref.element.nativeElement.parentNode.getElementsByTagName(nodeName);\n        return elem.length > 0 ? elem[0] : null;\n    }\n\n    /**\n     * @hidden\n     */\n    protected initSizesCache(items: any[]): number {\n        let totalSize = 0;\n        let size = 0;\n        const dimension = this.igxForScrollOrientation === 'horizontal' ?\n            this.igxForSizePropName : 'height';\n        let i = 0;\n        this.sizesCache = [];\n        this.heightCache = [];\n        this.sizesCache.push(0);\n        const count = this.isRemote ? this.totalItemCount : items.length;\n        for (i; i < count; i++) {\n            if (dimension === 'height') {\n                // cols[i][dimension] = parseInt(this.igxForItemSize, 10) || 0;\n                size = parseInt(this.igxForItemSize, 10) || 0;\n                this.heightCache.push(size);\n            } else {\n                size = this._getItemSize(items[i], dimension);\n            }\n            totalSize += size;\n            this.sizesCache.push(totalSize);\n        }\n        return totalSize;\n    }\n\n    protected _updateSizeCache() {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.initSizesCache(this.igxForOf);\n            return;\n        }\n        const oldHeight = this.heightCache.length > 0 ? this.heightCache.reduce((acc, val) => acc + val) : 0;\n        const newHeight = this.initSizesCache(this.igxForOf);\n\n        const diff = oldHeight - newHeight;\n\n        // if data has been changed while container is scrolled\n        // should update scroll top/left according to change so that same startIndex is in view\n        if (Math.abs(diff) > 0 && this.scrollPosition > 0) {\n            this.recalcUpdateSizes();\n            const offset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);\n            this.scrollPosition = this.sizesCache[this.state.startIndex] - offset;\n        }\n    }\n\n    /**\n     * @hidden\n     */\n    protected _calcMaxChunkSize(): number {\n        let i = 0;\n        let length = 0;\n        let maxLength = 0;\n        const arr = [];\n        let sum = 0;\n        const availableSize = parseInt(this.igxForContainerSize, 10);\n        if (!availableSize) {\n            return 0;\n        }\n        const dimension = this.igxForScrollOrientation === 'horizontal' ?\n            this.igxForSizePropName : 'height';\n        const reducer = (accumulator, currentItem) => accumulator + this._getItemSize(currentItem, dimension);\n        for (i; i < this.igxForOf.length; i++) {\n            let item = this.igxForOf[i];\n            if (dimension === 'height') {\n                item = { value: this.igxForOf[i], height: this.heightCache[i] };\n            }\n            const size = dimension === 'height' ?\n                this.heightCache[i] :\n                this._getItemSize(item, dimension);\n            sum = arr.reduce(reducer, size);\n            if (sum < availableSize) {\n                arr.push(item);\n                length = arr.length;\n                if (i === this.igxForOf.length - 1) {\n                    // reached end without exceeding\n                    // include prev items until size is filled or first item is reached.\n                    let curItem = dimension === 'height' ? arr[0].value : arr[0];\n                    let prevIndex = this.igxForOf.indexOf(curItem) - 1;\n                    while (prevIndex >= 0 && sum <= availableSize) {\n                        curItem = dimension === 'height' ? arr[0].value : arr[0];\n                        prevIndex = this.igxForOf.indexOf(curItem) - 1;\n                        const prevItem = this.igxForOf[prevIndex];\n                        const prevSize = dimension === 'height' ?\n                            this.heightCache[prevIndex] :\n                            parseInt(prevItem[dimension], 10);\n                        sum = arr.reduce(reducer, prevSize);\n                        arr.unshift(prevItem);\n                        length = arr.length;\n                    }\n                }\n            } else {\n                arr.push(item);\n                length = arr.length + 1;\n                arr.shift();\n            }\n            if (length > maxLength) {\n                maxLength = length;\n            }\n        }\n        return maxLength;\n    }\n\n    /**\n     * @hidden\n     */\n    protected getIndexAt(left, set, index) {\n        let start = 0;\n        let end = set.length - 1;\n        if (left === 0) {\n            return 0;\n        }\n        while (start <= end) {\n            const midIdx = Math.floor((start + end) / 2);\n            const midLeft = set[midIdx];\n            const cmp = left - midLeft;\n            if (cmp > 0) {\n                start = midIdx + 1;\n            } else if (cmp < 0) {\n                end = midIdx - 1;\n            } else {\n                return midIdx;\n            }\n        }\n        return end;\n    }\n\n    protected _recalcScrollBarSize() {\n        const count = this.isRemote ? this.totalItemCount : (this.igxForOf ? this.igxForOf.length : 0);\n        this.dc.instance.notVirtual = !(this.igxForContainerSize && this.dc && this.state.chunkSize < count);\n        const scrollable = this.isScrollable();\n        if (this.igxForScrollOrientation === 'horizontal') {\n            const totalWidth = this.igxForContainerSize ? this.initSizesCache(this.igxForOf) : 0;\n            this.scrollComponent.nativeElement.style.width = this.igxForContainerSize + 'px';\n            this.scrollComponent.size = totalWidth;\n            if (totalWidth <= parseInt(this.igxForContainerSize, 10)) {\n                this.scrollPosition = 0;\n            }\n        }\n        if (this.igxForScrollOrientation === 'vertical') {\n            this.scrollComponent.nativeElement.style.height = parseInt(this.igxForContainerSize, 10) + 'px';\n            this.scrollComponent.size = this._calcHeight();\n            if ( this.scrollComponent.size <= parseInt(this.igxForContainerSize, 10)) {\n                this.scrollPosition = 0;\n            }\n        }\n        if (scrollable !== this.isScrollable()) {\n            // scrollbar visibility has changed\n            this.onScrollbarVisibilityChanged.emit();\n        }\n    }\n\n    protected _calcHeight(): number {\n        let height;\n        if (this.heightCache) {\n            height = this.heightCache.reduce((acc, val) => acc + val, 0);\n        } else {\n            height = this.initSizesCache(this.igxForOf);\n        }\n        this._virtHeight = height;\n        if (height > this._maxHeight) {\n            this._virtHeightRatio = height / this._maxHeight;\n            height = this._maxHeight;\n        }\n        return height;\n    }\n\n    protected _recalcOnContainerChange(changes: SimpleChanges) {\n        this.dc.instance._viewContainer.element.nativeElement.style.top = '0px';\n        this.dc.instance._viewContainer.element.nativeElement.style.left = '0px';\n        const prevChunkSize = this.state.chunkSize;\n        this.applyChunkSizeChange();\n        this._recalcScrollBarSize();\n        if (prevChunkSize !== this.state.chunkSize) {\n            this.onChunkLoad.emit(this.state);\n        }\n        if (this.sizesCache && this.igxForScrollOrientation === 'horizontal') {\n            // Updating horizontal chunks and offsets based on the new scrollLeft\n            const scrollOffset = this.fixedUpdateAllElements(this.scrollPosition);\n            this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';\n        }\n    }\n\n    /**\n     * @hidden\n     * Removes an elemenet from the embedded views and updates chunkSize.\n     */\n    protected removeLastElem() {\n        const oldElem = this._embeddedViews.pop();\n        this.onBeforeViewDestroyed.emit(oldElem);\n        // also detach from ViewContainerRef to make absolutely sure this is removed from the view container.\n        this.dc.instance._vcr.detach(this.dc.instance._vcr.length - 1);\n        oldElem.destroy();\n\n        this.state.chunkSize--;\n    }\n\n    /**\n     * @hidden\n     * If there exists an element that we can create embedded view for creates it, appends it and updates chunkSize\n     */\n    protected addLastElem() {\n        let elemIndex = this.state.startIndex + this.state.chunkSize;\n        if (!this.isRemote && !this.igxForOf) {\n            return;\n        }\n\n        if (elemIndex >= this.igxForOf.length) {\n            elemIndex = this.igxForOf.length - this.state.chunkSize;\n        }\n        const input = this.igxForOf[elemIndex];\n        const embeddedView = this.dc.instance._vcr.createEmbeddedView(\n            this._template,\n            new IgxForOfContext<T>(input, this.getContextIndex(input), this.igxForOf.length)\n        );\n\n        this._embeddedViews.push(embeddedView);\n        this.state.chunkSize++;\n\n        this._zone.run(() => {\n            this.cdr.markForCheck();\n        });\n    }\n\n    /**\n     * Recalculates chunkSize and adds/removes elements if need due to the change.\n     * this.state.chunkSize is updated in @addLastElem() or @removeLastElem()\n     */\n    protected applyChunkSizeChange() {\n        const chunkSize = this.isRemote ? (this.igxForOf ? this.igxForOf.length : 0) : this._calculateChunkSize();\n        if (chunkSize > this.state.chunkSize) {\n            const diff = chunkSize - this.state.chunkSize;\n            for (let i = 0; i < diff; i++) {\n                this.addLastElem();\n            }\n        } else if (chunkSize < this.state.chunkSize) {\n            const diff = this.state.chunkSize - chunkSize;\n            for (let i = 0; i < diff; i++) {\n                this.removeLastElem();\n            }\n        }\n    }\n\n    protected _updateScrollOffset() {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this._updateHScrollOffset();\n        } else {\n            this._updateVScrollOffset();\n        }\n    }\n    private _updateVScrollOffset() {\n        let scrollOffset = 0;\n        const vScroll =  this.scrollComponent.nativeElement;\n        scrollOffset = vScroll && this.scrollComponent.size ?\n            this.scrollPosition - this.sizesCache[this.state.startIndex] : 0;\n        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';\n    }\n    private _updateHScrollOffset() {\n        let scrollOffset = 0;\n        scrollOffset =  this.scrollComponent.nativeElement &&\n            this.scrollComponent.size ?\n            this.scrollPosition - this.sizesCache[this.state.startIndex] : 0;\n        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';\n    }\n\n    private _getItemSize(item, dimension: string): number {\n        const dim = item[dimension];\n        return typeof dim === 'number' ? dim : parseInt(this.igxForItemSize, 10) || 0;\n    }\n}\n\nexport function getTypeNameForDebugging(type: any): string {\n    const name = 'name';\n    return type[name] || typeof type;\n}\n\nexport interface IForOfState extends IBaseEventArgs {\n    startIndex?: number;\n    chunkSize?: number;\n}\n\nexport interface IForOfDataChangingEventArgs extends IBaseEventArgs {\n    containerSize: number;\n}\n\n@Directive({\n    selector: '[igxGridFor][igxGridForOf]'\n})\nexport class IgxGridForOfDirective<T> extends IgxForOfDirective<T> implements OnInit, OnChanges, DoCheck {\n\n    constructor(\n        _viewContainer: ViewContainerRef,\n        _template: TemplateRef<NgForOfContext<T>>,\n        _differs: IterableDiffers,\n        resolver: ComponentFactoryResolver,\n        cdr: ChangeDetectorRef,\n        _zone: NgZone,\n        protected syncScrollService: IgxForOfScrollSyncService,\n        protected syncService: IgxForOfSyncService) {\n        super(_viewContainer, _template, _differs, resolver, cdr, _zone, syncScrollService);\n    }\n\n    @Input()\n    set igxGridForOf(value) {\n        this.igxForOf = value;\n    }\n\n    get igxGridForOf() {\n        return this.igxForOf;\n    }\n\n    /**\n     * @hidden @internal\n     * An event that is emitted after data has been changed but before the view is refreshed\n     */\n    @Output()\n    public onDataChanging = new EventEmitter<IForOfDataChangingEventArgs>();\n\n    ngOnInit() {\n        this.syncService.setMaster(this);\n        super.ngOnInit();\n        this.removeScrollEventListeners();\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const forOf = 'igxGridForOf';\n        this.syncService.setMaster(this);\n        if (forOf in changes) {\n            const value = changes[forOf].currentValue;\n            if (!this._differ && value) {\n                try {\n                    this._differ = this._differs.find(value).create(this.igxForTrackBy);\n                } catch (e) {\n                    throw new Error(\n                        `Cannot find a differ supporting object \"${value}\" of type \"${getTypeNameForDebugging(value)}\".\n                     NgFor only supports binding to Iterables such as Arrays.`);\n                }\n            }\n        }\n        const defaultItemSize = 'igxForItemSize';\n        if (defaultItemSize in changes && !changes[defaultItemSize].firstChange &&\n             this.igxForScrollOrientation === 'vertical' && this.igxForOf) {\n            // handle default item size changed.\n            this.initSizesCache(this.igxForOf);\n        }\n        const containerSize = 'igxForContainerSize';\n        if (containerSize in changes && !changes[containerSize].firstChange && this.igxForOf) {\n            this._recalcOnContainerChange(changes);\n        }\n    }\n\n    /**\n     * @hidden\n     * @internal\n     */\n    public get sizesCache(): number[] {\n        if (this.syncService.isMaster(this)) {\n            return this._sizesCache;\n        }\n        return this.syncService.sizesCache(this.igxForScrollOrientation);\n    }\n    /**\n     * @hidden\n     * @internal\n     */\n    public set sizesCache(value: number[]) {\n        this._sizesCache = value;\n    }\n\n    protected get itemsDimension() {\n        return this.igxForScrollOrientation === 'horizontal' ? this.igxForSizePropName : 'height';\n    }\n\n    protected getItemSize(item) {\n        let size = 0;\n        const dimension = this.igxForScrollOrientation === 'horizontal' ?\n            this.igxForSizePropName : 'height';\n        if (dimension === 'height') {\n            size = parseInt(this.igxForItemSize, 10) || 0;\n            if (item && item.summaries) {\n                size = item.max;\n            } else if (item && item.groups && item.height) {\n                size = item.height;\n            }\n        } else {\n            size = parseInt(item[dimension], 10) || 0;\n        }\n        return size;\n    }\n\n    protected initSizesCache(items: any[]): number {\n        if (!this.syncService.isMaster(this)) {\n            const masterSizesCache = this.syncService.sizesCache(this.igxForScrollOrientation);\n            return masterSizesCache[masterSizesCache.length - 1];\n        }\n        let totalSize = 0;\n        let size = 0;\n        let i = 0;\n        this.sizesCache = [];\n        this.heightCache = [];\n        this.sizesCache.push(0);\n        const count = this.isRemote ? this.totalItemCount : items.length;\n        for (i; i < count; i++) {\n            size = this.getItemSize(items[i]);\n            if (this.itemsDimension === 'height') {\n                this.heightCache.push(size);\n            }\n            totalSize += size;\n            this.sizesCache.push(totalSize);\n        }\n        return totalSize;\n    }\n\n    protected _updateSizeCache(changes: IterableChanges<T> = null) {\n        if (this.igxForScrollOrientation === 'horizontal') {\n            this.initSizesCache(this.igxForOf);\n            return;\n        }\n\n        const oldHeight = this.heightCache.length > 0 ? this.heightCache.reduce((acc, val) => acc + val) : 0;\n        let newHeight = oldHeight;\n        if (changes && !this.isRemote) {\n            newHeight = this.handleCacheChanges(changes);\n        } else {\n            newHeight = this.initSizesCache(this.igxForOf);\n        }\n\n        const diff = oldHeight - newHeight;\n\n        // if data has been changed while container is scrolled\n        // should update scroll top/left according to change so that same startIndex is in view\n        if (Math.abs(diff) > 0) {\n            // TODO: This code can be removed. However tests need to be rewritten in a way that they wait for ResizeObserved to complete.\n            // So leaving as is for the moment.\n            requestAnimationFrame(() => {\n                this.recalcUpdateSizes();\n                const offset = parseInt(this.dc.instance._viewContainer.element.nativeElement.style.top, 10);\n                if (this.scrollPosition !== 0) {\n                    this.scrollPosition = this.sizesCache[this.state.startIndex] - offset;\n                } else {\n                    this._updateScrollOffset();\n                }\n            });\n        }\n    }\n\n    protected handleCacheChanges(changes: IterableChanges<T>) {\n        const identityChanges = [];\n        const newHeightCache = [];\n        const newSizesCache = [];\n        newSizesCache.push(0);\n        let newHeight = 0;\n\n        // When there are more than one removed items the changes are not reliable so those with identity change should be default size.\n        let numRemovedItems = 0;\n        changes.forEachRemovedItem(() => numRemovedItems++);\n\n        // Get the identity changes to determine later if those that have changed their indexes should be assigned default item size.\n        changes.forEachIdentityChange((item) => {\n            if (item.currentIndex !== item.previousIndex) {\n                // Filter out ones that have not changed their index.\n                identityChanges[item.currentIndex] = item;\n            }\n        });\n\n        // Processing each item that is passed to the igxForOf so far seem to be most reliable. We parse the updated list of items.\n        changes.forEachItem((item) => {\n            if (item.previousIndex !== null &&\n                (numRemovedItems < 2 || !identityChanges.length || identityChanges[item.currentIndex])) {\n                // Reuse cache on those who have previousIndex.\n                // When there are more than one removed items currently the changes are not readable so ones with identity change\n                // should be racalculated.\n                newHeightCache[item.currentIndex] = this.heightCache[item.previousIndex];\n            } else {\n                // Assign default item size.\n                newHeightCache[item.currentIndex] = this.getItemSize(item.item);\n            }\n            newSizesCache[item.currentIndex + 1] = newSizesCache[item.currentIndex] + newHeightCache[item.currentIndex];\n            newHeight += newHeightCache[item.currentIndex];\n        });\n        this.heightCache = newHeightCache;\n        this.sizesCache = newSizesCache;\n        return newHeight;\n    }\n\n    /**\n     * @hidden\n     * @internal\n     */\n    public assumeMaster(): void {\n        this._sizesCache = this.syncService.sizesCache(this.igxForScrollOrientation);\n        this.syncService.setMaster(this, true);\n    }\n\n    ngDoCheck() {\n        if (this._differ) {\n            const changes = this._differ.diff(this.igxForOf);\n            if (changes) {\n                const args: IForOfDataChangingEventArgs = {\n                    containerSize: this.igxForContainerSize\n                };\n                this.onDataChanging.emit(args);\n                //  re-init cache.\n                if (!this.igxForOf) {\n                    this.igxForOf = [];\n                }\n                /* we need to reset the master dir if all rows are removed\n                (e.g. because of filtering); if all columns are hidden, rows are\n                still rendered empty, so we should not reset master */\n                if (!this.igxForOf.length &&\n                    this.igxForScrollOrientation === 'vertical') {\n                    this.syncService.resetMaster();\n                }\n                this.syncService.setMaster(this);\n                this.igxForContainerSize = args.containerSize;\n                this._updateSizeCache(changes);\n                this._applyChanges();\n                this._updateScrollOffset();\n                this.onDataChanged.emit();\n            }\n        }\n    }\n\n    onScroll(event) {\n        if (!parseInt(this.scrollComponent.nativeElement.style.height, 10)) {\n            return;\n        }\n\n        const containerSize = parseInt(this.igxForContainerSize, 10);\n        const maxRealScrollTop = event.target.children[0].scrollHeight - containerSize;\n        const realPercentScrolled = maxRealScrollTop !== 0 ?  event.target.scrollTop / maxRealScrollTop : 0;\n        if (!this._bScrollInternal) {\n            const maxVirtScrollTop = this._virtHeight - containerSize;\n            this._virtScrollTop = realPercentScrolled * maxVirtScrollTop;\n        } else {\n            this._bScrollInternal = false;\n        }\n        const scrollOffset = this.fixedUpdateAllElements(this._virtScrollTop);\n\n        this.dc.instance._viewContainer.element.nativeElement.style.top = -(scrollOffset) + 'px';\n\n        this._zone.onStable.pipe(first()).subscribe( () => {\n            this.recalcUpdateSizes();\n        });\n        this.cdr.markForCheck();\n    }\n\n    onHScroll(scrollAmount) {\n        /* in certain situations this may be called when no scrollbar is visible */\n        if (!this.scrollComponent || !parseInt(this.scrollComponent.nativeElement.children[0].style.width, 10)) {\n            return;\n        }\n        // Updating horizontal chunks\n        const scrollOffset = this.fixedUpdateAllElements(scrollAmount);\n        this.dc.instance._viewContainer.element.nativeElement.style.left = -scrollOffset + 'px';\n    }\n\n    protected addLastElem() {\n        let elemIndex = this.state.startIndex + this.state.chunkSize;\n        if (!this.isRemote && !this.igxForOf) {\n            return;\n        }\n\n        if (elemIndex >= this.igxForOf.length) {\n            elemIndex = this.igxForOf.length - this.state.chunkSize;\n        }\n        const input = this.igxForOf[elemIndex];\n        const embeddedView = this.dc.instance._vcr.createEmbeddedView(\n            this._template,\n            new IgxForOfContext<T>(input, this.getContextIndex(input), this.igxForOf.length)\n        );\n\n        this._embeddedViews.push(embeddedView);\n        this.state.chunkSize++;\n    }\n\n    protected _updateViews(prevChunkSize) {\n        if (this.igxForOf && this.igxForOf.length && this.dc) {\n            const embeddedViewCopy = Object.assign([], this._embeddedViews);\n            let startIndex;\n            let endIndex;\n            if (this.isRemote) {\n                startIndex = 0;\n                endIndex = this.igxForOf.length;\n            } else {\n                startIndex = this.getIndexAt(\n                    this.scrollPosition,\n                    this.sizesCache,\n                    0\n                );\n                if (startIndex + this.state.chunkSize > this.igxForOf.length) {\n                    startIndex = this.igxForOf.length - this.state.chunkSize;\n                }\n                this.state.startIndex = startIndex;\n                endIndex = this.state.chunkSize + this.state.startIndex;\n            }\n\n            for (let i = startIndex; i < endIndex && this.igxForOf[i] !== undefined; i++) {\n                const input = this.igxForOf[i];\n                const embView = embeddedViewCopy.shift();\n                const cntx = (embView as EmbeddedViewRef<any>).context;\n                cntx.$implicit = input;\n                cntx.index = this.getContextIndex(input);\n                cntx.count = this.igxForOf.length;\n            }\n            if (prevChunkSize !== this.state.chunkSize) {\n                this.onChunkLoad.emit(this.state);\n            }\n        }\n    }\n    protected _applyChanges() {\n        const prevChunkSize = this.state.chunkSize;\n        this.applyChunkSizeChange();\n        this._recalcScrollBarSize();\n        this._updateViews(prevChunkSize);\n    }\n\n    /**\n     * @hidden\n     */\n    protected _calcMaxChunkSize(): number {\n        if (this.syncService.isMaster(this)) {\n            return super._calcMaxChunkSize();\n        }\n        return this.syncService.chunkSize(this.igxForScrollOrientation);\n    }\n}\n\n/**\n * @hidden\n */\n@NgModule({\n    declarations: [IgxForOfDirective, IgxGridForOfDirective, DisplayContainerComponent, VirtualHelperComponent,\n         HVirtualHelperComponent, VirtualHelperBaseDirective],\n    entryComponents: [DisplayContainerComponent, VirtualHelperComponent, HVirtualHelperComponent],\n    exports: [IgxForOfDirective, IgxGridForOfDirective],\n    imports: [IgxScrollInertiaModule, CommonModule]\n})\n\nexport class IgxForOfModule {\n}\n"]}