@angular/cdk
Version:
Angular Material Component Development Kit
190 lines • 17.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/cdk/scrolling/viewport-ruler.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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.
* @type {?}
*/
export const DEFAULT_RESIZE_TIME = 20;
/**
* Object that holds the scroll position of the viewport in each direction.
* @record
*/
export function ViewportScrollPosition() { }
if (false) {
/** @type {?} */
ViewportScrollPosition.prototype.top;
/** @type {?} */
ViewportScrollPosition.prototype.left;
}
/**
* Simple utility for getting the bounds of the browser viewport.
* \@docs-private
*/
export class ViewportRuler {
/**
* @param {?} _platform
* @param {?} ngZone
*/
constructor(_platform, ngZone) {
this._platform = _platform;
ngZone.runOutsideAngular((/**
* @return {?}
*/
() => {
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((/**
* @return {?}
*/
() => this._updateViewportSize()));
}));
}
/**
* @return {?}
*/
ngOnDestroy() {
this._invalidateCache.unsubscribe();
}
/**
* Returns the viewport's width and height.
* @return {?}
*/
getViewportSize() {
if (!this._viewportSize) {
this._updateViewportSize();
}
/** @type {?} */
const 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 = (/** @type {?} */ (null));
}
return output;
}
/**
* Gets a ClientRect for the viewport's bounds.
* @return {?}
*/
getViewportRect() {
// 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().
/** @type {?} */
const scrollPosition = this.getViewportScrollPosition();
const { width, height } = this.getViewportSize();
return {
top: scrollPosition.top,
left: scrollPosition.left,
bottom: scrollPosition.top + height,
right: scrollPosition.left + width,
height,
width,
};
}
/**
* Gets the (top, left) scroll position of the viewport.
* @return {?}
*/
getViewportScrollPosition() {
// 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.
/** @type {?} */
const documentElement = (/** @type {?} */ (document.documentElement));
/** @type {?} */
const documentRect = documentElement.getBoundingClientRect();
/** @type {?} */
const top = -documentRect.top || document.body.scrollTop || window.scrollY ||
documentElement.scrollTop || 0;
/** @type {?} */
const left = -documentRect.left || document.body.scrollLeft || window.scrollX ||
documentElement.scrollLeft || 0;
return { top, left };
}
/**
* Returns a stream that emits whenever the size of the viewport changes.
* @param {?=} throttleTime Time in milliseconds to throttle the stream.
* @return {?}
*/
change(throttleTime = DEFAULT_RESIZE_TIME) {
return throttleTime > 0 ? this._change.pipe(auditTime(throttleTime)) : this._change;
}
/**
* Updates the cached viewport size.
* @private
* @return {?}
*/
_updateViewportSize() {
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 = () => [
{ type: Platform },
{ type: NgZone }
];
/** @nocollapse */ ViewportRuler.ɵprov = i0.ɵɵdefineInjectable({ factory: function ViewportRuler_Factory() { return new ViewportRuler(i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i0.NgZone)); }, token: ViewportRuler, providedIn: "root" });
if (false) {
/**
* Cached viewport dimensions.
* @type {?}
* @private
*/
ViewportRuler.prototype._viewportSize;
/**
* Stream of viewport change events.
* @type {?}
* @private
*/
ViewportRuler.prototype._change;
/**
* Subscription to streams that invalidate the cached viewport dimensions.
* @type {?}
* @private
*/
ViewportRuler.prototype._invalidateCache;
/**
* @type {?}
* @private
*/
ViewportRuler.prototype._platform;
}
//# 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"]}