theme-lib/esm2015/lib/components/list/infinite-list.directive.js

This is a simple example Angular Library published to npm.

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import { Directive, Input, HostListener, ElementRef, EventEmitter, Output, ContentChildren, QueryList, } from '@angular/core';
import { forkJoin, of as observableOf, interval, timer } from 'rxjs';
import { takeWhile, filter, switchMap, map, takeUntil, take } from 'rxjs/operators';
import { convertToBoolProperty } from '../helpers';
import { NbLayoutScrollService } from '../../services/scroll.service';
import { NbLayoutRulerService } from '../../services/ruler.service';
import { NbListItemComponent } from './list.component';
export class NbScrollableContainerDimentions {
}
if (false) {
    /** @type {?} */
    NbScrollableContainerDimentions.prototype.scrollTop;
    /** @type {?} */
    NbScrollableContainerDimentions.prototype.scrollHeight;
    /** @type {?} */
    NbScrollableContainerDimentions.prototype.clientHeight;
}
/*
 * Infinite List Directive
 *
 * ```html
 *  <nb-list nbInfiniteList [threshold]="500" (bottomThreshold)="loadNext()">
 *    <nb-list-item *ngFor="let item of items"></nb-list-item>
 *  </nb-list>
 * ```
 *
 * @stacked-example(Simple infinite list, infinite-list/infinite-list-showcase.component)
 *
 * Directive will notify when list scrolled up or down to given a threshold.
 * By default it listen to scroll of list on which applied, but also can be set to listen to window scroll.
 *
 * @stacked-example(Scroll modes, infinite-list/infinite-list-scroll-modes.component)
 *
 * To improve UX of infinite lists, it's better to keep current page in url,
 * so user able to return to the last viewed page or to share a link to this page.
 * `nbListPageTracker` directive will help you to know, what page user currently viewing.
 * Just put it on a list, set page size and it will calculate page that currently in viewport.
 * You can [open the example](example/infinite-list/infinite-news-list.component)
 * in a new tab to check out this feature.
 *
 * @stacked-example(Infinite list with pager, infinite-list/infinite-news-list.component)
 *
 * @stacked-example(Infinite list with placeholders at the top, infinite-list/infinite-list-placeholders.component)
 *
 */
