ahcdashboardui/node_modules/@angular/cdk/esm2015/scrolling/virtual-scroll-viewport.js

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directionality } from '@angular/cdk/bidi';
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Inject, Input, NgZone, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core';
import { animationFrameScheduler, asapScheduler, Observable, Subject, Subscription, } from 'rxjs';
import { auditTime, startWith, takeUntil } from 'rxjs/operators';
import { ScrollDispatcher } from './scroll-dispatcher';
import { CdkScrollable } from './scrollable';
import { VIRTUAL_SCROLL_STRATEGY } from './virtual-scroll-strategy';
import { ViewportRuler } from './viewport-ruler';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
/** Checks if the given ranges are equal. */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from '@angular/cdk/bidi';
import * as ɵngcc2 from './scroll-dispatcher';
import * as ɵngcc3 from './viewport-ruler';

const _c0 = ["contentWrapper"];
const _c1 = ["*"];
function rangesEqual(r1, r2) {
    return r1.start == r2.start && r1.end == r2.end;
}
/**
 * Scheduler to be used for scroll events. Needs to fall back to
 * something that doesn't rely on requestAnimationFrame on environments
 * that don't support it (e.g. server-side rendering).
 */
const SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;
/** A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`. */
export class CdkVirtualScrollViewport extends CdkScrollable {
    constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, 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';
        this._appendOnly = false;
        // 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;
        /**
         * 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 && (typeof ngDevMode === 'undefined' || ngDevMode)) {
            throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');
        }
        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();
        }
    }
    /**
     * Whether rendered items should persist in the DOM after scrolling out of view. By default, items
     * will be removed.
     */
    get appendOnly() {
        return this._appendOnly;
    }
    set appendOnly(value) {
        this._appendOnly = coerceBooleanProperty(value);
    }
    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 && (typeof ngDevMode === 'undefined' || ngDevMode)) {
            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;
    }
    /**
     * 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();
        }
    }
    /** Sets the currently rendered range of indices. */
    setRenderedRange(range) {
        if (!rangesEqual(this._renderedRange, range)) {
            if (this.appendOnly) {
                range = { start: 0, end: Math.max(this._renderedRange.end, range.end) };
            }
            this._renderedRangeSubject.next(this._renderedRange = range);
            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());
        }
    }
    /**
     * 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;
        }
        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();
                }
            });
        }
    }
    /**
     * 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);
    }
    /**
     * 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;
        }
        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);
        }
        // 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();
            }));
        }
    }
    /** 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();
        }
    }
    /** 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.ɵfac = function CdkVirtualScrollViewport_Factory(t) { return new (t || CdkVirtualScrollViewport)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(VIRTUAL_SCROLL_STRATEGY, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.ScrollDispatcher), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.ViewportRuler)); };
CdkVirtualScrollViewport.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: CdkVirtualScrollViewport, selectors: [["cdk-virtual-scroll-viewport"]], viewQuery: function CdkVirtualScrollViewport_Query(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵviewQuery(_c0, 7);
    } if (rf & 2) {
        let _t;
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._contentWrapper = _t.first);
    } }, hostAttrs: [1, "cdk-virtual-scroll-viewport"], hostVars: 4, hostBindings: function CdkVirtualScrollViewport_HostBindings(rf, ctx) { if (rf & 2) {
        ɵngcc0.ɵɵclassProp("cdk-virtual-scroll-orientation-horizontal", ctx.orientation === "horizontal")("cdk-virtual-scroll-orientation-vertical", ctx.orientation !== "horizontal");
    } }, inputs: { orientation: "orientation", appendOnly: "appendOnly" }, outputs: { scrolledIndexChange: "scrolledIndexChange" }, features: [ɵngcc0.ɵɵProvidersFeature([{
                provide: CdkScrollable,
                useExisting: CdkVirtualScrollViewport
            }]), ɵngcc0.ɵɵInheritDefinitionFeature], ngContentSelectors: _c1, decls: 4, vars: 4, consts: [[1, "cdk-virtual-scroll-content-wrapper"], ["contentWrapper", ""], [1, "cdk-virtual-scroll-spacer"]], template: function CdkVirtualScrollViewport_Template(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵprojectionDef();
        ɵngcc0.ɵɵelementStart(0, "div", 0, 1);
        ɵngcc0.ɵɵprojection(2);
        ɵngcc0.ɵɵelementEnd();
        ɵngcc0.ɵɵelement(3, "div", 2);
    } if (rf & 2) {
        ɵngcc0.ɵɵadvance(3);
        ɵngcc0.ɵɵstyleProp("width", ctx._totalContentWidth)("height", ctx._totalContentHeight);
    } }, 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"], encapsulation: 2, changeDetection: 0 });
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 }
];
CdkVirtualScrollViewport.propDecorators = {
    orientation: [{ type: Input }],
    appendOnly: [{ type: Input }],
    scrolledIndexChange: [{ type: Output }],
    _contentWrapper: [{ type: ViewChild, args: ['contentWrapper', { static: true },] }]
};
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkVirtualScrollViewport, [{
        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"]
            }]
    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [VIRTUAL_SCROLL_STRATEGY]
            }] }, { type: ɵngcc1.Directionality, decorators: [{
                type: Optional
            }] }, { type: ɵngcc2.ScrollDispatcher }, { type: ɵngcc3.ViewportRuler }]; }, { scrolledIndexChange: [{
            type: Output
        }], orientation: [{
            type: Input
        }], appendOnly: [{
            type: Input
        }], _contentWrapper: [{
            type: ViewChild,
            args: ['contentWrapper', { static: true }]
        }] }); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"virtual-scroll-viewport.js","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';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\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 readonly _detachedSubject = new Subject<void>();\n\n  /** Emits when the rendered range changes. */\n  private readonly _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  /**\n   * Whether rendered items should persist in the DOM after scrolling out of view. By default, items\n   * will be removed.\n   */\n  @Input()\n  get appendOnly(): boolean {\n    return this._appendOnly;\n  }\n  set appendOnly(value: boolean) {\n    this._appendOnly = coerceBooleanProperty(value);\n  }\n  private _appendOnly = false;\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()\n  readonly scrolledIndexChange: Observable<number> = new Observable(\n      (observer: Observer<number>) => this._scrollStrategy.scrolledIndexChange.subscribe(\n          index => 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  readonly renderedRangeStream: Observable<ListRange> = this._renderedRangeSubject;\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 override 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              viewportRuler: ViewportRuler) {\n    super(elementRef, scrollDispatcher, ngZone, dir);\n\n    if (!_scrollStrategy && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n    }\n\n    this._viewportChanges = viewportRuler.change().subscribe(() => {\n      this.checkViewportSize();\n    });\n  }\n\n  override 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  override 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 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\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      if (this.appendOnly) {\n        range = {start: 0, end: Math.max(this._renderedRange.end, range.end)};\n      }\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  override measureScrollOffset(\n      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  static ngAcceptInputType_appendOnly: BooleanInput;\n}\n"]}