/**
 * @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 { Platform } from '@angular/cdk/platform';
import { Injectable, NgZone } from '@angular/core';
import { merge, of as observableOf, fromEvent } from 'rxjs';
import { auditTime } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/platform";
/** Time in ms to throttle the resize events by default. */
export var DEFAULT_RESIZE_TIME = 20;
/**
 * Simple utility for getting the bounds of the browser viewport.
 * @docs-private
 */
var ViewportRuler = /** @class */ (function () {
    function ViewportRuler(_platform, ngZone) {
        var _this = this;
        this._platform = _platform;
        ngZone.runOutsideAngular(function () {
            _this._change = _platform.isBrowser ?
                merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange')) :
                observableOf();
            // Note that we need to do the subscription inside `runOutsideAngular`
            // since subscribing is what causes the event listener to be added.
            _this._invalidateCache = _this.change().subscribe(function () { return _this._updateViewportSize(); });
        });
    }
    ViewportRuler.prototype.ngOnDestroy = function () {
        this._invalidateCache.unsubscribe();
    };
    /** Returns the viewport's width and height. */
    ViewportRuler.prototype.getViewportSize = function () {
        if (!this._viewportSize) {
            this._updateViewportSize();
        }
        var output = { width: this._viewportSize.width, height: this._viewportSize.height };
        // If we're not on a browser, don't cache the size since it'll be mocked out anyway.
        if (!this._platform.isBrowser) {
            this._viewportSize = null;
        }
        return output;
    };
    /** Gets a ClientRect for the viewport's bounds. */
    ViewportRuler.prototype.getViewportRect = function () {
        // Use the document element's bounding rect rather than the window scroll properties
        // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll
        // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different
        // conceptual viewports. Under most circumstances these viewports are equivalent, but they
        // can disagree when the page is pinch-zoomed (on devices that support touch).
        // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4
        // We use the documentElement instead of the body because, by default (without a css reset)
        // browsers typically give the document body an 8px margin, which is not included in
        // getBoundingClientRect().
        var scrollPosition = this.getViewportScrollPosition();
        var _a = this.getViewportSize(), width = _a.width, height = _a.height;
        return {
            top: scrollPosition.top,
            left: scrollPosition.left,
            bottom: scrollPosition.top + height,
            right: scrollPosition.left + width,
            height: height,
            width: width,
        };
    };
    /** Gets the (top, left) scroll position of the viewport. */
    ViewportRuler.prototype.getViewportScrollPosition = function () {
        // While we can get a reference to the fake document
        // during SSR, it doesn't have getBoundingClientRect.
        if (!this._platform.isBrowser) {
            return { top: 0, left: 0 };
        }
        // The top-left-corner of the viewport is determined by the scroll position of the document
        // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about
        // whether `document.body` or `document.documentElement` is the scrolled element, so reading
        // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of
        // `document.documentElement` works consistently, where the `top` and `left` values will
        // equal negative the scroll position.
        var documentElement = document.documentElement;
        var documentRect = documentElement.getBoundingClientRect();
        var top = -documentRect.top || document.body.scrollTop || window.scrollY ||
            documentElement.scrollTop || 0;
        var left = -documentRect.left || document.body.scrollLeft || window.scrollX ||
            documentElement.scrollLeft || 0;
        return { top: top, left: left };
    };
    /**
     * Returns a stream that emits whenever the size of the viewport changes.
     * @param throttleTime Time in milliseconds to throttle the stream.
     */
    ViewportRuler.prototype.change = function (throttleTime) {
        if (throttleTime === void 0) { throttleTime = DEFAULT_RESIZE_TIME; }
        return throttleTime > 0 ? this._change.pipe(auditTime(throttleTime)) : this._change;
    };
    /** Updates the cached viewport size. */
    ViewportRuler.prototype._updateViewportSize = function () {
        this._viewportSize = this._platform.isBrowser ?
            { width: window.innerWidth, height: window.innerHeight } :
            { width: 0, height: 0 };
    };
    ViewportRuler.decorators = [
        { type: Injectable, args: [{ providedIn: 'root' },] }
    ];
    /** @nocollapse */
    ViewportRuler.ctorParameters = function () { return [
        { type: Platform },
        { type: NgZone }
    ]; };
    ViewportRuler.ɵprov = i0.ɵɵdefineInjectable({ factory: function ViewportRuler_Factory() { return new ViewportRuler(i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i0.NgZone)); }, token: ViewportRuler, providedIn: "root" });
    return ViewportRuler;
}());
export { ViewportRuler };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewport-ruler.js","sourceRoot":"","sources":["../../../../../../../../../../src/cdk/scrolling/viewport-ruler.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 {Platform} from '@angular/cdk/platform';\nimport {Injectable, NgZone, OnDestroy} from '@angular/core';\nimport {merge, of as observableOf, fromEvent, Observable, Subscription} from 'rxjs';\nimport {auditTime} from 'rxjs/operators';\n\n/** Time in ms to throttle the resize events by default. */\nexport const DEFAULT_RESIZE_TIME = 20;\n\n/** Object that holds the scroll position of the viewport in each direction. */\nexport interface ViewportScrollPosition {\n  top: number;\n  left: number;\n}\n\n/**\n * Simple utility for getting the bounds of the browser viewport.\n * @docs-private\n */\n@Injectable({providedIn: 'root'})\nexport class ViewportRuler implements OnDestroy {\n  /** Cached viewport dimensions. */\n  private _viewportSize: {width: number; height: number};\n\n  /** Stream of viewport change events. */\n  private _change: Observable<Event>;\n\n  /** Subscription to streams that invalidate the cached viewport dimensions. */\n  private _invalidateCache: Subscription;\n\n  constructor(private _platform: Platform, ngZone: NgZone) {\n    ngZone.runOutsideAngular(() => {\n      this._change = _platform.isBrowser ?\n          merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange')) :\n          observableOf();\n\n      // Note that we need to do the subscription inside `runOutsideAngular`\n      // since subscribing is what causes the event listener to be added.\n      this._invalidateCache = this.change().subscribe(() => this._updateViewportSize());\n    });\n  }\n\n  ngOnDestroy() {\n    this._invalidateCache.unsubscribe();\n  }\n\n  /** Returns the viewport's width and height. */\n  getViewportSize(): Readonly<{width: number, height: number}> {\n    if (!this._viewportSize) {\n      this._updateViewportSize();\n    }\n\n    const output = {width: this._viewportSize.width, height: this._viewportSize.height};\n\n    // If we're not on a browser, don't cache the size since it'll be mocked out anyway.\n    if (!this._platform.isBrowser) {\n      this._viewportSize = null!;\n    }\n\n    return output;\n  }\n\n  /** Gets a ClientRect for the viewport's bounds. */\n  getViewportRect(): ClientRect {\n    // Use the document element's bounding rect rather than the window scroll properties\n    // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\n    // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\n    // conceptual viewports. Under most circumstances these viewports are equivalent, but they\n    // can disagree when the page is pinch-zoomed (on devices that support touch).\n    // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\n    // We use the documentElement instead of the body because, by default (without a css reset)\n    // browsers typically give the document body an 8px margin, which is not included in\n    // getBoundingClientRect().\n    const scrollPosition = this.getViewportScrollPosition();\n    const {width, height} = this.getViewportSize();\n\n    return {\n      top: scrollPosition.top,\n      left: scrollPosition.left,\n      bottom: scrollPosition.top + height,\n      right: scrollPosition.left + width,\n      height,\n      width,\n    };\n  }\n\n  /** Gets the (top, left) scroll position of the viewport. */\n  getViewportScrollPosition(): ViewportScrollPosition {\n    // While we can get a reference to the fake document\n    // during SSR, it doesn't have getBoundingClientRect.\n    if (!this._platform.isBrowser) {\n      return {top: 0, left: 0};\n    }\n\n    // The top-left-corner of the viewport is determined by the scroll position of the document\n    // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\n    // whether `document.body` or `document.documentElement` is the scrolled element, so reading\n    // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\n    // `document.documentElement` works consistently, where the `top` and `left` values will\n    // equal negative the scroll position.\n    const documentElement = document.documentElement!;\n    const documentRect = documentElement.getBoundingClientRect();\n\n    const top = -documentRect.top || document.body.scrollTop || window.scrollY ||\n                 documentElement.scrollTop || 0;\n\n    const left = -documentRect.left || document.body.scrollLeft || window.scrollX ||\n                  documentElement.scrollLeft || 0;\n\n    return {top, left};\n  }\n\n  /**\n   * Returns a stream that emits whenever the size of the viewport changes.\n   * @param throttleTime Time in milliseconds to throttle the stream.\n   */\n  change(throttleTime: number = DEFAULT_RESIZE_TIME): Observable<Event> {\n    return throttleTime > 0 ? this._change.pipe(auditTime(throttleTime)) : this._change;\n  }\n\n  /** Updates the cached viewport size. */\n  private _updateViewportSize() {\n    this._viewportSize = this._platform.isBrowser ?\n        {width: window.innerWidth, height: window.innerHeight} :\n        {width: 0, height: 0};\n  }\n}\n"]}