@angular/common
Version:
Angular - commonly needed directives and services
276 lines • 20.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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 { ErrorHandler, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
import { DOCUMENT } from './dom_tokens';
/**
* Defines a scroll position manager. Implemented by `BrowserViewportScroller`.
*
* \@publicApi
* @abstract
*/
export class ViewportScroller {
}
// De-sugared tree-shakable injection
// See #23917
/** @nocollapse */
/** @nocollapse */ ViewportScroller.ngInjectableDef = ɵɵdefineInjectable({
token: ViewportScroller,
providedIn: 'root',
factory: (/**
* @nocollapse @return {?}
*/
() => new BrowserViewportScroller(ɵɵinject(DOCUMENT), window, ɵɵinject(ErrorHandler)))
});
if (false) {
/**
* @nocollapse
* @type {?}
*/
ViewportScroller.ngInjectableDef;
/**
* Configures the top offset used when scrolling to an anchor.
* @abstract
* @param {?} offset A position in screen coordinates (a tuple with x and y values)
* or a function that returns the top offset position.
*
* @return {?}
*/
ViewportScroller.prototype.setOffset = function (offset) { };
/**
* Retrieves the current scroll position.
* @abstract
* @return {?} A position in screen coordinates (a tuple with x and y values).
*/
ViewportScroller.prototype.getScrollPosition = function () { };
/**
* Scrolls to a specified position.
* @abstract
* @param {?} position A position in screen coordinates (a tuple with x and y values).
* @return {?}
*/
ViewportScroller.prototype.scrollToPosition = function (position) { };
/**
* Scrolls to an anchor element.
* @abstract
* @param {?} anchor The ID of the anchor element.
* @return {?}
*/
ViewportScroller.prototype.scrollToAnchor = function (anchor) { };
/**
* Disables automatic scroll restoration provided by the browser.
* See also [window.history.scrollRestoration
* info](https://developers.google.com/web/updates/2015/09/history-api-scroll-restoration).
* @abstract
* @param {?} scrollRestoration
* @return {?}
*/
ViewportScroller.prototype.setHistoryScrollRestoration = function (scrollRestoration) { };
}
/**
* Manages the scroll position for a browser window.
*/
export class BrowserViewportScroller {
/**
* @param {?} document
* @param {?} window
* @param {?} errorHandler
*/
constructor(document, window, errorHandler) {
this.document = document;
this.window = window;
this.errorHandler = errorHandler;
this.offset = (/**
* @return {?}
*/
() => [0, 0]);
}
/**
* Configures the top offset used when scrolling to an anchor.
* @param {?} offset A position in screen coordinates (a tuple with x and y values)
* or a function that returns the top offset position.
*
* @return {?}
*/
setOffset(offset) {
if (Array.isArray(offset)) {
this.offset = (/**
* @return {?}
*/
() => offset);
}
else {
this.offset = offset;
}
}
/**
* Retrieves the current scroll position.
* @return {?} The position in screen coordinates.
*/
getScrollPosition() {
if (this.supportScrollRestoration()) {
return [this.window.scrollX, this.window.scrollY];
}
else {
return [0, 0];
}
}
/**
* Sets the scroll position.
* @param {?} position The new position in screen coordinates.
* @return {?}
*/
scrollToPosition(position) {
if (this.supportScrollRestoration()) {
this.window.scrollTo(position[0], position[1]);
}
}
/**
* Scrolls to an anchor element.
* @param {?} anchor The ID of the anchor element.
* @return {?}
*/
scrollToAnchor(anchor) {
if (this.supportScrollRestoration()) {
// Escape anything passed to `querySelector` as it can throw errors and stop the application
// from working if invalid values are passed.
if (this.window.CSS && this.window.CSS.escape) {
anchor = this.window.CSS.escape(anchor);
}
else {
anchor = anchor.replace(/(\"|\'\ |:|\.|\[|\]|,|=)/g, '\\$1');
}
try {
/** @type {?} */
const elSelectedById = this.document.querySelector(`#${anchor}`);
if (elSelectedById) {
this.scrollToElement(elSelectedById);
return;
}
/** @type {?} */
const elSelectedByName = this.document.querySelector(`[name='${anchor}']`);
if (elSelectedByName) {
this.scrollToElement(elSelectedByName);
return;
}
}
catch (e) {
this.errorHandler.handleError(e);
}
}
}
/**
* Disables automatic scroll restoration provided by the browser.
* @param {?} scrollRestoration
* @return {?}
*/
setHistoryScrollRestoration(scrollRestoration) {
if (this.supportScrollRestoration()) {
/** @type {?} */
const history = this.window.history;
if (history && history.scrollRestoration) {
history.scrollRestoration = scrollRestoration;
}
}
}
/**
* @private
* @param {?} el
* @return {?}
*/
scrollToElement(el) {
/** @type {?} */
const rect = el.getBoundingClientRect();
/** @type {?} */
const left = rect.left + this.window.pageXOffset;
/** @type {?} */
const top = rect.top + this.window.pageYOffset;
/** @type {?} */
const offset = this.offset();
this.window.scrollTo(left - offset[0], top - offset[1]);
}
/**
* We only support scroll restoration when we can get a hold of window.
* This means that we do not support this behavior when running in a web worker.
*
* Lifting this restriction right now would require more changes in the dom adapter.
* Since webworkers aren't widely used, we will lift it once RouterScroller is
* battle-tested.
* @private
* @return {?}
*/
supportScrollRestoration() {
try {
return !!this.window && !!this.window.scrollTo;
}
catch (_a) {
return false;
}
}
}
if (false) {
/**
* @type {?}
* @private
*/
BrowserViewportScroller.prototype.offset;
/**
* @type {?}
* @private
*/
BrowserViewportScroller.prototype.document;
/**
* @type {?}
* @private
*/
BrowserViewportScroller.prototype.window;
/**
* @type {?}
* @private
*/
BrowserViewportScroller.prototype.errorHandler;
}
/**
* Provides an empty implementation of the viewport scroller. This will
* live in \@angular/common as it will be used by both platform-server and platform-webworker.
*/
export class NullViewportScroller {
/**
* Empty implementation
* @param {?} offset
* @return {?}
*/
setOffset(offset) { }
/**
* Empty implementation
* @return {?}
*/
getScrollPosition() { return [0, 0]; }
/**
* Empty implementation
* @param {?} position
* @return {?}
*/
scrollToPosition(position) { }
/**
* Empty implementation
* @param {?} anchor
* @return {?}
*/
scrollToAnchor(anchor) { }
/**
* Empty implementation
* @param {?} scrollRestoration
* @return {?}
*/
setHistoryScrollRestoration(scrollRestoration) { }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewport_scroller.js","sourceRoot":"","sources":["../../../../../../packages/common/src/viewport_scroller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {ErrorHandler, ɵɵdefineInjectable, ɵɵinject} from '@angular/core';\n\nimport {DOCUMENT} from './dom_tokens';\n\n\n\n/**\n * Defines a scroll position manager. Implemented by `BrowserViewportScroller`.\n *\n * @publicApi\n */\nexport abstract class ViewportScroller {\n  // De-sugared tree-shakable injection\n  // See #23917\n  /** @nocollapse */\n  static ngInjectableDef = ɵɵdefineInjectable({\n    token: ViewportScroller,\n    providedIn: 'root',\n    factory: () => new BrowserViewportScroller(ɵɵinject(DOCUMENT), window, ɵɵinject(ErrorHandler))\n  });\n\n  /**\n   * Configures the top offset used when scrolling to an anchor.\n   * @param offset A position in screen coordinates (a tuple with x and y values)\n   * or a function that returns the top offset position.\n   *\n   */\n  abstract setOffset(offset: [number, number]|(() => [number, number])): void;\n\n  /**\n   * Retrieves the current scroll position.\n   * @returns A position in screen coordinates (a tuple with x and y values).\n   */\n  abstract getScrollPosition(): [number, number];\n\n  /**\n   * Scrolls to a specified position.\n   * @param position A position in screen coordinates (a tuple with x and y values).\n   */\n  abstract scrollToPosition(position: [number, number]): void;\n\n  /**\n   * Scrolls to an anchor element.\n   * @param anchor The ID of the anchor element.\n   */\n  abstract scrollToAnchor(anchor: string): void;\n\n  /**\n   * Disables automatic scroll restoration provided by the browser.\n   * See also [window.history.scrollRestoration\n   * info](https://developers.google.com/web/updates/2015/09/history-api-scroll-restoration).\n   */\n  abstract setHistoryScrollRestoration(scrollRestoration: 'auto'|'manual'): void;\n}\n\n/**\n * Manages the scroll position for a browser window.\n */\nexport class BrowserViewportScroller implements ViewportScroller {\n  private offset: () => [number, number] = () => [0, 0];\n\n  constructor(private document: any, private window: any, private errorHandler: ErrorHandler) {}\n\n  /**\n   * Configures the top offset used when scrolling to an anchor.\n   * @param offset A position in screen coordinates (a tuple with x and y values)\n   * or a function that returns the top offset position.\n   *\n   */\n  setOffset(offset: [number, number]|(() => [number, number])): void {\n    if (Array.isArray(offset)) {\n      this.offset = () => offset;\n    } else {\n      this.offset = offset;\n    }\n  }\n\n  /**\n   * Retrieves the current scroll position.\n   * @returns The position in screen coordinates.\n   */\n  getScrollPosition(): [number, number] {\n    if (this.supportScrollRestoration()) {\n      return [this.window.scrollX, this.window.scrollY];\n    } else {\n      return [0, 0];\n    }\n  }\n\n  /**\n   * Sets the scroll position.\n   * @param position The new position in screen coordinates.\n   */\n  scrollToPosition(position: [number, number]): void {\n    if (this.supportScrollRestoration()) {\n      this.window.scrollTo(position[0], position[1]);\n    }\n  }\n\n  /**\n   * Scrolls to an anchor element.\n   * @param anchor The ID of the anchor element.\n   */\n  scrollToAnchor(anchor: string): void {\n    if (this.supportScrollRestoration()) {\n      // Escape anything passed to `querySelector` as it can throw errors and stop the application\n      // from working if invalid values are passed.\n      if (this.window.CSS && this.window.CSS.escape) {\n        anchor = this.window.CSS.escape(anchor);\n      } else {\n        anchor = anchor.replace(/(\\\"|\\'\\ |:|\\.|\\[|\\]|,|=)/g, '\\\\$1');\n      }\n      try {\n        const elSelectedById = this.document.querySelector(`#${anchor}`);\n        if (elSelectedById) {\n          this.scrollToElement(elSelectedById);\n          return;\n        }\n        const elSelectedByName = this.document.querySelector(`[name='${anchor}']`);\n        if (elSelectedByName) {\n          this.scrollToElement(elSelectedByName);\n          return;\n        }\n      } catch (e) {\n        this.errorHandler.handleError(e);\n      }\n    }\n  }\n\n  /**\n   * Disables automatic scroll restoration provided by the browser.\n   */\n  setHistoryScrollRestoration(scrollRestoration: 'auto'|'manual'): void {\n    if (this.supportScrollRestoration()) {\n      const history = this.window.history;\n      if (history && history.scrollRestoration) {\n        history.scrollRestoration = scrollRestoration;\n      }\n    }\n  }\n\n  private scrollToElement(el: any): void {\n    const rect = el.getBoundingClientRect();\n    const left = rect.left + this.window.pageXOffset;\n    const top = rect.top + this.window.pageYOffset;\n    const offset = this.offset();\n    this.window.scrollTo(left - offset[0], top - offset[1]);\n  }\n\n  /**\n   * We only support scroll restoration when we can get a hold of window.\n   * This means that we do not support this behavior when running in a web worker.\n   *\n   * Lifting this restriction right now would require more changes in the dom adapter.\n   * Since webworkers aren't widely used, we will lift it once RouterScroller is\n   * battle-tested.\n   */\n  private supportScrollRestoration(): boolean {\n    try {\n      return !!this.window && !!this.window.scrollTo;\n    } catch {\n      return false;\n    }\n  }\n}\n\n\n/**\n * Provides an empty implementation of the viewport scroller. This will\n * live in @angular/common as it will be used by both platform-server and platform-webworker.\n */\nexport class NullViewportScroller implements ViewportScroller {\n  /**\n   * Empty implementation\n   */\n  setOffset(offset: [number, number]|(() => [number, number])): void {}\n\n  /**\n   * Empty implementation\n   */\n  getScrollPosition(): [number, number] { return [0, 0]; }\n\n  /**\n   * Empty implementation\n   */\n  scrollToPosition(position: [number, number]): void {}\n\n  /**\n   * Empty implementation\n   */\n  scrollToAnchor(anchor: string): void {}\n\n  /**\n   * Empty implementation\n   */\n  setHistoryScrollRestoration(scrollRestoration: 'auto'|'manual'): void {}\n}\n"]}