legado/modules/web/src/plugins/jump.js

const easeInOutQuad = (t, b, c, d) => {
  t /= d / 2
  if (t < 1) return (c / 2) * t * t + b
  t--
  return (-c / 2) * (t * (t - 2) - 1) + b
}

const jumper = () => {
  // private variable cache
  // no variables are created during a jump, preventing memory leaks

  let container // container element to be scrolled       (node)
  let element // element to scroll to                   (node)

  let start // where scroll starts                    (px)
  let stop // where scroll stops                     (px)

  let offset // adjustment from the stop position      (px)
  let easing // easing function                        (function)
  let a11y // accessibility support flag             (boolean)

  let distance // distance of scroll                     (px)
  let duration // scroll duration                        (ms)

  let timeStart // time scroll started                    (ms)
  let timeElapsed // time spent scrolling thus far          (ms)

  let next // next scroll position                   (px)

  let callback // to call when done scrolling            (function)

  // scroll position helper

  function location() {
    let top = container.scrollTop || container.scrollY || container.pageYOffset
    top = typeof top === 'undefined' ? 0 : top
    return top
  }

  // element offset helper

  function top(element) {
    const elementTop = element.getBoundingClientRect().top
    const containerTop = container.getBoundingClientRect
      ? container.getBoundingClientRect().top
      : 0

    return elementTop - containerTop + start
  }

  // scrollTo helper

  function scrollTo(top) {
    container.scrollTo
      ? container.scrollTo(0, top) // window
      : (container.scrollTop = top) // custom container
  }

  // rAF loop helper

  function loop(timeCurrent) {
    // store time scroll started, if not started already
    if (!timeStart) {
      timeStart = timeCurrent
    }

    // determine time spent scrolling so far
    timeElapsed = timeCurrent - timeStart

    // calculate next scroll position
    next = easing(timeElapsed, start, distance, duration)

    // scroll to it
    scrollTo(next)

    // check progress
    timeElapsed < duration
      ? requestAnimationFrame(loop) // continue scroll loop
      : done() // scrolling is done
  }

  // scroll finished helper

  function done() {
    // account for rAF time rounding inaccuracies
    scrollTo(start + distance)

    // if scrolling to an element, and accessibility is enabled
    if (element && a11y) {
      // add tabindex indicating programmatic focus
      element.setAttribute('tabindex', '-1')

      // focus the element
      element.focus()
    }

    // if it exists, fire the callback
    if (typeof callback === 'function') {
      callback()
    }

    // reset time for next jump
    timeStart = false
  }

  // API

  function jump(target, options = {}) {
    // resolve options, or use defaults
    duration = options.duration || 1000
    offset = options.offset || 0
    callback = options.callback // "undefined" is a suitable default, and won't be called
    easing = options.easing || easeInOutQuad
    a11y = options.a11y || false

    // resolve container
    switch (typeof options.container) {
      case 'object':
        // we assume container is an HTML element (Node)
        container = options.container
        break

      case 'string':
        container = document.querySelector(options.container)
        break

      default:
        container = window
    }

    // cache starting position
    start = location()

    // resolve target
    switch (typeof target) {
      // scroll from current position
      case 'number':
        element = undefined // no element to scroll to
        a11y = false // make sure accessibility is off
        stop = start + target
        break

      // scroll to element (node)
      // bounding rect is relative to the viewport
      case 'object':
        element = target
        stop = top(element)
        break

      // scroll to element (selector)
      // bounding rect is relative to the viewport
      case 'string':
        element = document.querySelector(target)
        stop = top(element)
        break
    }

    // resolve scroll distance, accounting for offset
    distance = stop - start + offset

    // resolve duration
    switch (typeof options.duration) {
      // number in ms
      case 'number':
        duration = options.duration
        break

      // function passed the distance of the scroll
      case 'function':
        duration = options.duration(distance)
        break
    }

    // start the loop
    requestAnimationFrame(loop)
  }

  // expose only the jump method
  return jump
}

// export singleton

const singleton = jumper()

export default singleton