ahcdashboardui/node_modules/@angular/cdk/esm2015/scrolling/scroll-dispatcher.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 { coerceElement } from '@angular/cdk/coercion';
import { Platform } from '@angular/cdk/platform';
import { Injectable, NgZone, Optional, Inject } from '@angular/core';
import { fromEvent, of as observableOf, Subject, Observable } from 'rxjs';
import { auditTime, filter } from 'rxjs/operators';
import { DOCUMENT } from '@angular/common';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/platform";
import * as i2 from "@angular/common";
/** Time in ms to throttle the scrolling events by default. */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from '@angular/cdk/platform';
export const DEFAULT_SCROLL_TIME = 20;
/**
 * Service contained all registered Scrollable references and emits an event when any one of the
 * Scrollable references emit a scrolled event.
 */
export class ScrollDispatcher {
    constructor(_ngZone, _platform, document) {
        this._ngZone = _ngZone;
        this._platform = _platform;
        /** Subject for notifying that a registered scrollable reference element has been scrolled. */
        this._scrolled = new Subject();
        /** Keeps track of the global `scroll` and `resize` subscriptions. */
        this._globalSubscription = null;
        /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
        this._scrolledCount = 0;
        /**
         * Map of all the scrollable references that are registered with the service and their
         * scroll event subscriptions.
         */
        this.scrollContainers = new Map();
        this._document = document;
    }
    /**
     * Registers a scrollable instance with the service and listens for its scrolled events. When the
     * scrollable is scrolled, the service emits the event to its scrolled observable.
     * @param scrollable Scrollable instance to be registered.
     */
    register(scrollable) {
        if (!this.scrollContainers.has(scrollable)) {
            this.scrollContainers.set(scrollable, scrollable.elementScrolled()
                .subscribe(() => this._scrolled.next(scrollable)));
        }
    }
    /**
     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
     * @param scrollable Scrollable instance to be deregistered.
     */
    deregister(scrollable) {
        const scrollableReference = this.scrollContainers.get(scrollable);
        if (scrollableReference) {
            scrollableReference.unsubscribe();
            this.scrollContainers.delete(scrollable);
        }
    }
    /**
     * Returns an observable that emits an event whenever any of the registered Scrollable
     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
     * to override the default "throttle" time.
     *
     * **Note:** in order to avoid hitting change detection for every scroll event,
     * all of the events emitted from this stream will be run outside the Angular zone.
     * If you need to update any data bindings as a result of a scroll event, you have
     * to run the callback using `NgZone.run`.
     */
    scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME) {
        if (!this._platform.isBrowser) {
            return observableOf();
        }
        return new Observable((observer) => {
            if (!this._globalSubscription) {
                this._addGlobalListener();
            }
            // In the case of a 0ms delay, use an observable without auditTime
            // since it does add a perceptible delay in processing overhead.
            const subscription = auditTimeInMs > 0 ?
                this._scrolled.pipe(auditTime(auditTimeInMs)).subscribe(observer) :
                this._scrolled.subscribe(observer);
            this._scrolledCount++;
            return () => {
                subscription.unsubscribe();
                this._scrolledCount--;
                if (!this._scrolledCount) {
                    this._removeGlobalListener();
                }
            };
        });
    }
    ngOnDestroy() {
        this._removeGlobalListener();
        this.scrollContainers.forEach((_, container) => this.deregister(container));
        this._scrolled.complete();
    }
    /**
     * Returns an observable that emits whenever any of the
     * scrollable ancestors of an element are scrolled.
     * @param elementOrElementRef Element whose ancestors to listen for.
     * @param auditTimeInMs Time to throttle the scroll events.
     */
    ancestorScrolled(elementOrElementRef, auditTimeInMs) {
        const ancestors = this.getAncestorScrollContainers(elementOrElementRef);
        return this.scrolled(auditTimeInMs).pipe(filter(target => {
            return !target || ancestors.indexOf(target) > -1;
        }));
    }
    /** Returns all registered Scrollables that contain the provided element. */
    getAncestorScrollContainers(elementOrElementRef) {
        const scrollingContainers = [];
        this.scrollContainers.forEach((_subscription, scrollable) => {
            if (this._scrollableContainsElement(scrollable, elementOrElementRef)) {
                scrollingContainers.push(scrollable);
            }
        });
        return scrollingContainers;
    }
    /** Use defaultView of injected document if available or fallback to global window reference */
    _getWindow() {
        return this._document.defaultView || window;
    }
    /** Returns true if the element is contained within the provided Scrollable. */
    _scrollableContainsElement(scrollable, elementOrElementRef) {
        let element = coerceElement(elementOrElementRef);
        let scrollableElement = scrollable.getElementRef().nativeElement;
        // Traverse through the element parents until we reach null, checking if any of the elements
        // are the scrollable's element.
        do {
            if (element == scrollableElement) {
                return true;
            }
        } while (element = element.parentElement);
        return false;
    }
    /** Sets up the global scroll listeners. */
    _addGlobalListener() {
        this._globalSubscription = this._ngZone.runOutsideAngular(() => {
            const window = this._getWindow();
            return fromEvent(window.document, 'scroll').subscribe(() => this._scrolled.next());
        });
    }
    /** Cleans up the global scroll listener. */
    _removeGlobalListener() {
        if (this._globalSubscription) {
            this._globalSubscription.unsubscribe();
            this._globalSubscription = null;
        }
    }
}
ScrollDispatcher.ɵfac = function ScrollDispatcher_Factory(t) { return new (t || ScrollDispatcher)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(ɵngcc1.Platform), ɵngcc0.ɵɵinject(DOCUMENT, 8)); };
ScrollDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollDispatcher_Factory() { return new ScrollDispatcher(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i2.DOCUMENT, 8)); }, token: ScrollDispatcher, providedIn: "root" });
ScrollDispatcher.ctorParameters = () => [
    { type: NgZone },
    { type: Platform },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(ScrollDispatcher, [{
        type: Injectable,
        args: [{ providedIn: 'root' }]
    }], function () { return [{ type: ɵngcc0.NgZone }, { type: ɵngcc1.Platform }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [DOCUMENT]
            }] }]; }, null); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"scroll-dispatcher.js","sources":["../../../../../../src/cdk/scrolling/scroll-dispatcher.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 {coerceElement} from '@angular/cdk/coercion';\nimport {Platform} from '@angular/cdk/platform';\nimport {ElementRef, Injectable, NgZone, OnDestroy, Optional, Inject} from '@angular/core';\nimport {fromEvent, of as observableOf, Subject, Subscription, Observable, Observer} from 'rxjs';\nimport {auditTime, filter} from 'rxjs/operators';\nimport {CdkScrollable} from './scrollable';\nimport {DOCUMENT} from '@angular/common';\n\n/** Time in ms to throttle the scrolling events by default. */\nexport const DEFAULT_SCROLL_TIME = 20;\n\n/**\n * Service contained all registered Scrollable references and emits an event when any one of the\n * Scrollable references emit a scrolled event.\n */\n@Injectable({providedIn: 'root'})\nexport class ScrollDispatcher implements OnDestroy {\n  /** Used to reference correct document/window */\n  protected _document: Document;\n\n  constructor(private _ngZone: NgZone,\n              private _platform: Platform,\n              @Optional() @Inject(DOCUMENT) document: any) {\n    this._document = document;\n  }\n\n  /** Subject for notifying that a registered scrollable reference element has been scrolled. */\n  private readonly _scrolled = new Subject<CdkScrollable|void>();\n\n  /** Keeps track of the global `scroll` and `resize` subscriptions. */\n  _globalSubscription: Subscription | null = null;\n\n  /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */\n  private _scrolledCount = 0;\n\n  /**\n   * Map of all the scrollable references that are registered with the service and their\n   * scroll event subscriptions.\n   */\n  scrollContainers: Map<CdkScrollable, Subscription> = new Map();\n\n  /**\n   * Registers a scrollable instance with the service and listens for its scrolled events. When the\n   * scrollable is scrolled, the service emits the event to its scrolled observable.\n   * @param scrollable Scrollable instance to be registered.\n   */\n  register(scrollable: CdkScrollable): void {\n    if (!this.scrollContainers.has(scrollable)) {\n      this.scrollContainers.set(scrollable, scrollable.elementScrolled()\n          .subscribe(() => this._scrolled.next(scrollable)));\n    }\n  }\n\n  /**\n   * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.\n   * @param scrollable Scrollable instance to be deregistered.\n   */\n  deregister(scrollable: CdkScrollable): void {\n    const scrollableReference = this.scrollContainers.get(scrollable);\n\n    if (scrollableReference) {\n      scrollableReference.unsubscribe();\n      this.scrollContainers.delete(scrollable);\n    }\n  }\n\n  /**\n   * Returns an observable that emits an event whenever any of the registered Scrollable\n   * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\n   * to override the default \"throttle\" time.\n   *\n   * **Note:** in order to avoid hitting change detection for every scroll event,\n   * all of the events emitted from this stream will be run outside the Angular zone.\n   * If you need to update any data bindings as a result of a scroll event, you have\n   * to run the callback using `NgZone.run`.\n   */\n  scrolled(auditTimeInMs: number = DEFAULT_SCROLL_TIME): Observable<CdkScrollable|void> {\n    if (!this._platform.isBrowser) {\n      return observableOf<void>();\n    }\n\n    return new Observable((observer: Observer<CdkScrollable|void>) => {\n      if (!this._globalSubscription) {\n        this._addGlobalListener();\n      }\n\n      // In the case of a 0ms delay, use an observable without auditTime\n      // since it does add a perceptible delay in processing overhead.\n      const subscription = auditTimeInMs > 0 ?\n        this._scrolled.pipe(auditTime(auditTimeInMs)).subscribe(observer) :\n        this._scrolled.subscribe(observer);\n\n      this._scrolledCount++;\n\n      return () => {\n        subscription.unsubscribe();\n        this._scrolledCount--;\n\n        if (!this._scrolledCount) {\n          this._removeGlobalListener();\n        }\n      };\n    });\n  }\n\n  ngOnDestroy() {\n    this._removeGlobalListener();\n    this.scrollContainers.forEach((_, container) => this.deregister(container));\n    this._scrolled.complete();\n  }\n\n  /**\n   * Returns an observable that emits whenever any of the\n   * scrollable ancestors of an element are scrolled.\n   * @param elementOrElementRef Element whose ancestors to listen for.\n   * @param auditTimeInMs Time to throttle the scroll events.\n   */\n  ancestorScrolled(\n      elementOrElementRef: ElementRef|HTMLElement,\n      auditTimeInMs?: number): Observable<CdkScrollable|void> {\n    const ancestors = this.getAncestorScrollContainers(elementOrElementRef);\n\n    return this.scrolled(auditTimeInMs).pipe(filter(target => {\n      return !target || ancestors.indexOf(target) > -1;\n    }));\n  }\n\n  /** Returns all registered Scrollables that contain the provided element. */\n  getAncestorScrollContainers(elementOrElementRef: ElementRef|HTMLElement): CdkScrollable[] {\n    const scrollingContainers: CdkScrollable[] = [];\n\n    this.scrollContainers.forEach((_subscription: Subscription, scrollable: CdkScrollable) => {\n      if (this._scrollableContainsElement(scrollable, elementOrElementRef)) {\n        scrollingContainers.push(scrollable);\n      }\n    });\n\n    return scrollingContainers;\n  }\n\n  /** Use defaultView of injected document if available or fallback to global window reference */\n  private _getWindow(): Window {\n    return this._document.defaultView || window;\n  }\n\n  /** Returns true if the element is contained within the provided Scrollable. */\n  private _scrollableContainsElement(\n      scrollable: CdkScrollable,\n      elementOrElementRef: ElementRef|HTMLElement): boolean {\n    let element: HTMLElement | null = coerceElement(elementOrElementRef);\n    let scrollableElement = scrollable.getElementRef().nativeElement;\n\n    // Traverse through the element parents until we reach null, checking if any of the elements\n    // are the scrollable's element.\n    do {\n      if (element == scrollableElement) { return true; }\n    } while (element = element!.parentElement);\n\n    return false;\n  }\n\n  /** Sets up the global scroll listeners. */\n  private _addGlobalListener() {\n    this._globalSubscription = this._ngZone.runOutsideAngular(() => {\n      const window = this._getWindow();\n      return fromEvent(window.document, 'scroll').subscribe(() => this._scrolled.next());\n    });\n  }\n\n  /** Cleans up the global scroll listener. */\n  private _removeGlobalListener() {\n    if (this._globalSubscription) {\n      this._globalSubscription.unsubscribe();\n      this._globalSubscription = null;\n    }\n  }\n}\n"]}