UNPKG

@nicky-lenaers/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 32.9 kB
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'; } } ScrollToService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ScrollToService, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); ScrollToService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ScrollToService }); i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", 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';\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"]}