fix(ng-6): postinstall

__ivy_ngcc__/dist/modules/ngx-infinite-scroll.js

@@ -0,0 +1,819 @@
+import { Directive, ElementRef, EventEmitter, Input, NgModule, NgZone, Output } from '@angular/core';
+import { fromEvent, of } from 'rxjs';
+import { filter, map, mergeMap, sampleTime, tap } from 'rxjs/operators';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} selector
+ * @param {?} scrollWindow
+ * @param {?} defaultElement
+ * @param {?} fromRoot
+ * @return {?}
+ */
+import * as ɵngcc0 from '@angular/core';
+function resolveContainerElement(selector, scrollWindow, defaultElement, fromRoot) {
+    /** @type {?} */
+    const hasWindow = window && !!window.document && window.document.documentElement;
+    /** @type {?} */
+    let container = hasWindow && scrollWindow ? window : defaultElement;
+    if (selector) {
+        /** @type {?} */
+        const containerIsString = selector && hasWindow && typeof selector === 'string';
+        container = containerIsString
+            ? findElement(selector, defaultElement.nativeElement, fromRoot)
+            : selector;
+        if (!container) {
+            throw new Error('ngx-infinite-scroll {resolveContainerElement()}: selector for');
+        }
+    }
+    return container;
+}
+/**
+ * @param {?} selector
+ * @param {?} customRoot
+ * @param {?} fromRoot
+ * @return {?}
+ */
+function findElement(selector, customRoot, fromRoot) {
+    /** @type {?} */
+    const rootEl = fromRoot ? window.document : customRoot;
+    return rootEl.querySelector(selector);
+}
+/**
+ * @param {?} prop
+ * @return {?}
+ */
+function inputPropChanged(prop) {
+    return prop && !prop.firstChange;
+}
+/**
+ * @return {?}
+ */
+function hasWindowDefined() {
+    return typeof window !== 'undefined';
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const VerticalProps = {
+    clientHeight: "clientHeight",
+    offsetHeight: "offsetHeight",
+    scrollHeight: "scrollHeight",
+    pageYOffset: "pageYOffset",
+    offsetTop: "offsetTop",
+    scrollTop: "scrollTop",
+    top: "top"
+};
+/** @type {?} */
+const HorizontalProps = {
+    clientHeight: "clientWidth",
+    offsetHeight: "offsetWidth",
+    scrollHeight: "scrollWidth",
+    pageYOffset: "pageXOffset",
+    offsetTop: "offsetLeft",
+    scrollTop: "scrollLeft",
+    top: "left"
+};
+class AxisResolver {
+    /**
+     * @param {?=} vertical
+     */
+    constructor(vertical = true) {
+        this.vertical = vertical;
+        this.propsMap = vertical ? VerticalProps : HorizontalProps;
+    }
+    /**
+     * @return {?}
+     */
+    clientHeightKey() {
+        return this.propsMap.clientHeight;
+    }
+    /**
+     * @return {?}
+     */
+    offsetHeightKey() {
+        return this.propsMap.offsetHeight;
+    }
+    /**
+     * @return {?}
+     */
+    scrollHeightKey() {
+        return this.propsMap.scrollHeight;
+    }
+    /**
+     * @return {?}
+     */
+    pageYOffsetKey() {
+        return this.propsMap.pageYOffset;
+    }
+    /**
+     * @return {?}
+     */
+    offsetTopKey() {
+        return this.propsMap.offsetTop;
+    }
+    /**
+     * @return {?}
+     */
+    scrollTopKey() {
+        return this.propsMap.scrollTop;
+    }
+    /**
+     * @return {?}
+     */
+    topKey() {
+        return this.propsMap.top;
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+
+/**
+ * @record
+ */
+
+/**
+ * @record
+ */
+
+/**
+ * @record
+ */
+
+/**
+ * @param {?} alwaysCallback
+ * @param {?} shouldFireScrollEvent
+ * @param {?} isTriggeredCurrentTotal
+ * @return {?}
+ */
+function shouldTriggerEvents(alwaysCallback, shouldFireScrollEvent, isTriggeredCurrentTotal) {
+    if (alwaysCallback && shouldFireScrollEvent) {
+        return true;
+    }
+    if (!isTriggeredCurrentTotal && shouldFireScrollEvent) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} __0
+ * @return {?}
+ */
+function createResolver({ windowElement, axis }) {
+    return createResolverWithContainer({ axis, isWindow: isElementWindow(windowElement) }, windowElement);
+}
+/**
+ * @param {?} resolver
+ * @param {?} windowElement
+ * @return {?}
+ */
+function createResolverWithContainer(resolver, windowElement) {
+    /** @type {?} */
+    const container = resolver.isWindow || (windowElement && !windowElement.nativeElement)
+        ? windowElement
+        : windowElement.nativeElement;
+    return Object.assign(Object.assign({}, resolver), { container });
+}
+/**
+ * @param {?} windowElement
+ * @return {?}
+ */
+function isElementWindow(windowElement) {
+    /** @type {?} */
+    const isWindow = ['Window', 'global'].some((/**
+     * @param {?} obj
+     * @return {?}
+     */
+    (obj) => Object.prototype.toString.call(windowElement).includes(obj)));
+    return isWindow;
+}
+/**
+ * @param {?} isContainerWindow
+ * @param {?} windowElement
+ * @return {?}
+ */
+function getDocumentElement(isContainerWindow, windowElement) {
+    return isContainerWindow ? windowElement.document.documentElement : null;
+}
+/**
+ * @param {?} element
+ * @param {?} resolver
+ * @return {?}
+ */
+function calculatePoints(element, resolver) {
+    /** @type {?} */
+    const height = extractHeightForElement(resolver);
+    return resolver.isWindow
+        ? calculatePointsForWindow(height, element, resolver)
+        : calculatePointsForElement(height, element, resolver);
+}
+/**
+ * @param {?} height
+ * @param {?} element
+ * @param {?} resolver
+ * @return {?}
+ */
+function calculatePointsForWindow(height, element, resolver) {
+    const { axis, container, isWindow } = resolver;
+    const { offsetHeightKey, clientHeightKey } = extractHeightPropKeys(axis);
+    // scrolled until now / current y point
+    /** @type {?} */
+    const scrolled = height +
+        getElementPageYOffset(getDocumentElement(isWindow, container), axis, isWindow);
+    // total height / most bottom y point
+    /** @type {?} */
+    const nativeElementHeight = getElementHeight(element.nativeElement, isWindow, offsetHeightKey, clientHeightKey);
+    /** @type {?} */
+    const totalToScroll = getElementOffsetTop(element.nativeElement, axis, isWindow) +
+        nativeElementHeight;
+    return { height, scrolled, totalToScroll, isWindow };
+}
+/**
+ * @param {?} height
+ * @param {?} element
+ * @param {?} resolver
+ * @return {?}
+ */
+function calculatePointsForElement(height, element, resolver) {
+    const { axis, container } = resolver;
+    // perhaps use container.offsetTop instead of 'scrollTop'
+    /** @type {?} */
+    const scrolled = container[axis.scrollTopKey()];
+    /** @type {?} */
+    const totalToScroll = container[axis.scrollHeightKey()];
+    return { height, scrolled, totalToScroll, isWindow: false };
+}
+/**
+ * @param {?} axis
+ * @return {?}
+ */
+function extractHeightPropKeys(axis) {
+    return {
+        offsetHeightKey: axis.offsetHeightKey(),
+        clientHeightKey: axis.clientHeightKey()
+    };
+}
+/**
+ * @param {?} __0
+ * @return {?}
+ */
+function extractHeightForElement({ container, isWindow, axis }) {
+    const { offsetHeightKey, clientHeightKey } = extractHeightPropKeys(axis);
+    return getElementHeight(container, isWindow, offsetHeightKey, clientHeightKey);
+}
+/**
+ * @param {?} elem
+ * @param {?} isWindow
+ * @param {?} offsetHeightKey
+ * @param {?} clientHeightKey
+ * @return {?}
+ */
+function getElementHeight(elem, isWindow, offsetHeightKey, clientHeightKey) {
+    if (isNaN(elem[offsetHeightKey])) {
+        /** @type {?} */
+        const docElem = getDocumentElement(isWindow, elem);
+        return docElem ? docElem[clientHeightKey] : 0;
+    }
+    else {
+        return elem[offsetHeightKey];
+    }
+}
+/**
+ * @param {?} elem
+ * @param {?} axis
+ * @param {?} isWindow
+ * @return {?}
+ */
+function getElementOffsetTop(elem, axis, isWindow) {
+    /** @type {?} */
+    const topKey = axis.topKey();
+    // elem = elem.nativeElement;
+    if (!elem.getBoundingClientRect) {
+        // || elem.css('none')) {
+        return;
+    }
+    return (elem.getBoundingClientRect()[topKey] +
+        getElementPageYOffset(elem, axis, isWindow));
+}
+/**
+ * @param {?} elem
+ * @param {?} axis
+ * @param {?} isWindow
+ * @return {?}
+ */
+function getElementPageYOffset(elem, axis, isWindow) {
+    /** @type {?} */
+    const pageYOffset = axis.pageYOffsetKey();
+    /** @type {?} */
+    const scrollTop = axis.scrollTopKey();
+    /** @type {?} */
+    const offsetTop = axis.offsetTopKey();
+    if (isNaN(window.pageYOffset)) {
+        return getDocumentElement(isWindow, elem)[scrollTop];
+    }
+    else if (elem.ownerDocument) {
+        return elem.ownerDocument.defaultView[pageYOffset];
+    }
+    else {
+        return elem[offsetTop];
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} container
+ * @param {?} distance
+ * @param {?} scrollingDown
+ * @return {?}
+ */
+function shouldFireScrollEvent(container, distance, scrollingDown) {
+    /** @type {?} */
+    let remaining;
+    /** @type {?} */
+    let containerBreakpoint;
+    if (container.totalToScroll <= 0) {
+        return false;
+    }
+    /** @type {?} */
+    const scrolledUntilNow = container.isWindow ? container.scrolled : container.height + container.scrolled;
+    if (scrollingDown) {
+        remaining =
+            (container.totalToScroll - scrolledUntilNow) / container.totalToScroll;
+        containerBreakpoint = distance.down / 10;
+    }
+    else {
+        /** @type {?} */
+        const totalHiddenContentHeight = container.scrolled + (container.totalToScroll - scrolledUntilNow);
+        remaining = container.scrolled / totalHiddenContentHeight;
+        containerBreakpoint = distance.up / 10;
+    }
+    /** @type {?} */
+    const shouldFireEvent = remaining <= containerBreakpoint;
+    return shouldFireEvent;
+}
+/**
+ * @param {?} lastScrollPosition
+ * @param {?} container
+ * @return {?}
+ */
+function isScrollingDownwards(lastScrollPosition, container) {
+    return lastScrollPosition < container.scrolled;
+}
+/**
+ * @param {?} lastScrollPosition
+ * @param {?} container
+ * @param {?} distance
+ * @return {?}
+ */
+function getScrollStats(lastScrollPosition, container, distance) {
+    /** @type {?} */
+    const scrollDown = isScrollingDownwards(lastScrollPosition, container);
+    return {
+        fire: shouldFireScrollEvent(container, distance, scrollDown),
+        scrollDown
+    };
+}
+/**
+ * @param {?} position
+ * @param {?} scrollState
+ * @return {?}
+ */
+
+/**
+ * @param {?} totalToScroll
+ * @param {?} scrollState
+ * @return {?}
+ */
+
+/**
+ * @param {?} scrollState
+ * @return {?}
+ */
+
+/**
+ * @param {?} scroll
+ * @param {?} scrollState
+ * @param {?} triggered
+ * @param {?} isScrollingDown
+ * @return {?}
+ */
+
+/**
+ * @param {?} totalToScroll
+ * @param {?} scrollState
+ * @param {?} isScrollingDown
+ * @return {?}
+ */
+
+/**
+ * @param {?} scrollState
+ * @param {?} scrolledUntilNow
+ * @param {?} totalToScroll
+ * @return {?}
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class ScrollState {
+    /**
+     * @param {?} __0
+     */
+    constructor({ totalToScroll }) {
+        this.lastScrollPosition = 0;
+        this.lastTotalToScroll = 0;
+        this.totalToScroll = 0;
+        this.triggered = {
+            down: 0,
+            up: 0
+        };
+        this.totalToScroll = totalToScroll;
+    }
+    /**
+     * @param {?} position
+     * @return {?}
+     */
+    updateScrollPosition(position) {
+        return (this.lastScrollPosition = position);
+    }
+    /**
+     * @param {?} totalToScroll
+     * @return {?}
+     */
+    updateTotalToScroll(totalToScroll) {
+        if (this.lastTotalToScroll !== totalToScroll) {
+            this.lastTotalToScroll = this.totalToScroll;
+            this.totalToScroll = totalToScroll;
+        }
+    }
+    /**
+     * @param {?} scrolledUntilNow
+     * @param {?} totalToScroll
+     * @return {?}
+     */
+    updateScroll(scrolledUntilNow, totalToScroll) {
+        this.updateScrollPosition(scrolledUntilNow);
+        this.updateTotalToScroll(totalToScroll);
+    }
+    /**
+     * @param {?} scroll
+     * @param {?} isScrollingDown
+     * @return {?}
+     */
+    updateTriggeredFlag(scroll, isScrollingDown) {
+        if (isScrollingDown) {
+            this.triggered.down = scroll;
+        }
+        else {
+            this.triggered.up = scroll;
+        }
+    }
+    /**
+     * @param {?} totalToScroll
+     * @param {?} isScrollingDown
+     * @return {?}
+     */
+    isTriggeredScroll(totalToScroll, isScrollingDown) {
+        return isScrollingDown
+            ? this.triggered.down === totalToScroll
+            : this.triggered.up === totalToScroll;
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} config
+ * @return {?}
+ */
+function createScroller(config) {
+    const { scrollContainer, scrollWindow, element, fromRoot } = config;
+    /** @type {?} */
+    const resolver = createResolver({
+        axis: new AxisResolver(!config.horizontal),
+        windowElement: resolveContainerElement(scrollContainer, scrollWindow, element, fromRoot)
+    });
+    /** @type {?} */
+    const scrollState = new ScrollState({
+        totalToScroll: calculatePoints(element, resolver)
+    });
+    /** @type {?} */
+    const options = {
+        container: resolver.container,
+        throttle: config.throttle
+    };
+    /** @type {?} */
+    const distance = {
+        up: config.upDistance,
+        down: config.downDistance
+    };
+    return attachScrollEvent(options).pipe(mergeMap((/**
+     * @return {?}
+     */
+    () => of(calculatePoints(element, resolver)))), map((/**
+     * @param {?} positionStats
+     * @return {?}
+     */
+    (positionStats) => toInfiniteScrollParams(scrollState.lastScrollPosition, positionStats, distance))), tap((/**
+     * @param {?} __0
+     * @return {?}
+     */
+    ({ stats }) => scrollState.updateScroll(stats.scrolled, stats.totalToScroll))), filter((/**
+     * @param {?} __0
+     * @return {?}
+     */
+    ({ fire, scrollDown, stats: { totalToScroll } }) => shouldTriggerEvents(config.alwaysCallback, fire, scrollState.isTriggeredScroll(totalToScroll, scrollDown)))), tap((/**
+     * @param {?} __0
+     * @return {?}
+     */
+    ({ scrollDown, stats: { totalToScroll } }) => {
+        scrollState.updateTriggeredFlag(totalToScroll, scrollDown);
+    })), map(toInfiniteScrollAction));
+}
+/**
+ * @param {?} options
+ * @return {?}
+ */
+function attachScrollEvent(options) {
+    /** @type {?} */
+    let obs = fromEvent(options.container, 'scroll');
+    // For an unknown reason calling `sampleTime()` causes trouble for many users, even with `options.throttle = 0`.
+    // Let's avoid calling the function unless needed.
+    // See https://github.com/orizens/ngx-infinite-scroll/issues/198
+    if (options.throttle) {
+        obs = obs.pipe(sampleTime(options.throttle));
+    }
+    return obs;
+}
+/**
+ * @param {?} lastScrollPosition
+ * @param {?} stats
+ * @param {?} distance
+ * @return {?}
+ */
+function toInfiniteScrollParams(lastScrollPosition, stats, distance) {
+    const { scrollDown, fire } = getScrollStats(lastScrollPosition, stats, distance);
+    return {
+        scrollDown,
+        fire,
+        stats
+    };
+}
+/** @type {?} */
+const InfiniteScrollActions = {
+    DOWN: '[NGX_ISE] DOWN',
+    UP: '[NGX_ISE] UP'
+};
+/**
+ * @param {?} response
+ * @return {?}
+ */
+function toInfiniteScrollAction(response) {
+    const { scrollDown, stats: { scrolled: currentScrollPosition } } = response;
+    return {
+        type: scrollDown ? InfiniteScrollActions.DOWN : InfiniteScrollActions.UP,
+        payload: {
+            currentScrollPosition
+        }
+    };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class InfiniteScrollDirective {
+    /**
+     * @param {?} element
+     * @param {?} zone
+     */
+    constructor(element, zone) {
+        this.element = element;
+        this.zone = zone;
+        this.scrolled = new EventEmitter();
+        this.scrolledUp = new EventEmitter();
+        this.infiniteScrollDistance = 2;
+        this.infiniteScrollUpDistance = 1.5;
+        this.infiniteScrollThrottle = 150;
+        this.infiniteScrollDisabled = false;
+        this.infiniteScrollContainer = null;
+        this.scrollWindow = true;
+        this.immediateCheck = false;
+        this.horizontal = false;
+        this.alwaysCallback = false;
+        this.fromRoot = false;
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        if (!this.infiniteScrollDisabled) {
+            this.setup();
+        }
+    }
+    /**
+     * @param {?} __0
+     * @return {?}
+     */
+    ngOnChanges({ infiniteScrollContainer, infiniteScrollDisabled, infiniteScrollDistance }) {
+        /** @type {?} */
+        const containerChanged = inputPropChanged(infiniteScrollContainer);
+        /** @type {?} */
+        const disabledChanged = inputPropChanged(infiniteScrollDisabled);
+        /** @type {?} */
+        const distanceChanged = inputPropChanged(infiniteScrollDistance);
+        /** @type {?} */
+        const shouldSetup = (!disabledChanged && !this.infiniteScrollDisabled) ||
+            (disabledChanged && !infiniteScrollDisabled.currentValue) || distanceChanged;
+        if (containerChanged || disabledChanged || distanceChanged) {
+            this.destroyScroller();
+            if (shouldSetup) {
+                this.setup();
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    setup() {
+        if (hasWindowDefined()) {
+            this.zone.runOutsideAngular((/**
+             * @return {?}
+             */
+            () => {
+                this.disposeScroller = createScroller({
+                    fromRoot: this.fromRoot,
+                    alwaysCallback: this.alwaysCallback,
+                    disable: this.infiniteScrollDisabled,
+                    downDistance: this.infiniteScrollDistance,
+                    element: this.element,
+                    horizontal: this.horizontal,
+                    scrollContainer: this.infiniteScrollContainer,
+                    scrollWindow: this.scrollWindow,
+                    throttle: this.infiniteScrollThrottle,
+                    upDistance: this.infiniteScrollUpDistance
+                }).subscribe((/**
+                 * @param {?} payload
+                 * @return {?}
+                 */
+                (payload) => this.zone.run((/**
+                 * @return {?}
+                 */
+                () => this.handleOnScroll(payload)))));
+            }));
+        }
+    }
+    /**
+     * @param {?} __0
+     * @return {?}
+     */
+    handleOnScroll({ type, payload }) {
+        switch (type) {
+            case InfiniteScrollActions.DOWN:
+                return this.scrolled.emit(payload);
+            case InfiniteScrollActions.UP:
+                return this.scrolledUp.emit(payload);
+            default:
+                return;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.destroyScroller();
+    }
+    /**
+     * @return {?}
+     */
+    destroyScroller() {
+        if (this.disposeScroller) {
+            this.disposeScroller.unsubscribe();
+        }
+    }
+}
+InfiniteScrollDirective.ɵfac = function InfiniteScrollDirective_Factory(t) { return new (t || InfiniteScrollDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone)); };
+InfiniteScrollDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: InfiniteScrollDirective, selectors: [["", "infiniteScroll", ""], ["", "infinite-scroll", ""], ["", "data-infinite-scroll", ""]], inputs: { infiniteScrollDistance: "infiniteScrollDistance", infiniteScrollUpDistance: "infiniteScrollUpDistance", infiniteScrollThrottle: "infiniteScrollThrottle", infiniteScrollDisabled: "infiniteScrollDisabled", infiniteScrollContainer: "infiniteScrollContainer", scrollWindow: "scrollWindow", immediateCheck: "immediateCheck", horizontal: "horizontal", alwaysCallback: "alwaysCallback", fromRoot: "fromRoot" }, outputs: { scrolled: "scrolled", scrolledUp: "scrolledUp" }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
+/** @nocollapse */
+InfiniteScrollDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone }
+];
+InfiniteScrollDirective.propDecorators = {
+    scrolled: [{ type: Output }],
+    scrolledUp: [{ type: Output }],
+    infiniteScrollDistance: [{ type: Input }],
+    infiniteScrollUpDistance: [{ type: Input }],
+    infiniteScrollThrottle: [{ type: Input }],
+    infiniteScrollDisabled: [{ type: Input }],
+    infiniteScrollContainer: [{ type: Input }],
+    scrollWindow: [{ type: Input }],
+    immediateCheck: [{ type: Input }],
+    horizontal: [{ type: Input }],
+    alwaysCallback: [{ type: Input }],
+    fromRoot: [{ type: Input }]
+};
+/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(InfiniteScrollDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[infiniteScroll], [infinite-scroll], [data-infinite-scroll]'
+            }]
+    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.NgZone }]; }, { scrolled: [{
+            type: Output
+        }], scrolledUp: [{
+            type: Output
+        }], infiniteScrollDistance: [{
+            type: Input
+        }], infiniteScrollUpDistance: [{
+            type: Input
+        }], infiniteScrollThrottle: [{
+            type: Input
+        }], infiniteScrollDisabled: [{
+            type: Input
+        }], infiniteScrollContainer: [{
+            type: Input
+        }], scrollWindow: [{
+            type: Input
+        }], immediateCheck: [{
+            type: Input
+        }], horizontal: [{
+            type: Input
+        }], alwaysCallback: [{
+            type: Input
+        }], fromRoot: [{
+            type: Input
+        }] }); })();
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class InfiniteScrollModule {
+}
+InfiniteScrollModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: InfiniteScrollModule });
+InfiniteScrollModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function InfiniteScrollModule_Factory(t) { return new (t || InfiniteScrollModule)(); }, providers: [], imports: [[]] });
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(InfiniteScrollModule, { declarations: [InfiniteScrollDirective], exports: [InfiniteScrollDirective] }); })();
+/*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(InfiniteScrollModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [InfiniteScrollDirective],
+                exports: [InfiniteScrollDirective],
+                imports: [],
+                providers: []
+            }]
+    }], null, null); })();
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Angular library starter.
+ * Build an Angular library compatible with AoT compilation & Tree shaking.
+ * Written by Roberto Simonetti.
+ * MIT license.
+ * https://github.com/robisim74/angular-library-starter
+ */
+/**
+ * Entry point for all public APIs of the package.
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { InfiniteScrollDirective, InfiniteScrollModule };
+
+//# sourceMappingURL=ngx-infinite-scroll.js.map

examples/package.json

@@ -22,6 +22,7 @@
     "@angular/platform-browser-dynamic": "^6.0.2",
     "@angular/router": "^6.0.2",
     "core-js": "^2.4.1",
+    "ngx-infinite-scroll": "6.9.1",
     "rxjs": "6.1.0",
     "rxjs-compat": "^6.0.0-rc.0",
     "zone.js": "^0.8.26"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-infinite-scroll",
-  "version": "6.9.0",
+  "version": "6.9.1",
   "description": "An infinite scroll directive for Angular compatible with AoT compilation and Tree shaking",
   "main": "./bundles/ngx-infinite-scroll.umd.js",
   "module": "./modules/ngx-infinite-scroll.es5.js",
@@ -16,7 +16,7 @@
     "compodoc-serve": "compodoc -s",
     "transpile": "ngc -p ./tsconfig.json",
     "serve:prod": "npm run build && lite-server -c ./example/bs-config.json",
-    "postinstall": "opencollective postinstall"
+    "postinstall": "opencollective-postinstall || exit 0"
   },
   "typings": "./ngx-infinite-scroll.d.ts",
   "author": "Oren Farhi (orizens.com)",
@@ -60,9 +60,10 @@
     "karma-sourcemap-loader": "0.3.7",
     "karma-spec-reporter": "0.0.30",
     "karma-webpack": "2.0.3",
+    "opencollective-postinstall": "2.0.2",
     "reflect-metadata": "0.1.10",
     "rollup": "0.41.6",
-    "rxjs": "^6.1.0",
+    "rxjs": "6.1.0",
     "shelljs": "0.7.7",
     "sorcery": "0.10.0",
     "ts-helpers": "1.1.2",
@@ -74,9 +75,6 @@
     "yargs": "7.0.2",
     "zone.js": "^0.8.26"
   },
-  "dependencies": {
-    "opencollective": "^1.0.3"
-  },
   "collective": {
     "type": "opencollective",
     "url": "https://opencollective.com/ngx-infinite-scroll",