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