@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/scrolling/virtual-scroll-viewport.js

@@ -24,344 +24,340 @@ function rangesEqual(r1, r2) {
  */
 const SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;
 /** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */
-let CdkVirtualScrollViewport = /** @class */ (() => {
-    class CdkVirtualScrollViewport extends CdkScrollable {
-        constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, 
+export class CdkVirtualScrollViewport extends CdkScrollable {
+    constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, 
+    /**
+     * @deprecated `viewportRuler` parameter to become required.
+     * @breaking-change 11.0.0
+     */
+    viewportRuler) {
+        super(elementRef, scrollDispatcher, ngZone, dir);
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._scrollStrategy = _scrollStrategy;
+        /** Emits when the viewport is detached from a CdkVirtualForOf. */
+        this._detachedSubject = new Subject();
+        /** Emits when the rendered range changes. */
+        this._renderedRangeSubject = new Subject();
+        this._orientation = 'vertical';
+        // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll
+        // strategy lazily (i.e. only if the user is actually listening to the events). We do this because
+        // depending on how the strategy calculates the scrolled index, it may come at a cost to
+        // performance.
+        /** Emits when the index of the first element visible in the viewport changes. */
+        this.scrolledIndexChange = new Observable((observer) => this._scrollStrategy.scrolledIndexChange.subscribe(index => Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));
+        /** A stream that emits whenever the rendered range changes. */
+        this.renderedRangeStream = this._renderedRangeSubject.asObservable();
         /**
-         * @deprecated `viewportRuler` parameter to become required.
-         * @breaking-change 11.0.0
+         * The total size of all content (in pixels), including content that is not currently rendered.
          */
-        viewportRuler) {
-            super(elementRef, scrollDispatcher, ngZone, dir);
-            this.elementRef = elementRef;
-            this._changeDetectorRef = _changeDetectorRef;
-            this._scrollStrategy = _scrollStrategy;
-            /** Emits when the viewport is detached from a CdkVirtualForOf. */
-            this._detachedSubject = new Subject();
-            /** Emits when the rendered range changes. */
-            this._renderedRangeSubject = new Subject();
-            this._orientation = 'vertical';
-            // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll
-            // strategy lazily (i.e. only if the user is actually listening to the events). We do this because
-            // depending on how the strategy calculates the scrolled index, it may come at a cost to
-            // performance.
-            /** Emits when the index of the first element visible in the viewport changes. */
-            this.scrolledIndexChange = new Observable((observer) => this._scrollStrategy.scrolledIndexChange.subscribe(index => Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));
-            /** A stream that emits whenever the rendered range changes. */
-            this.renderedRangeStream = this._renderedRangeSubject.asObservable();
-            /**
-             * The total size of all content (in pixels), including content that is not currently rendered.
-             */
-            this._totalContentSize = 0;
-            /** A string representing the `style.width` property value to be used for the spacer element. */
-            this._totalContentWidth = '';
-            /** A string representing the `style.height` property value to be used for the spacer element. */
-            this._totalContentHeight = '';
-            /** The currently rendered range of indices. */
-            this._renderedRange = { start: 0, end: 0 };
-            /** The length of the data bound to this viewport (in number of items). */
-            this._dataLength = 0;
-            /** The size of the viewport (in pixels). */
-            this._viewportSize = 0;
-            /** The last rendered content offset that was set. */
-            this._renderedContentOffset = 0;
-            /**
-             * Whether the last rendered content offset was to the end of the content (and therefore needs to
-             * be rewritten as an offset to the start of the content).
-             */
-            this._renderedContentOffsetNeedsRewrite = false;
-            /** Whether there is a pending change detection cycle. */
-            this._isChangeDetectionPending = false;
-            /** A list of functions to run after the next change detection cycle. */
-            this._runAfterChangeDetection = [];
-            /** Subscription to changes in the viewport size. */
-            this._viewportChanges = Subscription.EMPTY;
-            if (!_scrollStrategy) {
-                throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');
-            }
-            // @breaking-change 11.0.0 Remove null check for `viewportRuler`.
-            if (viewportRuler) {
-                this._viewportChanges = viewportRuler.change().subscribe(() => {
-                    this.checkViewportSize();
-                });
-            }
-        }
-        /** The direction the viewport scrolls. */
-        get orientation() {
-            return this._orientation;
-        }
-        set orientation(orientation) {
-            if (this._orientation !== orientation) {
-                this._orientation = orientation;
-                this._calculateSpacerSize();
-            }
-        }
-        ngOnInit() {
-            super.ngOnInit();
-            // It's still too early to measure the viewport at this point. Deferring with a promise allows
-            // the Viewport to be rendered with the correct size before we measure. We run this outside the
-            // zone to avoid causing more change detection cycles. We handle the change detection loop
-            // ourselves instead.
-            this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
-                this._measureViewportSize();
-                this._scrollStrategy.attach(this);
-                this.elementScrolled()
-                    .pipe(
-                // Start off with a fake scroll event so we properly detect our initial position.
-                startWith(null), 
-                // Collect multiple events into one until the next animation frame. This way if
-                // there are multiple scroll events in the same frame we only need to recheck
-                // our layout once.
-                auditTime(0, SCROLL_SCHEDULER))
-                    .subscribe(() => this._scrollStrategy.onContentScrolled());
-                this._markChangeDetectionNeeded();
-            }));
-        }
-        ngOnDestroy() {
-            this.detach();
-            this._scrollStrategy.detach();
-            // Complete all subjects
-            this._renderedRangeSubject.complete();
-            this._detachedSubject.complete();
-            this._viewportChanges.unsubscribe();
-            super.ngOnDestroy();
-        }
-        /** Attaches a `CdkVirtualForOf` to this viewport. */
-        attach(forOf) {
-            if (this._forOf) {
-                throw Error('CdkVirtualScrollViewport is already attached.');
-            }
-            // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length
-            // changes. Run outside the zone to avoid triggering change detection, since we're managing the
-            // change detection loop ourselves.
-            this.ngZone.runOutsideAngular(() => {
-                this._forOf = forOf;
-                this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe(data => {
-                    const newLength = data.length;
-                    if (newLength !== this._dataLength) {
-                        this._dataLength = newLength;
-                        this._scrollStrategy.onDataLengthChanged();
-                    }
-                    this._doChangeDetection();
-                });
-            });
-        }
-        /** Detaches the current `CdkVirtualForOf`. */
-        detach() {
-            this._forOf = null;
-            this._detachedSubject.next();
-        }
-        /** Gets the length of the data bound to this viewport (in number of items). */
-        getDataLength() {
-            return this._dataLength;
-        }
-        /** Gets the size of the viewport (in pixels). */
-        getViewportSize() {
-            return this._viewportSize;
-        }
-        // TODO(mmalerba): This is technically out of sync with what's really rendered until a render
-        // cycle happens. I'm being careful to only call it after the render cycle is complete and before
-        // setting it to something else, but its error prone and should probably be split into
-        // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.
-        /** Get the current rendered range of items. */
-        getRenderedRange() {
-            return this._renderedRange;
-        }
+        this._totalContentSize = 0;
+        /** A string representing the `style.width` property value to be used for the spacer element. */
+        this._totalContentWidth = '';
+        /** A string representing the `style.height` property value to be used for the spacer element. */
+        this._totalContentHeight = '';
+        /** The currently rendered range of indices. */
+        this._renderedRange = { start: 0, end: 0 };
+        /** The length of the data bound to this viewport (in number of items). */
+        this._dataLength = 0;
+        /** The size of the viewport (in pixels). */
+        this._viewportSize = 0;
+        /** The last rendered content offset that was set. */
+        this._renderedContentOffset = 0;
         /**
-         * Sets the total size of all content (in pixels), including content that is not currently
-         * rendered.
+         * Whether the last rendered content offset was to the end of the content (and therefore needs to
+         * be rewritten as an offset to the start of the content).
          */
-        setTotalContentSize(size) {
-            if (this._totalContentSize !== size) {
-                this._totalContentSize = size;
-                this._calculateSpacerSize();
-                this._markChangeDetectionNeeded();
-            }
+        this._renderedContentOffsetNeedsRewrite = false;
+        /** Whether there is a pending change detection cycle. */
+        this._isChangeDetectionPending = false;
+        /** A list of functions to run after the next change detection cycle. */
+        this._runAfterChangeDetection = [];
+        /** Subscription to changes in the viewport size. */
+        this._viewportChanges = Subscription.EMPTY;
+        if (!_scrollStrategy) {
+            throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');
         }
-        /** Sets the currently rendered range of indices. */
-        setRenderedRange(range) {
-            if (!rangesEqual(this._renderedRange, range)) {
-                this._renderedRangeSubject.next(this._renderedRange = range);
-                this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());
-            }
+        // @breaking-change 11.0.0 Remove null check for `viewportRuler`.
+        if (viewportRuler) {
+            this._viewportChanges = viewportRuler.change().subscribe(() => {
+                this.checkViewportSize();
+            });
         }
-        /**
-         * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
-         */
-        getOffsetToRenderedContentStart() {
-            return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;
+    }
+    /** The direction the viewport scrolls. */
+    get orientation() {
+        return this._orientation;
+    }
+    set orientation(orientation) {
+        if (this._orientation !== orientation) {
+            this._orientation = orientation;
+            this._calculateSpacerSize();
         }
-        /**
-         * Sets the offset from the start of the viewport to either the start or end of the rendered data
-         * (in pixels).
-         */
-        setRenderedContentOffset(offset, to = 'to-start') {
-            // For a horizontal viewport in a right-to-left language we need to translate along the x-axis
-            // in the negative direction.
-            const isRtl = this.dir && this.dir.value == 'rtl';
-            const isHorizontal = this.orientation == 'horizontal';
-            const axis = isHorizontal ? 'X' : 'Y';
-            const axisDirection = isHorizontal && isRtl ? -1 : 1;
-            let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;
-            this._renderedContentOffset = offset;
-            if (to === 'to-end') {
-                transform += ` translate${axis}(-100%)`;
-                // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise
-                // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would
-                // expand upward).
-                this._renderedContentOffsetNeedsRewrite = true;
-            }
-            if (this._renderedContentTransform != transform) {
-                // We know this value is safe because we parse `offset` with `Number()` before passing it
-                // into the string.
-                this._renderedContentTransform = transform;
-                this._markChangeDetectionNeeded(() => {
-                    if (this._renderedContentOffsetNeedsRewrite) {
-                        this._renderedContentOffset -= this.measureRenderedContentSize();
-                        this._renderedContentOffsetNeedsRewrite = false;
-                        this.setRenderedContentOffset(this._renderedContentOffset);
-                    }
-                    else {
-                        this._scrollStrategy.onRenderedOffsetChanged();
-                    }
-                });
-            }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // It's still too early to measure the viewport at this point. Deferring with a promise allows
+        // the Viewport to be rendered with the correct size before we measure. We run this outside the
+        // zone to avoid causing more change detection cycles. We handle the change detection loop
+        // ourselves instead.
+        this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+            this._measureViewportSize();
+            this._scrollStrategy.attach(this);
+            this.elementScrolled()
+                .pipe(
+            // Start off with a fake scroll event so we properly detect our initial position.
+            startWith(null), 
+            // Collect multiple events into one until the next animation frame. This way if
+            // there are multiple scroll events in the same frame we only need to recheck
+            // our layout once.
+            auditTime(0, SCROLL_SCHEDULER))
+                .subscribe(() => this._scrollStrategy.onContentScrolled());
+            this._markChangeDetectionNeeded();
+        }));
+    }
+    ngOnDestroy() {
+        this.detach();
+        this._scrollStrategy.detach();
+        // Complete all subjects
+        this._renderedRangeSubject.complete();
+        this._detachedSubject.complete();
+        this._viewportChanges.unsubscribe();
+        super.ngOnDestroy();
+    }
+    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */
+    attach(forOf) {
+        if (this._forOf) {
+            throw Error('CdkVirtualScrollViewport is already attached.');
         }
-        /**
-         * Scrolls to the given offset from the start of the viewport. Please note that this is not always
-         * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left
-         * direction, this would be the equivalent of setting a fictional `scrollRight` property.
-         * @param offset The offset to scroll to.
-         * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
-         */
-        scrollToOffset(offset, behavior = 'auto') {
-            const options = { behavior };
-            if (this.orientation === 'horizontal') {
-                options.start = offset;
-            }
-            else {
-                options.top = offset;
-            }
-            this.scrollTo(options);
+        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length
+        // changes. Run outside the zone to avoid triggering change detection, since we're managing the
+        // change detection loop ourselves.
+        this.ngZone.runOutsideAngular(() => {
+            this._forOf = forOf;
+            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe(data => {
+                const newLength = data.length;
+                if (newLength !== this._dataLength) {
+                    this._dataLength = newLength;
+                    this._scrollStrategy.onDataLengthChanged();
+                }
+                this._doChangeDetection();
+            });
+        });
+    }
+    /** Detaches the current `CdkVirtualForOf`. */
+    detach() {
+        this._forOf = null;
+        this._detachedSubject.next();
+    }
+    /** Gets the length of the data bound to this viewport (in number of items). */
+    getDataLength() {
+        return this._dataLength;
+    }
+    /** Gets the size of the viewport (in pixels). */
+    getViewportSize() {
+        return this._viewportSize;
+    }
+    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render
+    // cycle happens. I'm being careful to only call it after the render cycle is complete and before
+    // setting it to something else, but its error prone and should probably be split into
+    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.
+    /** Get the current rendered range of items. */
+    getRenderedRange() {
+        return this._renderedRange;
+    }
+    /**
+     * Sets the total size of all content (in pixels), including content that is not currently
+     * rendered.
+     */
+    setTotalContentSize(size) {
+        if (this._totalContentSize !== size) {
+            this._totalContentSize = size;
+            this._calculateSpacerSize();
+            this._markChangeDetectionNeeded();
         }
-        /**
-         * Scrolls to the offset for the given index.
-         * @param index The index of the element to scroll to.
-         * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
-         */
-        scrollToIndex(index, behavior = 'auto') {
-            this._scrollStrategy.scrollToIndex(index, behavior);
+    }
+    /** Sets the currently rendered range of indices. */
+    setRenderedRange(range) {
+        if (!rangesEqual(this._renderedRange, range)) {
+            this._renderedRangeSubject.next(this._renderedRange = range);
+            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());
         }
-        /**
-         * Gets the current scroll offset from the start of the viewport (in pixels).
-         * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'
-         *     in horizontal mode.
-         */
-        measureScrollOffset(from) {
-            return from ?
-                super.measureScrollOffset(from) :
-                super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');
+    }
+    /**
+     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
+     */
+    getOffsetToRenderedContentStart() {
+        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;
+    }
+    /**
+     * Sets the offset from the start of the viewport to either the start or end of the rendered data
+     * (in pixels).
+     */
+    setRenderedContentOffset(offset, to = 'to-start') {
+        // For a horizontal viewport in a right-to-left language we need to translate along the x-axis
+        // in the negative direction.
+        const isRtl = this.dir && this.dir.value == 'rtl';
+        const isHorizontal = this.orientation == 'horizontal';
+        const axis = isHorizontal ? 'X' : 'Y';
+        const axisDirection = isHorizontal && isRtl ? -1 : 1;
+        let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;
+        this._renderedContentOffset = offset;
+        if (to === 'to-end') {
+            transform += ` translate${axis}(-100%)`;
+            // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise
+            // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would
+            // expand upward).
+            this._renderedContentOffsetNeedsRewrite = true;
         }
-        /** Measure the combined size of all of the rendered items. */
-        measureRenderedContentSize() {
-            const contentEl = this._contentWrapper.nativeElement;
-            return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;
+        if (this._renderedContentTransform != transform) {
+            // We know this value is safe because we parse `offset` with `Number()` before passing it
+            // into the string.
+            this._renderedContentTransform = transform;
+            this._markChangeDetectionNeeded(() => {
+                if (this._renderedContentOffsetNeedsRewrite) {
+                    this._renderedContentOffset -= this.measureRenderedContentSize();
+                    this._renderedContentOffsetNeedsRewrite = false;
+                    this.setRenderedContentOffset(this._renderedContentOffset);
+                }
+                else {
+                    this._scrollStrategy.onRenderedOffsetChanged();
+                }
+            });
         }
-        /**
-         * Measure the total combined size of the given range. Throws if the range includes items that are
-         * not rendered.
-         */
-        measureRangeSize(range) {
-            if (!this._forOf) {
-                return 0;
-            }
-            return this._forOf.measureRangeSize(range, this.orientation);
+    }
+    /**
+     * Scrolls to the given offset from the start of the viewport. Please note that this is not always
+     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left
+     * direction, this would be the equivalent of setting a fictional `scrollRight` property.
+     * @param offset The offset to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToOffset(offset, behavior = 'auto') {
+        const options = { behavior };
+        if (this.orientation === 'horizontal') {
+            options.start = offset;
         }
-        /** Update the viewport dimensions and re-render. */
-        checkViewportSize() {
-            // TODO: Cleanup later when add logic for handling content resize
-            this._measureViewportSize();
-            this._scrollStrategy.onDataLengthChanged();
+        else {
+            options.top = offset;
         }
-        /** Measure the viewport size. */
-        _measureViewportSize() {
-            const viewportEl = this.elementRef.nativeElement;
-            this._viewportSize = this.orientation === 'horizontal' ?
-                viewportEl.clientWidth : viewportEl.clientHeight;
+        this.scrollTo(options);
+    }
+    /**
+     * Scrolls to the offset for the given index.
+     * @param index The index of the element to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToIndex(index, behavior = 'auto') {
+        this._scrollStrategy.scrollToIndex(index, behavior);
+    }
+    /**
+     * Gets the current scroll offset from the start of the viewport (in pixels).
+     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'
+     *     in horizontal mode.
+     */
+    measureScrollOffset(from) {
+        return from ?
+            super.measureScrollOffset(from) :
+            super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');
+    }
+    /** Measure the combined size of all of the rendered items. */
+    measureRenderedContentSize() {
+        const contentEl = this._contentWrapper.nativeElement;
+        return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;
+    }
+    /**
+     * Measure the total combined size of the given range. Throws if the range includes items that are
+     * not rendered.
+     */
+    measureRangeSize(range) {
+        if (!this._forOf) {
+            return 0;
         }
-        /** Queue up change detection to run. */
-        _markChangeDetectionNeeded(runAfter) {
-            if (runAfter) {
-                this._runAfterChangeDetection.push(runAfter);
-            }
-            // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of
-            // properties sequentially we only have to run `_doChangeDetection` once at the end.
-            if (!this._isChangeDetectionPending) {
-                this._isChangeDetectionPending = true;
-                this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
-                    this._doChangeDetection();
-                }));
-            }
+        return this._forOf.measureRangeSize(range, this.orientation);
+    }
+    /** Update the viewport dimensions and re-render. */
+    checkViewportSize() {
+        // TODO: Cleanup later when add logic for handling content resize
+        this._measureViewportSize();
+        this._scrollStrategy.onDataLengthChanged();
+    }
+    /** Measure the viewport size. */
+    _measureViewportSize() {
+        const viewportEl = this.elementRef.nativeElement;
+        this._viewportSize = this.orientation === 'horizontal' ?
+            viewportEl.clientWidth : viewportEl.clientHeight;
+    }
+    /** Queue up change detection to run. */
+    _markChangeDetectionNeeded(runAfter) {
+        if (runAfter) {
+            this._runAfterChangeDetection.push(runAfter);
         }
-        /** Run change detection. */
-        _doChangeDetection() {
-            this._isChangeDetectionPending = false;
-            // Apply the content transform. The transform can't be set via an Angular binding because
-            // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of
-            // string literals, a variable that can only be 'X' or 'Y', and user input that is run through
-            // the `Number` function first to coerce it to a numeric value.
-            this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;
-            // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection
-            // from the root, since the repeated items are content projected in. Calling `detectChanges`
-            // instead does not properly check the projected content.
-            this.ngZone.run(() => this._changeDetectorRef.markForCheck());
-            const runAfterChangeDetection = this._runAfterChangeDetection;
-            this._runAfterChangeDetection = [];
-            for (const fn of runAfterChangeDetection) {
-                fn();
-            }
+        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of
+        // properties sequentially we only have to run `_doChangeDetection` once at the end.
+        if (!this._isChangeDetectionPending) {
+            this._isChangeDetectionPending = true;
+            this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+                this._doChangeDetection();
+            }));
         }
-        /** Calculates the `style.width` and `style.height` for the spacer element. */
-        _calculateSpacerSize() {
-            this._totalContentHeight =
-                this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;
-            this._totalContentWidth =
-                this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';
+    }
+    /** Run change detection. */
+    _doChangeDetection() {
+        this._isChangeDetectionPending = false;
+        // Apply the content transform. The transform can't be set via an Angular binding because
+        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of
+        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through
+        // the `Number` function first to coerce it to a numeric value.
+        this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;
+        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection
+        // from the root, since the repeated items are content projected in. Calling `detectChanges`
+        // instead does not properly check the projected content.
+        this.ngZone.run(() => this._changeDetectorRef.markForCheck());
+        const runAfterChangeDetection = this._runAfterChangeDetection;
+        this._runAfterChangeDetection = [];
+        for (const fn of runAfterChangeDetection) {
+            fn();
         }
     }
-    CdkVirtualScrollViewport.decorators = [
-        { type: Component, args: [{
-                    selector: 'cdk-virtual-scroll-viewport',
-                    template: "<!--\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\n  position.\n-->\n<div #contentWrapper class=\"cdk-virtual-scroll-content-wrapper\">\n  <ng-content></ng-content>\n</div>\n<!--\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\n  so that the scrollbar captures the size of the entire data set.\n-->\n<div class=\"cdk-virtual-scroll-spacer\"\n     [style.width]=\"_totalContentWidth\" [style.height]=\"_totalContentHeight\"></div>\n",
-                    host: {
-                        'class': 'cdk-virtual-scroll-viewport',
-                        '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === "horizontal"',
-                        '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== "horizontal"',
-                    },
-                    encapsulation: ViewEncapsulation.None,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    providers: [{
-                            provide: CdkScrollable,
-                            useExisting: CdkVirtualScrollViewport,
-                        }],
-                    styles: ["cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"]
-                },] }
-    ];
-    CdkVirtualScrollViewport.ctorParameters = () => [
-        { type: ElementRef },
-        { type: ChangeDetectorRef },
-        { type: NgZone },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [VIRTUAL_SCROLL_STRATEGY,] }] },
-        { type: Directionality, decorators: [{ type: Optional }] },
-        { type: ScrollDispatcher },
-        { type: ViewportRuler, decorators: [{ type: Optional }] }
-    ];
-    CdkVirtualScrollViewport.propDecorators = {
-        orientation: [{ type: Input }],
-        scrolledIndexChange: [{ type: Output }],
-        _contentWrapper: [{ type: ViewChild, args: ['contentWrapper', { static: true },] }]
-    };
-    return CdkVirtualScrollViewport;
-})();
-export { CdkVirtualScrollViewport };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-scroll-viewport.js","sourceRoot":"","sources":["../../../../../../src/cdk/scrolling/virtual-scroll-viewport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directionality} from '@angular/cdk/bidi';\nimport {ListRange} from '@angular/cdk/collections';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {\n  animationFrameScheduler,\n  asapScheduler,\n  Observable,\n  Subject,\n  Observer,\n  Subscription,\n} from 'rxjs';\nimport {auditTime, startWith, takeUntil} from 'rxjs/operators';\nimport {ScrollDispatcher} from './scroll-dispatcher';\nimport {CdkScrollable, ExtendedScrollToOptions} from './scrollable';\nimport {CdkVirtualForOf} from './virtual-for-of';\nimport {VIRTUAL_SCROLL_STRATEGY, VirtualScrollStrategy} from './virtual-scroll-strategy';\nimport {ViewportRuler} from './viewport-ruler';\n\n/** Checks if the given ranges are equal. */\nfunction rangesEqual(r1: ListRange, r2: ListRange): boolean {\n  return r1.start == r2.start && r1.end == r2.end;\n}\n\n/**\n * Scheduler to be used for scroll events. Needs to fall back to\n * something that doesn't rely on requestAnimationFrame on environments\n * that don't support it (e.g. server-side rendering).\n */\nconst SCROLL_SCHEDULER =\n    typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;\n\n\n/** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */\n@Component({\n  selector: 'cdk-virtual-scroll-viewport',\n  templateUrl: 'virtual-scroll-viewport.html',\n  styleUrls: ['virtual-scroll-viewport.css'],\n  host: {\n    'class': 'cdk-virtual-scroll-viewport',\n    '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === \"horizontal\"',\n    '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== \"horizontal\"',\n  },\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [{\n    provide: CdkScrollable,\n    useExisting: CdkVirtualScrollViewport,\n  }]\n})\nexport class CdkVirtualScrollViewport extends CdkScrollable implements OnInit, OnDestroy {\n  /** Emits when the viewport is detached from a CdkVirtualForOf. */\n  private _detachedSubject = new Subject<void>();\n\n  /** Emits when the rendered range changes. */\n  private _renderedRangeSubject = new Subject<ListRange>();\n\n  /** The direction the viewport scrolls. */\n  @Input()\n  get orientation() {\n    return this._orientation;\n  }\n  set orientation(orientation: 'horizontal' | 'vertical') {\n    if (this._orientation !== orientation) {\n      this._orientation = orientation;\n      this._calculateSpacerSize();\n    }\n  }\n  private _orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\n  // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\n  // depending on how the strategy calculates the scrolled index, it may come at a cost to\n  // performance.\n  /** Emits when the index of the first element visible in the viewport changes. */\n  @Output() scrolledIndexChange: Observable<number> =\n      new Observable((observer: Observer<number>) =>\n        this._scrollStrategy.scrolledIndexChange.subscribe(index =>\n            Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));\n\n  /** The element that wraps the rendered content. */\n  @ViewChild('contentWrapper', {static: true}) _contentWrapper: ElementRef<HTMLElement>;\n\n  /** A stream that emits whenever the rendered range changes. */\n  renderedRangeStream: Observable<ListRange> = this._renderedRangeSubject.asObservable();\n\n  /**\n   * The total size of all content (in pixels), including content that is not currently rendered.\n   */\n  private _totalContentSize = 0;\n\n  /** A string representing the `style.width` property value to be used for the spacer element. */\n  _totalContentWidth = '';\n\n  /** A string representing the `style.height` property value to be used for the spacer element. */\n  _totalContentHeight = '';\n\n  /**\n   * The CSS transform applied to the rendered subset of items so that they appear within the bounds\n   * of the visible viewport.\n   */\n  private _renderedContentTransform: string;\n\n  /** The currently rendered range of indices. */\n  private _renderedRange: ListRange = {start: 0, end: 0};\n\n  /** The length of the data bound to this viewport (in number of items). */\n  private _dataLength = 0;\n\n  /** The size of the viewport (in pixels). */\n  private _viewportSize = 0;\n\n  /** the currently attached CdkVirtualForOf. */\n  private _forOf: CdkVirtualForOf<any> | null;\n\n  /** The last rendered content offset that was set. */\n  private _renderedContentOffset = 0;\n\n  /**\n   * Whether the last rendered content offset was to the end of the content (and therefore needs to\n   * be rewritten as an offset to the start of the content).\n   */\n  private _renderedContentOffsetNeedsRewrite = false;\n\n  /** Whether there is a pending change detection cycle. */\n  private _isChangeDetectionPending = false;\n\n  /** A list of functions to run after the next change detection cycle. */\n  private _runAfterChangeDetection: Function[] = [];\n\n  /** Subscription to changes in the viewport size. */\n  private _viewportChanges = Subscription.EMPTY;\n\n  constructor(public elementRef: ElementRef<HTMLElement>,\n              private _changeDetectorRef: ChangeDetectorRef,\n              ngZone: NgZone,\n              @Optional() @Inject(VIRTUAL_SCROLL_STRATEGY)\n                  private _scrollStrategy: VirtualScrollStrategy,\n              @Optional() dir: Directionality,\n              scrollDispatcher: ScrollDispatcher,\n              /**\n               * @deprecated `viewportRuler` parameter to become required.\n               * @breaking-change 11.0.0\n               */\n              @Optional() viewportRuler?: ViewportRuler) {\n    super(elementRef, scrollDispatcher, ngZone, dir);\n\n    if (!_scrollStrategy) {\n      throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n    }\n\n    // @breaking-change 11.0.0 Remove null check for `viewportRuler`.\n    if (viewportRuler) {\n      this._viewportChanges = viewportRuler.change().subscribe(() => {\n        this.checkViewportSize();\n      });\n    }\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    // It's still too early to measure the viewport at this point. Deferring with a promise allows\n    // the Viewport to be rendered with the correct size before we measure. We run this outside the\n    // zone to avoid causing more change detection cycles. We handle the change detection loop\n    // ourselves instead.\n    this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n      this._measureViewportSize();\n      this._scrollStrategy.attach(this);\n\n      this.elementScrolled()\n          .pipe(\n              // Start off with a fake scroll event so we properly detect our initial position.\n              startWith(null!),\n              // Collect multiple events into one until the next animation frame. This way if\n              // there are multiple scroll events in the same frame we only need to recheck\n              // our layout once.\n              auditTime(0, SCROLL_SCHEDULER))\n          .subscribe(() => this._scrollStrategy.onContentScrolled());\n\n      this._markChangeDetectionNeeded();\n    }));\n  }\n\n  ngOnDestroy() {\n    this.detach();\n    this._scrollStrategy.detach();\n\n    // Complete all subjects\n    this._renderedRangeSubject.complete();\n    this._detachedSubject.complete();\n    this._viewportChanges.unsubscribe();\n\n    super.ngOnDestroy();\n  }\n\n  /** Attaches a `CdkVirtualForOf` to this viewport. */\n  attach(forOf: CdkVirtualForOf<any>) {\n    if (this._forOf) {\n      throw Error('CdkVirtualScrollViewport is already attached.');\n    }\n\n    // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\n    // changes. Run outside the zone to avoid triggering change detection, since we're managing the\n    // change detection loop ourselves.\n    this.ngZone.runOutsideAngular(() => {\n      this._forOf = forOf;\n      this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe(data => {\n        const newLength = data.length;\n        if (newLength !== this._dataLength) {\n          this._dataLength = newLength;\n          this._scrollStrategy.onDataLengthChanged();\n        }\n        this._doChangeDetection();\n      });\n    });\n  }\n\n  /** Detaches the current `CdkVirtualForOf`. */\n  detach() {\n    this._forOf = null;\n    this._detachedSubject.next();\n  }\n\n  /** Gets the length of the data bound to this viewport (in number of items). */\n  getDataLength(): number {\n    return this._dataLength;\n  }\n\n  /** Gets the size of the viewport (in pixels). */\n  getViewportSize(): number {\n    return this._viewportSize;\n  }\n\n  // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\n  // cycle happens. I'm being careful to only call it after the render cycle is complete and before\n  // setting it to something else, but its error prone and should probably be split into\n  // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\n\n  /** Get the current rendered range of items. */\n  getRenderedRange(): ListRange {\n    return this._renderedRange;\n  }\n\n  /**\n   * Sets the total size of all content (in pixels), including content that is not currently\n   * rendered.\n   */\n  setTotalContentSize(size: number) {\n    if (this._totalContentSize !== size) {\n      this._totalContentSize = size;\n      this._calculateSpacerSize();\n      this._markChangeDetectionNeeded();\n    }\n  }\n\n  /** Sets the currently rendered range of indices. */\n  setRenderedRange(range: ListRange) {\n    if (!rangesEqual(this._renderedRange, range)) {\n      this._renderedRangeSubject.next(this._renderedRange = range);\n      this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());\n    }\n  }\n\n  /**\n   * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\n   */\n  getOffsetToRenderedContentStart(): number | null {\n    return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\n  }\n\n  /**\n   * Sets the offset from the start of the viewport to either the start or end of the rendered data\n   * (in pixels).\n   */\n  setRenderedContentOffset(offset: number, to: 'to-start' | 'to-end' = 'to-start') {\n    // For a horizontal viewport in a right-to-left language we need to translate along the x-axis\n    // in the negative direction.\n    const isRtl = this.dir && this.dir.value == 'rtl';\n    const isHorizontal = this.orientation == 'horizontal';\n    const axis = isHorizontal ? 'X' : 'Y';\n    const axisDirection = isHorizontal && isRtl ? -1 : 1;\n    let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;\n    this._renderedContentOffset = offset;\n    if (to === 'to-end') {\n      transform += ` translate${axis}(-100%)`;\n      // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise\n      // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would\n      // expand upward).\n      this._renderedContentOffsetNeedsRewrite = true;\n    }\n    if (this._renderedContentTransform != transform) {\n      // We know this value is safe because we parse `offset` with `Number()` before passing it\n      // into the string.\n      this._renderedContentTransform = transform;\n      this._markChangeDetectionNeeded(() => {\n        if (this._renderedContentOffsetNeedsRewrite) {\n          this._renderedContentOffset -= this.measureRenderedContentSize();\n          this._renderedContentOffsetNeedsRewrite = false;\n          this.setRenderedContentOffset(this._renderedContentOffset);\n        } else {\n          this._scrollStrategy.onRenderedOffsetChanged();\n        }\n      });\n    }\n  }\n\n  /**\n   * Scrolls to the given offset from the start of the viewport. Please note that this is not always\n   * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\n   * direction, this would be the equivalent of setting a fictional `scrollRight` property.\n   * @param offset The offset to scroll to.\n   * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n   */\n  scrollToOffset(offset: number, behavior: ScrollBehavior = 'auto') {\n    const options: ExtendedScrollToOptions = {behavior};\n    if (this.orientation === 'horizontal') {\n      options.start = offset;\n    } else {\n      options.top = offset;\n    }\n    this.scrollTo(options);\n  }\n\n  /**\n   * Scrolls to the offset for the given index.\n   * @param index The index of the element to scroll to.\n   * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n   */\n  scrollToIndex(index: number,  behavior: ScrollBehavior = 'auto') {\n    this._scrollStrategy.scrollToIndex(index, behavior);\n  }\n\n  /**\n   * Gets the current scroll offset from the start of the viewport (in pixels).\n   * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\n   *     in horizontal mode.\n   */\n  measureScrollOffset(from?: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number {\n    return from ?\n      super.measureScrollOffset(from) :\n      super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');\n  }\n\n  /** Measure the combined size of all of the rendered items. */\n  measureRenderedContentSize(): number {\n    const contentEl = this._contentWrapper.nativeElement;\n    return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;\n  }\n\n  /**\n   * Measure the total combined size of the given range. Throws if the range includes items that are\n   * not rendered.\n   */\n  measureRangeSize(range: ListRange): number {\n    if (!this._forOf) {\n      return 0;\n    }\n    return this._forOf.measureRangeSize(range, this.orientation);\n  }\n\n  /** Update the viewport dimensions and re-render. */\n  checkViewportSize() {\n    // TODO: Cleanup later when add logic for handling content resize\n    this._measureViewportSize();\n    this._scrollStrategy.onDataLengthChanged();\n  }\n\n  /** Measure the viewport size. */\n  private _measureViewportSize() {\n    const viewportEl = this.elementRef.nativeElement;\n    this._viewportSize = this.orientation === 'horizontal' ?\n        viewportEl.clientWidth : viewportEl.clientHeight;\n  }\n\n  /** Queue up change detection to run. */\n  private _markChangeDetectionNeeded(runAfter?: Function) {\n    if (runAfter) {\n      this._runAfterChangeDetection.push(runAfter);\n    }\n\n    // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\n    // properties sequentially we only have to run `_doChangeDetection` once at the end.\n    if (!this._isChangeDetectionPending) {\n      this._isChangeDetectionPending = true;\n      this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n        this._doChangeDetection();\n      }));\n    }\n  }\n\n  /** Run change detection. */\n  private _doChangeDetection() {\n    this._isChangeDetectionPending = false;\n\n    // Apply the content transform. The transform can't be set via an Angular binding because\n    // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\n    // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\n    // the `Number` function first to coerce it to a numeric value.\n    this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;\n    // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\n    // from the root, since the repeated items are content projected in. Calling `detectChanges`\n    // instead does not properly check the projected content.\n    this.ngZone.run(() => this._changeDetectorRef.markForCheck());\n\n    const runAfterChangeDetection = this._runAfterChangeDetection;\n    this._runAfterChangeDetection = [];\n    for (const fn of runAfterChangeDetection) {\n      fn();\n    }\n  }\n\n  /** Calculates the `style.width` and `style.height` for the spacer element. */\n  private _calculateSpacerSize() {\n    this._totalContentHeight =\n        this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;\n    this._totalContentWidth =\n        this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';\n  }\n}\n"]}
+    /** Calculates the `style.width` and `style.height` for the spacer element. */
+    _calculateSpacerSize() {
+        this._totalContentHeight =
+            this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;
+        this._totalContentWidth =
+            this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';
+    }
+}
+CdkVirtualScrollViewport.decorators = [
+    { type: Component, args: [{
+                selector: 'cdk-virtual-scroll-viewport',
+                template: "<!--\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\n  position.\n-->\n<div #contentWrapper class=\"cdk-virtual-scroll-content-wrapper\">\n  <ng-content></ng-content>\n</div>\n<!--\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\n  so that the scrollbar captures the size of the entire data set.\n-->\n<div class=\"cdk-virtual-scroll-spacer\"\n     [style.width]=\"_totalContentWidth\" [style.height]=\"_totalContentHeight\"></div>\n",
+                host: {
+                    'class': 'cdk-virtual-scroll-viewport',
+                    '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === "horizontal"',
+                    '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== "horizontal"',
+                },
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [{
+                        provide: CdkScrollable,
+                        useExisting: CdkVirtualScrollViewport,
+                    }],
+                styles: ["cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"]
+            },] }
+];
+CdkVirtualScrollViewport.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ChangeDetectorRef },
+    { type: NgZone },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [VIRTUAL_SCROLL_STRATEGY,] }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: ScrollDispatcher },
+    { type: ViewportRuler, decorators: [{ type: Optional }] }
+];
+CdkVirtualScrollViewport.propDecorators = {
+    orientation: [{ type: Input }],
+    scrolledIndexChange: [{ type: Output }],
+    _contentWrapper: [{ type: ViewChild, args: ['contentWrapper', { static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-scroll-viewport.js","sourceRoot":"","sources":["../../../../../../src/cdk/scrolling/virtual-scroll-viewport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directionality} from '@angular/cdk/bidi';\nimport {ListRange} from '@angular/cdk/collections';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {\n  animationFrameScheduler,\n  asapScheduler,\n  Observable,\n  Subject,\n  Observer,\n  Subscription,\n} from 'rxjs';\nimport {auditTime, startWith, takeUntil} from 'rxjs/operators';\nimport {ScrollDispatcher} from './scroll-dispatcher';\nimport {CdkScrollable, ExtendedScrollToOptions} from './scrollable';\nimport {VIRTUAL_SCROLL_STRATEGY, VirtualScrollStrategy} from './virtual-scroll-strategy';\nimport {ViewportRuler} from './viewport-ruler';\nimport {CdkVirtualScrollRepeater} from './virtual-scroll-repeater';\n\n/** Checks if the given ranges are equal. */\nfunction rangesEqual(r1: ListRange, r2: ListRange): boolean {\n  return r1.start == r2.start && r1.end == r2.end;\n}\n\n/**\n * Scheduler to be used for scroll events. Needs to fall back to\n * something that doesn't rely on requestAnimationFrame on environments\n * that don't support it (e.g. server-side rendering).\n */\nconst SCROLL_SCHEDULER =\n    typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;\n\n\n/** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */\n@Component({\n  selector: 'cdk-virtual-scroll-viewport',\n  templateUrl: 'virtual-scroll-viewport.html',\n  styleUrls: ['virtual-scroll-viewport.css'],\n  host: {\n    'class': 'cdk-virtual-scroll-viewport',\n    '[class.cdk-virtual-scroll-orientation-horizontal]': 'orientation === \"horizontal\"',\n    '[class.cdk-virtual-scroll-orientation-vertical]': 'orientation !== \"horizontal\"',\n  },\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [{\n    provide: CdkScrollable,\n    useExisting: CdkVirtualScrollViewport,\n  }]\n})\nexport class CdkVirtualScrollViewport extends CdkScrollable implements OnInit, OnDestroy {\n  /** Emits when the viewport is detached from a CdkVirtualForOf. */\n  private _detachedSubject = new Subject<void>();\n\n  /** Emits when the rendered range changes. */\n  private _renderedRangeSubject = new Subject<ListRange>();\n\n  /** The direction the viewport scrolls. */\n  @Input()\n  get orientation() {\n    return this._orientation;\n  }\n  set orientation(orientation: 'horizontal' | 'vertical') {\n    if (this._orientation !== orientation) {\n      this._orientation = orientation;\n      this._calculateSpacerSize();\n    }\n  }\n  private _orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\n  // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\n  // depending on how the strategy calculates the scrolled index, it may come at a cost to\n  // performance.\n  /** Emits when the index of the first element visible in the viewport changes. */\n  @Output() scrolledIndexChange: Observable<number> =\n      new Observable((observer: Observer<number>) =>\n        this._scrollStrategy.scrolledIndexChange.subscribe(index =>\n            Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));\n\n  /** The element that wraps the rendered content. */\n  @ViewChild('contentWrapper', {static: true}) _contentWrapper: ElementRef<HTMLElement>;\n\n  /** A stream that emits whenever the rendered range changes. */\n  renderedRangeStream: Observable<ListRange> = this._renderedRangeSubject.asObservable();\n\n  /**\n   * The total size of all content (in pixels), including content that is not currently rendered.\n   */\n  private _totalContentSize = 0;\n\n  /** A string representing the `style.width` property value to be used for the spacer element. */\n  _totalContentWidth = '';\n\n  /** A string representing the `style.height` property value to be used for the spacer element. */\n  _totalContentHeight = '';\n\n  /**\n   * The CSS transform applied to the rendered subset of items so that they appear within the bounds\n   * of the visible viewport.\n   */\n  private _renderedContentTransform: string;\n\n  /** The currently rendered range of indices. */\n  private _renderedRange: ListRange = {start: 0, end: 0};\n\n  /** The length of the data bound to this viewport (in number of items). */\n  private _dataLength = 0;\n\n  /** The size of the viewport (in pixels). */\n  private _viewportSize = 0;\n\n  /** the currently attached CdkVirtualScrollRepeater. */\n  private _forOf: CdkVirtualScrollRepeater<any> | null;\n\n  /** The last rendered content offset that was set. */\n  private _renderedContentOffset = 0;\n\n  /**\n   * Whether the last rendered content offset was to the end of the content (and therefore needs to\n   * be rewritten as an offset to the start of the content).\n   */\n  private _renderedContentOffsetNeedsRewrite = false;\n\n  /** Whether there is a pending change detection cycle. */\n  private _isChangeDetectionPending = false;\n\n  /** A list of functions to run after the next change detection cycle. */\n  private _runAfterChangeDetection: Function[] = [];\n\n  /** Subscription to changes in the viewport size. */\n  private _viewportChanges = Subscription.EMPTY;\n\n  constructor(public elementRef: ElementRef<HTMLElement>,\n              private _changeDetectorRef: ChangeDetectorRef,\n              ngZone: NgZone,\n              @Optional() @Inject(VIRTUAL_SCROLL_STRATEGY)\n                  private _scrollStrategy: VirtualScrollStrategy,\n              @Optional() dir: Directionality,\n              scrollDispatcher: ScrollDispatcher,\n              /**\n               * @deprecated `viewportRuler` parameter to become required.\n               * @breaking-change 11.0.0\n               */\n              @Optional() viewportRuler?: ViewportRuler) {\n    super(elementRef, scrollDispatcher, ngZone, dir);\n\n    if (!_scrollStrategy) {\n      throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n    }\n\n    // @breaking-change 11.0.0 Remove null check for `viewportRuler`.\n    if (viewportRuler) {\n      this._viewportChanges = viewportRuler.change().subscribe(() => {\n        this.checkViewportSize();\n      });\n    }\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    // It's still too early to measure the viewport at this point. Deferring with a promise allows\n    // the Viewport to be rendered with the correct size before we measure. We run this outside the\n    // zone to avoid causing more change detection cycles. We handle the change detection loop\n    // ourselves instead.\n    this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n      this._measureViewportSize();\n      this._scrollStrategy.attach(this);\n\n      this.elementScrolled()\n          .pipe(\n              // Start off with a fake scroll event so we properly detect our initial position.\n              startWith(null!),\n              // Collect multiple events into one until the next animation frame. This way if\n              // there are multiple scroll events in the same frame we only need to recheck\n              // our layout once.\n              auditTime(0, SCROLL_SCHEDULER))\n          .subscribe(() => this._scrollStrategy.onContentScrolled());\n\n      this._markChangeDetectionNeeded();\n    }));\n  }\n\n  ngOnDestroy() {\n    this.detach();\n    this._scrollStrategy.detach();\n\n    // Complete all subjects\n    this._renderedRangeSubject.complete();\n    this._detachedSubject.complete();\n    this._viewportChanges.unsubscribe();\n\n    super.ngOnDestroy();\n  }\n\n  /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */\n  attach(forOf: CdkVirtualScrollRepeater<any>) {\n    if (this._forOf) {\n      throw Error('CdkVirtualScrollViewport is already attached.');\n    }\n\n    // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\n    // changes. Run outside the zone to avoid triggering change detection, since we're managing the\n    // change detection loop ourselves.\n    this.ngZone.runOutsideAngular(() => {\n      this._forOf = forOf;\n      this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe(data => {\n        const newLength = data.length;\n        if (newLength !== this._dataLength) {\n          this._dataLength = newLength;\n          this._scrollStrategy.onDataLengthChanged();\n        }\n        this._doChangeDetection();\n      });\n    });\n  }\n\n  /** Detaches the current `CdkVirtualForOf`. */\n  detach() {\n    this._forOf = null;\n    this._detachedSubject.next();\n  }\n\n  /** Gets the length of the data bound to this viewport (in number of items). */\n  getDataLength(): number {\n    return this._dataLength;\n  }\n\n  /** Gets the size of the viewport (in pixels). */\n  getViewportSize(): number {\n    return this._viewportSize;\n  }\n\n  // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\n  // cycle happens. I'm being careful to only call it after the render cycle is complete and before\n  // setting it to something else, but its error prone and should probably be split into\n  // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\n\n  /** Get the current rendered range of items. */\n  getRenderedRange(): ListRange {\n    return this._renderedRange;\n  }\n\n  /**\n   * Sets the total size of all content (in pixels), including content that is not currently\n   * rendered.\n   */\n  setTotalContentSize(size: number) {\n    if (this._totalContentSize !== size) {\n      this._totalContentSize = size;\n      this._calculateSpacerSize();\n      this._markChangeDetectionNeeded();\n    }\n  }\n\n  /** Sets the currently rendered range of indices. */\n  setRenderedRange(range: ListRange) {\n    if (!rangesEqual(this._renderedRange, range)) {\n      this._renderedRangeSubject.next(this._renderedRange = range);\n      this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());\n    }\n  }\n\n  /**\n   * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\n   */\n  getOffsetToRenderedContentStart(): number | null {\n    return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\n  }\n\n  /**\n   * Sets the offset from the start of the viewport to either the start or end of the rendered data\n   * (in pixels).\n   */\n  setRenderedContentOffset(offset: number, to: 'to-start' | 'to-end' = 'to-start') {\n    // For a horizontal viewport in a right-to-left language we need to translate along the x-axis\n    // in the negative direction.\n    const isRtl = this.dir && this.dir.value == 'rtl';\n    const isHorizontal = this.orientation == 'horizontal';\n    const axis = isHorizontal ? 'X' : 'Y';\n    const axisDirection = isHorizontal && isRtl ? -1 : 1;\n    let transform = `translate${axis}(${Number(axisDirection * offset)}px)`;\n    this._renderedContentOffset = offset;\n    if (to === 'to-end') {\n      transform += ` translate${axis}(-100%)`;\n      // The viewport should rewrite this as a `to-start` offset on the next render cycle. Otherwise\n      // elements will appear to expand in the wrong direction (e.g. `mat-expansion-panel` would\n      // expand upward).\n      this._renderedContentOffsetNeedsRewrite = true;\n    }\n    if (this._renderedContentTransform != transform) {\n      // We know this value is safe because we parse `offset` with `Number()` before passing it\n      // into the string.\n      this._renderedContentTransform = transform;\n      this._markChangeDetectionNeeded(() => {\n        if (this._renderedContentOffsetNeedsRewrite) {\n          this._renderedContentOffset -= this.measureRenderedContentSize();\n          this._renderedContentOffsetNeedsRewrite = false;\n          this.setRenderedContentOffset(this._renderedContentOffset);\n        } else {\n          this._scrollStrategy.onRenderedOffsetChanged();\n        }\n      });\n    }\n  }\n\n  /**\n   * Scrolls to the given offset from the start of the viewport. Please note that this is not always\n   * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\n   * direction, this would be the equivalent of setting a fictional `scrollRight` property.\n   * @param offset The offset to scroll to.\n   * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n   */\n  scrollToOffset(offset: number, behavior: ScrollBehavior = 'auto') {\n    const options: ExtendedScrollToOptions = {behavior};\n    if (this.orientation === 'horizontal') {\n      options.start = offset;\n    } else {\n      options.top = offset;\n    }\n    this.scrollTo(options);\n  }\n\n  /**\n   * Scrolls to the offset for the given index.\n   * @param index The index of the element to scroll to.\n   * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n   */\n  scrollToIndex(index: number,  behavior: ScrollBehavior = 'auto') {\n    this._scrollStrategy.scrollToIndex(index, behavior);\n  }\n\n  /**\n   * Gets the current scroll offset from the start of the viewport (in pixels).\n   * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\n   *     in horizontal mode.\n   */\n  measureScrollOffset(from?: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number {\n    return from ?\n      super.measureScrollOffset(from) :\n      super.measureScrollOffset(this.orientation === 'horizontal' ? 'start' : 'top');\n  }\n\n  /** Measure the combined size of all of the rendered items. */\n  measureRenderedContentSize(): number {\n    const contentEl = this._contentWrapper.nativeElement;\n    return this.orientation === 'horizontal' ? contentEl.offsetWidth : contentEl.offsetHeight;\n  }\n\n  /**\n   * Measure the total combined size of the given range. Throws if the range includes items that are\n   * not rendered.\n   */\n  measureRangeSize(range: ListRange): number {\n    if (!this._forOf) {\n      return 0;\n    }\n    return this._forOf.measureRangeSize(range, this.orientation);\n  }\n\n  /** Update the viewport dimensions and re-render. */\n  checkViewportSize() {\n    // TODO: Cleanup later when add logic for handling content resize\n    this._measureViewportSize();\n    this._scrollStrategy.onDataLengthChanged();\n  }\n\n  /** Measure the viewport size. */\n  private _measureViewportSize() {\n    const viewportEl = this.elementRef.nativeElement;\n    this._viewportSize = this.orientation === 'horizontal' ?\n        viewportEl.clientWidth : viewportEl.clientHeight;\n  }\n\n  /** Queue up change detection to run. */\n  private _markChangeDetectionNeeded(runAfter?: Function) {\n    if (runAfter) {\n      this._runAfterChangeDetection.push(runAfter);\n    }\n\n    // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\n    // properties sequentially we only have to run `_doChangeDetection` once at the end.\n    if (!this._isChangeDetectionPending) {\n      this._isChangeDetectionPending = true;\n      this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {\n        this._doChangeDetection();\n      }));\n    }\n  }\n\n  /** Run change detection. */\n  private _doChangeDetection() {\n    this._isChangeDetectionPending = false;\n\n    // Apply the content transform. The transform can't be set via an Angular binding because\n    // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\n    // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\n    // the `Number` function first to coerce it to a numeric value.\n    this._contentWrapper.nativeElement.style.transform = this._renderedContentTransform;\n    // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\n    // from the root, since the repeated items are content projected in. Calling `detectChanges`\n    // instead does not properly check the projected content.\n    this.ngZone.run(() => this._changeDetectorRef.markForCheck());\n\n    const runAfterChangeDetection = this._runAfterChangeDetection;\n    this._runAfterChangeDetection = [];\n    for (const fn of runAfterChangeDetection) {\n      fn();\n    }\n  }\n\n  /** Calculates the `style.width` and `style.height` for the spacer element. */\n  private _calculateSpacerSize() {\n    this._totalContentHeight =\n        this.orientation === 'horizontal' ? '' : `${this._totalContentSize}px`;\n    this._totalContentWidth =\n        this.orientation === 'horizontal' ? `${this._totalContentSize}px` : '';\n  }\n}\n"]}