theme-lib
Version:
This is a simple example Angular Library published to npm.
263 lines • 24 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import * as tslib_1 from "tslib";
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';
var NbScrollableContainerDimentions = /** @class */ (function () {
function NbScrollableContainerDimentions() {
}
return NbScrollableContainerDimentions;
}());
export { 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)
*
*/
var NbInfiniteListDirective = /** @class */ (function () {
function NbInfiniteListDirective(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);
}
Object.defineProperty(NbInfiniteListDirective.prototype, "elementScroll", {
get: /**
* @private
* @return {?}
*/
function () {
return !this.windowScroll;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NbInfiniteListDirective.prototype, "listenWindowScroll", {
/*
* By default component observes list scroll position.
* If set to `true`, component will observe position of page scroll instead.
*/
set: /*
* By default component observes list scroll position.
* If set to `true`, component will observe position of page scroll instead.
*/
/**
* @param {?} value
* @return {?}
*/
function (value) {
this.windowScroll = convertToBoolProperty(value);
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
NbInfiniteListDirective.prototype.onElementScroll = /**
* @return {?}
*/
function () {
if (this.elementScroll) {
this.checkPosition(this.elementRef.nativeElement);
}
};
/**
* @return {?}
*/
NbInfiniteListDirective.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
var _this = this;
this.scrollService.onScroll()
.pipe(takeWhile(function () { return _this.alive; }), filter(function () { return _this.windowScroll; }), switchMap(function () { return _this.getContainerDimensions(); }))
.subscribe(function (dimentions) { return _this.checkPosition(dimentions); });
this.listItems.changes
.pipe(takeWhile(function () { return _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(function () { return interval(50).pipe(takeUntil(timer(1000)), filter(function () { return _this.inSyncWithDom(); }), take(1)); }), switchMap(function () { return _this.getContainerDimensions(); }))
.subscribe(function (dimentions) { return _this.checkPosition(dimentions); });
this.getContainerDimensions().subscribe(function (dimentions) { return _this.checkPosition(dimentions); });
};
/**
* @return {?}
*/
NbInfiniteListDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.alive = false;
};
/**
* @param {?} __0
* @return {?}
*/
NbInfiniteListDirective.prototype.checkPosition = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var scrollHeight = _a.scrollHeight, scrollTop = _a.scrollTop, clientHeight = _a.clientHeight;
/** @type {?} */
var initialCheck = this.lastScrollPosition == null;
/** @type {?} */
var manualCheck = this.lastScrollPosition === scrollTop;
/** @type {?} */
var scrollUp = scrollTop < this.lastScrollPosition;
/** @type {?} */
var scrollDown = scrollTop > this.lastScrollPosition;
/** @type {?} */
var 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 {?}
*/
NbInfiniteListDirective.prototype.getContainerDimensions = /**
* @private
* @return {?}
*/
function () {
if (this.elementScroll) {
var _a = this.elementRef.nativeElement, scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
return observableOf({ scrollTop: scrollTop, scrollHeight: scrollHeight, clientHeight: clientHeight });
}
return forkJoin(this.scrollService.getPosition(), this.dimensionsService.getDimensions())
.pipe(map(function (_a) {
var _b = tslib_1.__read(_a, 2), scrollPosition = _b[0], dimensions = _b[1];
return ({
scrollTop: scrollPosition.y,
scrollHeight: dimensions.scrollHeight,
clientHeight: dimensions.clientHeight,
});
}));
};
/**
* @private
* @return {?}
*/
NbInfiniteListDirective.prototype.inSyncWithDom = /**
* @private
* @return {?}
*/
function () {
return this.elementRef.nativeElement.children.length === this.listItems.length;
};
NbInfiniteListDirective.decorators = [
{ type: Directive, args: [{
selector: '[nbInfiniteList]',
},] }
];
/** @nocollapse */
NbInfiniteListDirective.ctorParameters = function () { return [
{ 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,] }]
};
return NbInfiniteListDirective;
}());
export { NbInfiniteListDirective };
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":";;;;;AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,MAAM,EAGN,eAAe,EACf,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAc,QAAQ,EAAE,EAAE,IAAI,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD;IAAA;IAIA,CAAC;IAAD,sCAAC;AAAD,CAAC,AAJD,IAIC;;;;IAHC,oDAAkB;;IAClB,uDAAqB;;IACrB,uDAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BvB;IAiDE,iCACU,UAAsB,EACtB,aAAoC,EACpC,iBAAuC;QAFvC,eAAU,GAAV,UAAU,CAAY;QACtB,kBAAa,GAAb,aAAa,CAAuB;QACpC,sBAAiB,GAAjB,iBAAiB,CAAsB;QA/CzC,UAAK,GAAG,IAAI,CAAC;QAErB,iBAAY,GAAG,KAAK,CAAC;;;;QAyBrB,oBAAe,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;;;;QAMzC,iBAAY,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAenC,CAAC;IA7CJ,sBAAY,kDAAa;;;;;QAAzB;YACE,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;QAC5B,CAAC;;;OAAA;IAaD,sBACI,uDAAkB;QALtB;;;WAGG;;;;;;;;;QACH,UACuB,KAAK;YAC1B,IAAI,CAAC,YAAY,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACnD,CAAC;;;OAAA;;;;IAeD,iDAAe;;;IADf;QAEE,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;SACnD;IACH,CAAC;;;;IAUD,iDAAe;;;IAAf;QAAA,iBA0BC;QAzBC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;aAC1B,IAAI,CACH,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,KAAK,EAAV,CAAU,CAAC,EAC3B,MAAM,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,EAAjB,CAAiB,CAAC,EAC/B,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,sBAAsB,EAAE,EAA7B,CAA6B,CAAC,CAC/C;aACA,SAAS,CAAC,UAAA,UAAU,IAAI,OAAA,KAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAA9B,CAA8B,CAAC,CAAC;QAE3D,IAAI,CAAC,SAAS,CAAC,OAAO;aACnB,IAAI,CACH,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,KAAK,EAAV,CAAU,CAAC;QAC3B,0EAA0E;QAC1E,mCAAmC;QACnC,8DAA8D;QAC9D,wDAAwD;QACxD,SAAS,CAAC,cAAM,OAAA,QAAQ,CAAC,EAAE,CAAC,CAAC,IAAI,CAC/B,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EACtB,MAAM,CAAC,cAAM,OAAA,KAAI,CAAC,aAAa,EAAE,EAApB,CAAoB,CAAC,EAClC,IAAI,CAAC,CAAC,CAAC,CACR,EAJe,CAIf,CAAC,EACF,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,sBAAsB,EAAE,EAA7B,CAA6B,CAAC,CAC/C;aACA,SAAS,CAAC,UAAA,UAAU,IAAI,OAAA,KAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAA9B,CAA8B,CAAC,CAAC;QAEzD,IAAI,CAAC,sBAAsB,EAAE,CAAC,SAAS,CAAC,UAAA,UAAU,IAAI,OAAA,KAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAA9B,CAA8B,CAAC,CAAC;IAC1F,CAAC;;;;IAED,6CAAW;;;IAAX;QACE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;;;;;IAED,+CAAa;;;;IAAb,UAAc,EAA0E;YAAxE,8BAAY,EAAE,wBAAS,EAAE,8BAAY;;YAC7C,YAAY,GAAG,IAAI,CAAC,kBAAkB,IAAI,IAAI;;YAC9C,WAAW,GAAG,IAAI,CAAC,kBAAkB,KAAK,SAAS;;YACnD,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,kBAAkB;;YAC9C,UAAU,GAAG,SAAS,GAAG,IAAI,CAAC,kBAAkB;;YAChD,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,YAAY;QAEhE,IAAI,CAAC,YAAY,IAAK,WAAW,IAAI,UAAU,CAAC,IAAI,gBAAgB,IAAI,IAAI,CAAC,SAAS,EAAE;YACtF,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;SAC7B;QACD,IAAI,CAAC,YAAY,IAAI,QAAQ,CAAC,IAAI,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE;YAC7D,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;QAED,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;IACtC,CAAC;;;;;IAEO,wDAAsB;;;;IAA9B;QACE,IAAI,IAAI,CAAC,aAAa,EAAE;YAChB,IAAA,kCAAyE,EAAvE,wBAAS,EAAE,8BAAY,EAAE,8BAA8C;YAC/E,OAAO,YAAY,CAAC,EAAE,SAAS,WAAA,EAAE,YAAY,cAAA,EAAE,YAAY,cAAA,EAAE,CAAC,CAAC;SAChE;QAED,OAAO,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;aACtF,IAAI,CACD,GAAG,CAAC,UAAC,EAA4B;gBAA5B,0BAA4B,EAA3B,sBAAc,EAAE,kBAAU;YAAM,OAAA,CAAC;gBACrC,SAAS,EAAE,cAAc,CAAC,CAAC;gBAC3B,YAAY,EAAE,UAAU,CAAC,YAAY;gBACrC,YAAY,EAAE,UAAU,CAAC,YAAY;aACtC,CAAC;QAJoC,CAIpC,CAAC,CACN,CAAC;IACN,CAAC;;;;;IAEO,+CAAa;;;;IAArB;QACE,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IACjF,CAAC;;gBA1HF,SAAS,SAAC;oBACT,QAAQ,EAAE,kBAAkB;iBAC7B;;;;gBAnDC,UAAU;gBAWH,qBAAqB;gBACrB,oBAAoB;;;4BAqD1B,KAAK;qCAOL,KAAK;kCAQL,MAAM;+BAMN,MAAM;kCAGN,YAAY,SAAC,QAAQ;4BAOrB,eAAe,SAAC,mBAAmB;;IA4EtC,8BAAC;CAAA,AA3HD,IA2HC;SAxHY,uBAAuB;;;;;;IAElC,wCAAqB;;;;;IACrB,qDAA2B;;IAC3B,+CAAqB;;IASrB,4CACkB;;IAclB,kDACyC;;IAKzC,+CACsC;;IAStC,4CAAgF;;;;;IAG9E,6CAA8B;;;;;IAC9B,gDAA4C;;;;;IAC5C,oDAA+C","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"]}