@hkjeffchan/ngx-scroll-to
Version:
A simple Angular 4+ plugin enabling you to smooth scroll to any element on your page and enhance scroll-based features in your app.
273 lines • 33.2 kB
JavaScript
import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
import { DOCUMENT, isPlatformBrowser } from '@angular/common';
import { ScrollToAnimation } from './scroll-to-animation';
import { DEFAULTS, isElementRef, isNativeElement, isNumber, isString, isWindow, stripHash } from './scroll-to-helpers';
import { ReplaySubject, throwError } from 'rxjs';
import * as i0 from "@angular/core";
/**
* The Scroll To Service handles starting, interrupting
* and ending the actual Scroll Animation. It provides
* some utilities to find the proper HTML Element on a
* given page to setup Event Listeners and calculate
* distances for the Animation.
*/
export class ScrollToService {
/**
* Construct and setup required paratemeters.
*
* @param document A Reference to the Document
* @param platformId Angular Platform ID
*/
constructor(document, platformId) {
this.document = document;
this.platformId = platformId;
this.interruptiveEvents = ['mousewheel', 'DOMMouseScroll', 'touchstart'];
}
/**
* Target an Element to scroll to. Notice that the `TimeOut` decorator
* ensures the executing to take place in the next Angular lifecycle.
* This allows for scrolling to elements that are e.g. initially hidden
* by means of `*ngIf`, but ought to be scrolled to eventually.
*
* @todo type 'any' in Observable should become custom type like 'ScrollToEvent' (base class), see issue comment:
* - https://github.com/nicky-lenaers/ngx-scroll-to/issues/10#issuecomment-317198481
*
* @param options Configuration Object
* @returns Observable
*/
scrollTo(options) {
if (!isPlatformBrowser(this.platformId)) {
return new ReplaySubject().asObservable();
}
return this.start(options);
}
/**
* Start a new Animation.
*
* @todo Emit proper events from subscription
*
* @param options Configuration Object
* @returns Observable
*/
start(options) {
// Merge config with default values
const mergedConfigOptions = {
...DEFAULTS,
...options
};
if (this.animation) {
this.animation.stop();
}
const targetNode = this.getNode(mergedConfigOptions.target);
if (mergedConfigOptions.target && !targetNode) {
return throwError(() => new Error('Unable to find Target Element'));
}
const container = this.getContainer(mergedConfigOptions, targetNode);
if (mergedConfigOptions.container && !container) {
return throwError(() => new Error('Unable to find Container Element'));
}
const listenerTarget = this.getListenerTarget(container) || window;
let to = container ? container.getBoundingClientRect().top : 0;
if (targetNode) {
to = isWindow(listenerTarget) ?
window.scrollY + targetNode.getBoundingClientRect().top :
targetNode.getBoundingClientRect().top;
}
// Create Animation
this.animation = new ScrollToAnimation(container, listenerTarget, isWindow(listenerTarget), to, mergedConfigOptions, isPlatformBrowser(this.platformId));
const onInterrupt = () => this.animation.stop();
this.addInterruptiveEventListeners(listenerTarget, onInterrupt);
// Start Animation
const animation$ = this.animation.start();
this.subscribeToAnimation(animation$, listenerTarget, onInterrupt);
return animation$;
}
/**
* Subscribe to the events emitted from the Scrolling
* Animation. Events might be used for e.g. unsubscribing
* once finished.
*
* @param animation$ The Animation Observable
* @param listenerTarget The Listener Target for events
* @param onInterrupt The handler for Interruptive Events
* @returns Void
*/
subscribeToAnimation(animation$, listenerTarget, onInterrupt) {
const subscription = animation$
.subscribe({
complete: () => {
this.removeInterruptiveEventListeners(this.interruptiveEvents, listenerTarget, onInterrupt);
subscription.unsubscribe();
}
});
}
/**
* Get the container HTML Element in which
* the scrolling should happen.
*
* @param options The Merged Configuration Object
* @param targetNode the targeted HTMLElement
*/
getContainer(options, targetNode) {
let container = null;
if (options.container) {
container = this.getNode(options.container, true);
}
else if (targetNode) {
container = this.getFirstScrollableParent(targetNode);
}
return container;
}
/**
* Add listeners for the Animation Interruptive Events
* to the Listener Target.
*
* @param events List of events to listen to
* @param listenerTarget Target to attach the listener on
* @param handler Handler for when the listener fires
* @returns Void
*/
addInterruptiveEventListeners(listenerTarget, handler) {
if (!listenerTarget) {
listenerTarget = window;
}
this.interruptiveEvents
.forEach(event => listenerTarget
.addEventListener(event, handler, this.supportPassive() ? { passive: true } : false));
}
/**
* Feature-detect support for passive event listeners.
*
* @returns Whether or not passive event listeners are supported
*/
supportPassive() {
let supportsPassive = false;
try {
const opts = Object.defineProperty({}, 'passive', {
get: () => {
supportsPassive = true;
}
});
window.addEventListener('testPassive', null, opts);
window.removeEventListener('testPassive', null, opts);
}
catch (e) {
}
return supportsPassive;
}
/**
* Remove listeners for the Animation Interrupt Event from
* the Listener Target. Specifying the correct handler prevents
* memory leaks and makes the allocated memory available for
* Garbage Collection.
*
* @param events List of Interruptive Events to remove
* @param listenerTarget Target to attach the listener on
* @param handler Handler for when the listener fires
* @returns Void
*/
removeInterruptiveEventListeners(events, listenerTarget, handler) {
if (!listenerTarget) {
listenerTarget = window;
}
events.forEach(event => listenerTarget.removeEventListener(event, handler));
}
/**
* Find the first scrollable parent Node of a given
* Element. The DOM Tree gets searched upwards
* to find this first scrollable parent. Parents might
* be ignored by CSS styles applied to the HTML Element.
*
* @param nativeElement The Element to search the DOM Tree upwards from
* @returns The first scrollable parent HTML Element
*/
getFirstScrollableParent(nativeElement) {
let style = window.getComputedStyle(nativeElement);
const overflowRegex = /(auto|scroll|overlay)/;
if (style.position === 'fixed') {
return null;
}
let parent = nativeElement;
while (parent.parentElement) {
parent = parent.parentElement;
style = window.getComputedStyle(parent);
if (style.position === 'absolute'
|| style.overflow === 'hidden'
|| style.overflowY === 'hidden') {
continue;
}
if (overflowRegex.test(style.overflow + style.overflowY)
|| parent.tagName === 'BODY') {
return parent;
}
}
return null;
}
/**
* Get the Target Node to scroll to.
*
* @param id The given ID of the node, either a string or
* an element reference
* @param allowBodyTag Indicate whether or not the Document Body is
* considered a valid Target Node
* @returns The Target Node to scroll to
*/
getNode(id, allowBodyTag = false) {
let targetNode;
if (isString(id)) {
if (allowBodyTag && (id === 'body' || id === 'BODY')) {
targetNode = this.document.body;
}
else {
targetNode = this.document.getElementById(stripHash(id));
}
}
else if (isNumber(id)) {
targetNode = this.document.getElementById(String(id));
}
else if (isElementRef(id)) {
targetNode = id.nativeElement;
}
else if (isNativeElement(id)) {
targetNode = id;
}
return targetNode;
}
/**
* Retrieve the Listener target. This Listener Target is used
* to attach Event Listeners on. In case of the target being
* the Document Body, we need the actual `window` to listen
* for events.
*
* @param container The HTML Container element
* @returns The Listener Target to attach events on
*/
getListenerTarget(container) {
if (!container) {
return null;
}
return this.isDocumentBody(container) ? window : container;
}
/**
* Test if a given HTML Element is the Document Body.
*
* @param element The given HTML Element
* @returns Whether or not the Element is the
* Document Body Element
*/
isDocumentBody(element) {
return element.tagName.toUpperCase() === 'BODY';
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToService, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToService }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToService, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: undefined, decorators: [{
type: Inject,
args: [DOCUMENT]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [PLATFORM_ID]
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-to.service.js","sourceRoot":"","sources":["../../../../projects/ngx-scroll-to/src/lib/scroll-to.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, PLATFORM_ID } from '@angular/core';\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\n\nimport {\n  ScrollToConfigOptions,\n  ScrollToConfigOptionsTarget,\n  ScrollToListenerTarget,\n  ScrollToTarget\n} from './scroll-to-config.interface';\nimport { ScrollToAnimation } from './scroll-to-animation';\nimport { DEFAULTS, isElementRef, isNativeElement, isNumber, isString, isWindow, stripHash } from './scroll-to-helpers';\nimport { Observable, ReplaySubject, throwError } from 'rxjs';\n\n/**\n * The Scroll To Service handles starting, interrupting\n * and ending the actual Scroll Animation. It provides\n * some utilities to find the proper HTML Element on a\n * given page to setup Event Listeners and calculate\n * distances for the Animation.\n */\n@Injectable()\nexport class ScrollToService {\n\n  /**\n   * The animation that provides the scrolling\n   * to happen smoothly over time. Defining it here\n   * allows for usage of e.g. `start` and `stop`\n   * methods within this Angular Service.\n   */\n  private animation: ScrollToAnimation;\n\n  /**\n   * Interruptive Events allow to scrolling animation\n   * to be interrupted before it is finished. The list\n   * of Interruptive Events represents those.\n   */\n  private interruptiveEvents: string[];\n\n  /**\n   * Construct and setup required paratemeters.\n   *\n   * @param document         A Reference to the Document\n   * @param platformId       Angular Platform ID\n   */\n  constructor(\n    @Inject(DOCUMENT) private document: any,\n    @Inject(PLATFORM_ID) private platformId: any\n  ) {\n    this.interruptiveEvents = ['mousewheel', 'DOMMouseScroll', 'touchstart'];\n  }\n\n  /**\n   * Target an Element to scroll to. Notice that the `TimeOut` decorator\n   * ensures the executing to take place in the next Angular lifecycle.\n   * This allows for scrolling to elements that are e.g. initially hidden\n   * by means of `*ngIf`, but ought to be scrolled to eventually.\n   *\n   * @todo type 'any' in Observable should become custom type like 'ScrollToEvent' (base class), see issue comment:\n   *  - https://github.com/nicky-lenaers/ngx-scroll-to/issues/10#issuecomment-317198481\n   *\n   * @param options         Configuration Object\n   * @returns               Observable\n   */\n  scrollTo(options: ScrollToConfigOptions): Observable<any> {\n\n    if (!isPlatformBrowser(this.platformId)) {\n      return new ReplaySubject().asObservable();\n    }\n\n    return this.start(options);\n  }\n\n  /**\n   * Start a new Animation.\n   *\n   * @todo Emit proper events from subscription\n   *\n   * @param options         Configuration Object\n   * @returns               Observable\n   */\n  private start(options: ScrollToConfigOptions): Observable<number> {\n\n    // Merge config with default values\n    const mergedConfigOptions = {\n      ...DEFAULTS as ScrollToConfigOptions,\n      ...options\n    } as ScrollToConfigOptionsTarget;\n\n    if (this.animation) {\n      this.animation.stop();\n    }\n\n    const targetNode = this.getNode(mergedConfigOptions.target);\n    if (mergedConfigOptions.target && !targetNode) {\n      return throwError(() => new Error('Unable to find Target Element'));\n    }\n\n    const container: HTMLElement = this.getContainer(mergedConfigOptions, targetNode);\n    if (mergedConfigOptions.container && !container) {\n      return throwError(() => new Error('Unable to find Container Element'));\n    }\n\n    const listenerTarget = this.getListenerTarget(container) || window;\n\n    let to = container ? container.getBoundingClientRect().top : 0;\n\n    if (targetNode) {\n      to = isWindow(listenerTarget) ?\n        window.scrollY + targetNode.getBoundingClientRect().top :\n        targetNode.getBoundingClientRect().top;\n    }\n\n    // Create Animation\n    this.animation = new ScrollToAnimation(\n      container,\n      listenerTarget,\n      isWindow(listenerTarget),\n      to,\n      mergedConfigOptions,\n      isPlatformBrowser(this.platformId)\n    );\n    const onInterrupt = () => this.animation.stop();\n    this.addInterruptiveEventListeners(listenerTarget, onInterrupt);\n\n    // Start Animation\n    const animation$ = this.animation.start();\n    this.subscribeToAnimation(animation$, listenerTarget, onInterrupt);\n\n    return animation$;\n  }\n\n  /**\n   * Subscribe to the events emitted from the Scrolling\n   * Animation. Events might be used for e.g. unsubscribing\n   * once finished.\n   *\n   * @param animation$              The Animation Observable\n   * @param listenerTarget          The Listener Target for events\n   * @param onInterrupt             The handler for Interruptive Events\n   * @returns                       Void\n   */\n  private subscribeToAnimation(\n    animation$: Observable<any>,\n    listenerTarget: ScrollToListenerTarget,\n    onInterrupt: EventListenerOrEventListenerObject\n  ) {\n    const subscription = animation$\n      .subscribe(\n        {\n          complete: () => {\n            this.removeInterruptiveEventListeners(this.interruptiveEvents, listenerTarget, onInterrupt);\n            subscription.unsubscribe();\n          }\n        }\n      );\n  }\n\n  /**\n   * Get the container HTML Element in which\n   * the scrolling should happen.\n   *\n   * @param options         The Merged Configuration Object\n   * @param targetNode    the targeted HTMLElement\n   */\n  private getContainer(options: ScrollToConfigOptions, targetNode: HTMLElement): HTMLElement | null {\n\n    let container: HTMLElement | null = null;\n\n    if (options.container) {\n      container = this.getNode(options.container, true);\n    } else if (targetNode) {\n      container = this.getFirstScrollableParent(targetNode);\n    }\n\n    return container;\n  }\n\n  /**\n   * Add listeners for the Animation Interruptive Events\n   * to the Listener Target.\n   *\n   * @param events            List of events to listen to\n   * @param listenerTarget    Target to attach the listener on\n   * @param handler           Handler for when the listener fires\n   * @returns                 Void\n   */\n  private addInterruptiveEventListeners(\n    listenerTarget: ScrollToListenerTarget,\n    handler: EventListenerOrEventListenerObject): void {\n\n    if (!listenerTarget) {\n      listenerTarget = window;\n    }\n\n    this.interruptiveEvents\n      .forEach(event => listenerTarget\n        .addEventListener(event, handler, this.supportPassive() ? {passive: true} : false));\n  }\n\n  /**\n   * Feature-detect support for passive event listeners.\n   *\n   * @returns       Whether or not passive event listeners are supported\n   */\n  private supportPassive(): boolean {\n\n    let supportsPassive = false;\n\n    try {\n      const opts = Object.defineProperty({}, 'passive', {\n        get: () => {\n          supportsPassive = true;\n        }\n      });\n      window.addEventListener('testPassive', null, opts);\n      window.removeEventListener('testPassive', null, opts);\n    } catch (e) {\n    }\n\n    return supportsPassive;\n  }\n\n  /**\n   * Remove listeners for the Animation Interrupt Event from\n   * the Listener Target. Specifying the correct handler prevents\n   * memory leaks and makes the allocated memory available for\n   * Garbage Collection.\n   *\n   * @param events            List of Interruptive Events to remove\n   * @param listenerTarget    Target to attach the listener on\n   * @param handler           Handler for when the listener fires\n   * @returns                 Void\n   */\n  private removeInterruptiveEventListeners(\n    events: string[],\n    listenerTarget: ScrollToListenerTarget,\n    handler: EventListenerOrEventListenerObject): void {\n\n    if (!listenerTarget) {\n      listenerTarget = window;\n    }\n    events.forEach(event => listenerTarget.removeEventListener(event, handler));\n  }\n\n  /**\n   * Find the first scrollable parent Node of a given\n   * Element. The DOM Tree gets searched upwards\n   * to find this first scrollable parent. Parents might\n   * be ignored by CSS styles applied to the HTML Element.\n   *\n   * @param nativeElement     The Element to search the DOM Tree upwards from\n   * @returns                 The first scrollable parent HTML Element\n   */\n  private getFirstScrollableParent(nativeElement: HTMLElement): HTMLElement {\n\n    let style: CSSStyleDeclaration = window.getComputedStyle(nativeElement);\n\n    const overflowRegex: RegExp = /(auto|scroll|overlay)/;\n\n    if (style.position === 'fixed') {\n      return null;\n    }\n\n    let parent = nativeElement;\n    while (parent.parentElement) {\n      parent = parent.parentElement;\n      style = window.getComputedStyle(parent);\n\n      if (style.position === 'absolute'\n        || style.overflow === 'hidden'\n        || style.overflowY === 'hidden') {\n        continue;\n      }\n\n      if (overflowRegex.test(style.overflow + style.overflowY)\n        || parent.tagName === 'BODY') {\n        return parent;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Get the Target Node to scroll to.\n   *\n   * @param id              The given ID of the node, either a string or\n   *                        an element reference\n   * @param allowBodyTag    Indicate whether or not the Document Body is\n   *                        considered a valid Target Node\n   * @returns               The Target Node to scroll to\n   */\n  private getNode(id: ScrollToTarget, allowBodyTag: boolean = false): HTMLElement {\n\n    let targetNode: HTMLElement;\n\n    if (isString(id)) {\n      if (allowBodyTag && (id === 'body' || id === 'BODY')) {\n        targetNode = this.document.body;\n      } else {\n        targetNode = this.document.getElementById(stripHash(id));\n      }\n    } else if (isNumber(id)) {\n      targetNode = this.document.getElementById(String(id));\n    } else if (isElementRef(id)) {\n      targetNode = id.nativeElement;\n    } else if (isNativeElement(id)) {\n      targetNode = id;\n    }\n\n    return targetNode;\n  }\n\n  /**\n   * Retrieve the Listener target. This Listener Target is used\n   * to attach Event Listeners on. In case of the target being\n   * the Document Body, we need the actual `window` to listen\n   * for events.\n   *\n   * @param container           The HTML Container element\n   * @returns                   The Listener Target to attach events on\n   */\n  private getListenerTarget(container: HTMLElement): ScrollToListenerTarget {\n    if (!container) {\n      return null;\n    }\n    return this.isDocumentBody(container) ? window : container;\n  }\n\n  /**\n   * Test if a given HTML Element is the Document Body.\n   *\n   * @param element             The given HTML Element\n   * @returns                   Whether or not the Element is the\n   *                            Document Body Element\n   */\n  private isDocumentBody(element: HTMLElement): element is HTMLBodyElement {\n    return element.tagName.toUpperCase() === 'BODY';\n  }\n}\n"]}