export class NbInfiniteListDirective {
    /**
     * @param {?} elementRef
     * @param {?} scrollService
     * @param {?} dimensionsService
     */
    constructor(elementRef, scrollService, dimensionsService) {
        this.elementRef = elementRef;
        this.scrollService = scrollService;
        this.dimensionsService = dimensionsService;
        this.alive = true;
        this.windowScroll = false;
        /*
           * Emits when distance between list bottom and current scroll position is less than threshold.
           */
        this.bottomThreshold = new EventEmitter(true);
        /*
           * Emits when distance between list top and current scroll position is less than threshold.
           */
        this.topThreshold = new EventEmitter(true);
    }
    /**
     * @private
     * @return {?}
     */
    get elementScroll() {
        return !this.windowScroll;
    }
    /*
       * By default component observes list scroll position.
       * If set to `true`, component will observe position of page scroll instead.
       */
    /**
     * @param {?} value
     * @return {?}
     */
    set listenWindowScroll(value) {
        this.windowScroll = convertToBoolProperty(value);
    }
    /**
     * @return {?}
     */
    onElementScroll() {
        if (this.elementScroll) {
            this.checkPosition(this.elementRef.nativeElement);
        }
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        this.scrollService.onScroll()
            .pipe(takeWhile(() => this.alive), filter(() => this.windowScroll), switchMap(() => this.getContainerDimensions()))
            .subscribe(dimentions => this.checkPosition(dimentions));
        this.listItems.changes
            .pipe(takeWhile(() => this.alive), 
        // For some reason, changes are emitted before list item removed from dom,
        // so dimensions will be incorrect.
        // Check every 50ms for a second if dom and query are in sync.
        // Once they synchronized, we can get proper dimensions.
        switchMap(() => interval(50).pipe(takeUntil(timer(1000)), filter(() => this.inSyncWithDom()), take(1))), switchMap(() => this.getContainerDimensions()))
            .subscribe(dimentions => this.checkPosition(dimentions));
        this.getContainerDimensions().subscribe(dimentions => this.checkPosition(dimentions));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.alive = false;
    }
    /**
     * @param {?} __0
     * @return {?}
     */
    checkPosition({ scrollHeight, scrollTop, clientHeight }) {
        /** @type {?} */
        const initialCheck = this.lastScrollPosition == null;
        /** @type {?} */
        const manualCheck = this.lastScrollPosition === scrollTop;
        /** @type {?} */
        const scrollUp = scrollTop < this.lastScrollPosition;
        /** @type {?} */
        const scrollDown = scrollTop > this.lastScrollPosition;
        /** @type {?} */
        const distanceToBottom = scrollHeight - scrollTop - clientHeight;
        if ((initialCheck || manualCheck || scrollDown) && distanceToBottom <= this.threshold) {
            this.bottomThreshold.emit();
        }
        if ((initialCheck || scrollUp) && scrollTop <= this.threshold) {
            this.topThreshold.emit();
        }
        this.lastScrollPosition = scrollTop;
    }
    /**
     * @private
     * @return {?}
     */
    getContainerDimensions() {
        if (this.elementScroll) {
            const { scrollTop, scrollHeight, clientHeight } = this.elementRef.nativeElement;
            return observableOf({ scrollTop, scrollHeight, clientHeight });
        }
        return forkJoin(this.scrollService.getPosition(), this.dimensionsService.getDimensions())
            .pipe(map(([scrollPosition, dimensions]) => ({
            scrollTop: scrollPosition.y,
            scrollHeight: dimensions.scrollHeight,
            clientHeight: dimensions.clientHeight,
        })));
    }
    /**
     * @private
     * @return {?}
     */
    inSyncWithDom() {
        return this.elementRef.nativeElement.children.length === this.listItems.length;
    }
}
NbInfiniteListDirective.decorators = [
    { type: Directive, args: [{
                selector: '[nbInfiniteList]',
            },] }
];
/** @nocollapse */
NbInfiniteListDirective.ctorParameters = () => [
    { type: ElementRef },
    { type: NbLayoutScrollService },
    { type: NbLayoutRulerService }
];
NbInfiniteListDirective.propDecorators = {
    threshold: [{ type: Input }],
    listenWindowScroll: [{ type: Input }],
    bottomThreshold: [{ type: Output }],
    topThreshold: [{ type: Output }],
    onElementScroll: [{ type: HostListener, args: ['scroll',] }],
    listItems: [{ type: ContentChildren, args: [NbListItemComponent,] }]
};
if (false) {
    /**
     * @type {?}
     * @private
     */
    NbInfiniteListDirective.prototype.alive;
    /**
     * @type {?}
     * @private
     */
    NbInfiniteListDirective.prototype.lastScrollPosition;
    /** @type {?} */
    NbInfiniteListDirective.prototype.windowScroll;
    /** @type {?} */
    NbInfiniteListDirective.prototype.threshold;
    /** @type {?} */
    NbInfiniteListDirective.prototype.bottomThreshold;
    /** @type {?} */
    NbInfiniteListDirective.prototype.topThreshold;
    /** @type {?} */
    NbInfiniteListDirective.prototype.listItems;
    /**
     * @type {?}
     * @private
     */
    NbInfiniteListDirective.prototype.elementRef;
    /**
     * @type {?}
     * @private
     */
    NbInfiniteListDirective.prototype.scrollService;
    /**
     * @type {?}
     * @private
     */
    NbInfiniteListDirective.prototype.dimensionsService;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinite-list.directive.js","sourceRoot":"ng://theme-lib/","sources":["lib/components/list/infinite-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Directive,\r\n  Input,\r\n  HostListener,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Output,\r\n  OnDestroy,\r\n  AfterViewInit,\r\n  ContentChildren,\r\n  QueryList,\r\n} from '@angular/core';\r\nimport { Observable, forkJoin, of as observableOf, interval, timer } from 'rxjs';\r\nimport { takeWhile, filter, switchMap, map, takeUntil, take } from 'rxjs/operators';\r\nimport { convertToBoolProperty } from '../helpers';\r\nimport { NbLayoutScrollService } from '../../services/scroll.service';\r\nimport { NbLayoutRulerService } from '../../services/ruler.service';\r\nimport { NbListItemComponent } from './list.component';\r\n\r\nexport class NbScrollableContainerDimentions {\r\n  scrollTop: number;\r\n  scrollHeight: number;\r\n  clientHeight: number;\r\n}\r\n\r\n/*\r\n * Infinite List Directive\r\n *\r\n * ```html\r\n *  <nb-list nbInfiniteList [threshold]=\"500\" (bottomThreshold)=\"loadNext()\">\r\n *    <nb-list-item *ngFor=\"let item of items\"></nb-list-item>\r\n *  </nb-list>\r\n * ```\r\n *\r\n * @stacked-example(Simple infinite list, infinite-list/infinite-list-showcase.component)\r\n *\r\n * Directive will notify when list scrolled up or down to given a threshold.\r\n * By default it listen to scroll of list on which applied, but also can be set to listen to window scroll.\r\n *\r\n * @stacked-example(Scroll modes, infinite-list/infinite-list-scroll-modes.component)\r\n *\r\n * To improve UX of infinite lists, it's better to keep current page in url,\r\n * so user able to return to the last viewed page or to share a link to this page.\r\n * `nbListPageTracker` directive will help you to know, what page user currently viewing.\r\n * Just put it on a list, set page size and it will calculate page that currently in viewport.\r\n * You can [open the example](example/infinite-list/infinite-news-list.component)\r\n * in a new tab to check out this feature.\r\n *\r\n * @stacked-example(Infinite list with pager, infinite-list/infinite-news-list.component)\r\n *\r\n * @stacked-example(Infinite list with placeholders at the top, infinite-list/infinite-list-placeholders.component)\r\n *\r\n */\r\n@Directive({\r\n  selector: '[nbInfiniteList]',\r\n})\r\nexport class NbInfiniteListDirective implements AfterViewInit, OnDestroy {\r\n\r\n  private alive = true;\r\n  private lastScrollPosition;\r\n  windowScroll = false;\r\n  private get elementScroll() {\r\n    return !this.windowScroll;\r\n  }\r\n\r\n  /*\r\n   * Threshold after which event load more event will be emited.\r\n   * In pixels.\r\n   */\r\n  @Input()\r\n  threshold: number;\r\n\r\n  /*\r\n   * By default component observes list scroll position.\r\n   * If set to `true`, component will observe position of page scroll instead.\r\n   */\r\n  @Input()\r\n  set listenWindowScroll(value) {\r\n    this.windowScroll = convertToBoolProperty(value);\r\n  }\r\n\r\n  /*\r\n   * Emits when distance between list bottom and current scroll position is less than threshold.\r\n   */\r\n  @Output()\r\n  bottomThreshold = new EventEmitter(true);\r\n\r\n  /*\r\n   * Emits when distance between list top and current scroll position is less than threshold.\r\n   */\r\n  @Output()\r\n  topThreshold = new EventEmitter(true);\r\n\r\n  @HostListener('scroll')\r\n  onElementScroll() {\r\n    if (this.elementScroll) {\r\n      this.checkPosition(this.elementRef.nativeElement);\r\n    }\r\n  }\r\n\r\n  @ContentChildren(NbListItemComponent) listItems: QueryList<NbListItemComponent>;\r\n\r\n  constructor(\r\n    private elementRef: ElementRef,\r\n    private scrollService: NbLayoutScrollService,\r\n    private dimensionsService: NbLayoutRulerService,\r\n  ) {}\r\n\r\n  ngAfterViewInit() {\r\n    this.scrollService.onScroll()\r\n      .pipe(\r\n        takeWhile(() => this.alive),\r\n        filter(() => this.windowScroll),\r\n        switchMap(() => this.getContainerDimensions()),\r\n      )\r\n      .subscribe(dimentions => this.checkPosition(dimentions));\r\n\r\n    this.listItems.changes\r\n      .pipe(\r\n        takeWhile(() => this.alive),\r\n        // For some reason, changes are emitted before list item removed from dom,\r\n        // so dimensions will be incorrect.\r\n        // Check every 50ms for a second if dom and query are in sync.\r\n        // Once they synchronized, we can get proper dimensions.\r\n        switchMap(() => interval(50).pipe(\r\n          takeUntil(timer(1000)),\r\n          filter(() => this.inSyncWithDom()),\r\n          take(1),\r\n        )),\r\n        switchMap(() => this.getContainerDimensions()),\r\n      )\r\n      .subscribe(dimentions => this.checkPosition(dimentions));\r\n\r\n      this.getContainerDimensions().subscribe(dimentions => this.checkPosition(dimentions));\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.alive = false;\r\n  }\r\n\r\n  checkPosition({ scrollHeight, scrollTop, clientHeight }: NbScrollableContainerDimentions) {\r\n    const initialCheck = this.lastScrollPosition == null;\r\n    const manualCheck = this.lastScrollPosition === scrollTop;\r\n    const scrollUp = scrollTop < this.lastScrollPosition;\r\n    const scrollDown = scrollTop > this.lastScrollPosition;\r\n    const distanceToBottom = scrollHeight - scrollTop - clientHeight;\r\n\r\n    if ((initialCheck ||  manualCheck || scrollDown) && distanceToBottom <= this.threshold) {\r\n      this.bottomThreshold.emit();\r\n    }\r\n    if ((initialCheck || scrollUp) && scrollTop <= this.threshold) {\r\n      this.topThreshold.emit();\r\n    }\r\n\r\n    this.lastScrollPosition = scrollTop;\r\n  }\r\n\r\n  private getContainerDimensions(): Observable<NbScrollableContainerDimentions> {\r\n    if (this.elementScroll) {\r\n      const { scrollTop, scrollHeight, clientHeight } = this.elementRef.nativeElement;\r\n      return observableOf({ scrollTop, scrollHeight, clientHeight });\r\n    }\r\n\r\n    return forkJoin(this.scrollService.getPosition(), this.dimensionsService.getDimensions())\r\n      .pipe(\r\n          map(([scrollPosition, dimensions]) => ({\r\n            scrollTop: scrollPosition.y,\r\n            scrollHeight: dimensions.scrollHeight,\r\n            clientHeight: dimensions.clientHeight,\r\n          })),\r\n      );\r\n  }\r\n\r\n  private inSyncWithDom(): boolean {\r\n    return this.elementRef.nativeElement.children.length === this.listItems.length;\r\n  }\r\n}\r\n"]}