@rhavenside/baseline 2.0.0

package/dist/js/modal.js

@@ -0,0 +1,440 @@
+/**
+ * Base-Line Modal Component
+ * Baseline 2.0 compatible modal with Base-Line naming
+ */
+
+import { BaseComponent } from './base.js'
+import { SelectorEngine, isRTL, isVisible, reflow, getElement, one } from './util.js'
+import { on, off } from './util.js'
+import Backdrop from './util/backdrop.js'
+import { enableDismissTrigger } from './util/component-functions.js'
+import FocusTrap from './util/focustrap.js'
+import ScrollBarHelper from './util/scrollbar.js'
+
+/**
+ * Constants
+ */
+
+const NAME = 'modal'
+const DATA_KEY = `c.${NAME}`
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = `[data-c-${NAME}]`
+const ESCAPE_KEY = 'Escape'
+
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_RESIZE = `resize${EVENT_KEY}`
+const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`
+const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY}`
+const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+
+const CLASS_NAME_OPEN = 'c-modal-open'
+const CLASS_NAME_FADE = 'c-fade'
+const CLASS_NAME_SHOW = 'is-show'
+const CLASS_NAME_STATIC = 'c-modal-static'
+
+const OPEN_SELECTOR = '.c-modal.is-show'
+const SELECTOR_DIALOG = '.c-modal-dialog'
+const SELECTOR_MODAL_BODY = '.c-modal-body'
+const SELECTOR_DATA_TOGGLE = '[data-c-toggle="modal"]'
+
+const Default = {
+  backdrop: true,
+  focus: true,
+  keyboard: true
+}
+
+/**
+ * Class definition
+ */
+
+class Modal extends BaseComponent {
+  constructor(element, config) {
+    super(element, config)
+
+    this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element)
+    this._backdrop = this._initializeBackDrop()
+    this._focustrap = this._initializeFocusTrap()
+    this._isShown = false
+    this._isTransitioning = false
+    this._scrollBar = new ScrollBarHelper()
+
+    this._addEventListeners()
+  }
+
+  // Getters
+  static get Default() {
+    return Default
+  }
+
+  static get DefaultType() {
+    return {
+      backdrop: '(boolean|string)',
+      focus: 'boolean',
+      keyboard: 'boolean'
+    }
+  }
+
+  static get NAME() {
+    return NAME
+  }
+
+  // Public
+  toggle(relatedTarget) {
+    return this._isShown ? this.hide() : this.show(relatedTarget)
+  }
+
+  show(relatedTarget) {
+    if (this._isShown || this._isTransitioning) {
+      return
+    }
+
+    const showEvent = new CustomEvent(EVENT_SHOW, {
+      bubbles: true,
+      cancelable: true,
+      detail: { relatedTarget }
+    })
+
+    this._element.dispatchEvent(showEvent)
+
+    if (showEvent.defaultPrevented) {
+      return
+    }
+
+    this._isShown = true
+    this._isTransitioning = true
+
+    this._scrollBar.hide()
+
+    document.body.classList.add(CLASS_NAME_OPEN)
+
+    this._adjustDialog()
+
+    this._backdrop.show(() => this._showElement(relatedTarget))
+  }
+
+  hide() {
+    if (!this._isShown || this._isTransitioning) {
+      return
+    }
+
+    const hideEvent = new CustomEvent(EVENT_HIDE, {
+      bubbles: true,
+      cancelable: true
+    })
+
+    this._element.dispatchEvent(hideEvent)
+
+    if (hideEvent.defaultPrevented) {
+      return
+    }
+
+    this._isShown = false
+    this._isTransitioning = true
+    
+    // Deactivate focus trap and remove focus from modal element BEFORE removing class
+    this._focustrap.deactivate()
+    // Remove focus from modal element itself if it has focus
+    if (this._element === document.activeElement || this._element.contains(document.activeElement)) {
+      document.activeElement?.blur()
+    }
+
+    this._element.classList.remove(CLASS_NAME_SHOW)
+
+    this._queueCallback(() => this._hideModal(), this._element, this._isAnimated())
+  }
+
+  dispose() {
+    off(window, EVENT_KEY)
+    off(this._dialog, EVENT_KEY)
+
+    this._backdrop.dispose()
+    this._focustrap.deactivate()
+
+    super.dispose()
+  }
+
+  handleUpdate() {
+    this._adjustDialog()
+  }
+
+  // Private
+  _initializeBackDrop() {
+    const clickCallback = () => {
+      if (this._config.backdrop === 'static') {
+        this._triggerBackdropTransition()
+        return
+      }
+
+      if (this._config.backdrop) {
+        this.hide()
+      }
+    }
+
+    return new Backdrop({
+      isVisible: Boolean(this._config.backdrop),
+      isAnimated: this._isAnimated(),
+      clickCallback
+    })
+  }
+
+  _initializeFocusTrap() {
+    return new FocusTrap({
+      trapElement: this._element
+    })
+  }
+
+  _showElement(relatedTarget) {
+    // try to append dynamic modal
+    if (!document.body.contains(this._element)) {
+      document.body.append(this._element)
+    }
+
+    // Remove aria-hidden BEFORE setting display and focus
+    this._element.removeAttribute('aria-hidden')
+    
+    this._element.style.display = 'block'
+    this._element.setAttribute('aria-modal', true)
+    this._element.setAttribute('role', 'dialog')
+    this._element.scrollTop = 0
+
+    const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog)
+    if (modalBody) {
+      modalBody.scrollTop = 0
+    }
+
+    reflow(this._element)
+
+    this._element.classList.add(CLASS_NAME_SHOW)
+
+    const transitionComplete = () => {
+      if (this._config.focus) {
+        this._focustrap.activate()
+      }
+
+      this._isTransitioning = false
+      const shownEvent = new CustomEvent(EVENT_SHOWN, {
+        bubbles: true,
+        detail: { relatedTarget }
+      })
+      this._element.dispatchEvent(shownEvent)
+    }
+
+    this._queueCallback(transitionComplete, this._dialog, this._isAnimated())
+  }
+
+  _addEventListeners() {
+    on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
+      if (event.key !== ESCAPE_KEY) {
+        return
+      }
+
+      if (this._config.keyboard) {
+        this.hide()
+        return
+      }
+
+      this._triggerBackdropTransition()
+    })
+
+    on(window, EVENT_RESIZE, () => {
+      if (this._isShown && !this._isTransitioning) {
+        this._adjustDialog()
+      }
+    })
+
+    on(this._element, EVENT_MOUSEDOWN_DISMISS, (event) => {
+      // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
+      const clickHandler = (event2) => {
+        if (this._element !== event.target || this._element !== event2.target) {
+          return
+        }
+
+        if (this._config.backdrop === 'static') {
+          this._triggerBackdropTransition()
+          return
+        }
+
+        if (this._config.backdrop) {
+          this.hide()
+        }
+      }
+
+      one(this._element, EVENT_CLICK_DISMISS, clickHandler)
+    })
+  }
+
+  _hideModal() {
+    // Remove focus from any element inside the modal before hiding
+    const activeElement = document.activeElement
+    if (this._element.contains(activeElement)) {
+      activeElement.blur()
+    }
+    
+    // Remove focus from modal element itself if it has focus
+    if (this._element === document.activeElement) {
+      this._element.blur()
+    }
+    
+    this._element.style.display = 'none'
+    // Remove aria-modal and role first
+    this._element.removeAttribute('aria-modal')
+    this._element.removeAttribute('role')
+    this._isTransitioning = false
+
+    this._backdrop.hide(() => {
+      document.body.classList.remove(CLASS_NAME_OPEN)
+      this._resetAdjustments()
+      this._scrollBar.reset()
+      
+      // Ensure no element inside modal has focus before setting aria-hidden
+      const focusedElement = document.activeElement
+      if (this._element.contains(focusedElement) || this._element === focusedElement) {
+        // If focus is still inside modal, move it to body
+        document.body.focus()
+        // If body can't receive focus, blur the element
+        if (document.activeElement === focusedElement) {
+          focusedElement.blur()
+        }
+      }
+      
+      // Set aria-hidden after ensuring no focus is inside the modal
+      this._element.setAttribute('aria-hidden', 'true')
+      const hiddenEvent = new CustomEvent(EVENT_HIDDEN, { bubbles: true })
+      this._element.dispatchEvent(hiddenEvent)
+    })
+  }
+
+  _isAnimated() {
+    return this._element.classList.contains(CLASS_NAME_FADE)
+  }
+
+  _triggerBackdropTransition() {
+    const hideEvent = new CustomEvent(EVENT_HIDE_PREVENTED, {
+      bubbles: true,
+      cancelable: true
+    })
+    this._element.dispatchEvent(hideEvent)
+    if (hideEvent.defaultPrevented) {
+      return
+    }
+
+    const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight
+    const initialOverflowY = this._element.style.overflowY
+    // return if the following background transition hasn't yet completed
+    if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
+      return
+    }
+
+    if (!isModalOverflowing) {
+      this._element.style.overflowY = 'hidden'
+    }
+
+    this._element.classList.add(CLASS_NAME_STATIC)
+    this._queueCallback(() => {
+      this._element.classList.remove(CLASS_NAME_STATIC)
+      this._queueCallback(() => {
+        this._element.style.overflowY = initialOverflowY
+      }, this._dialog)
+    }, this._dialog)
+
+    this._element.focus()
+  }
+
+  /**
+   * The following methods are used to handle overflowing modals
+   */
+
+  _adjustDialog() {
+    const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight
+    const scrollbarWidth = this._scrollBar.getWidth()
+    const isBodyOverflowing = scrollbarWidth > 0
+
+    if (isBodyOverflowing && !isModalOverflowing) {
+      const property = isRTL() ? 'paddingLeft' : 'paddingRight'
+      this._element.style[property] = `${scrollbarWidth}px`
+    }
+
+    if (!isBodyOverflowing && isModalOverflowing) {
+      const property = isRTL() ? 'paddingRight' : 'paddingLeft'
+      this._element.style[property] = `${scrollbarWidth}px`
+    }
+  }
+
+  _resetAdjustments() {
+    this._element.style.paddingLeft = ''
+    this._element.style.paddingRight = ''
+  }
+
+  // Static
+  static jQueryInterface(config, relatedTarget) {
+    return this.each(function () {
+      const data = Modal.getOrCreateInstance(this, config)
+
+      if (typeof config !== 'string') {
+        return
+      }
+
+      if (typeof data[config] === 'undefined') {
+        throw new TypeError(`No method named "${config}"`)
+      }
+
+      data[config](relatedTarget)
+    })
+  }
+
+  static getOrCreateInstance(element, config = {}) {
+    if (!element._baseLineComponent) {
+      element._baseLineComponent = new Modal(element, config)
+    }
+    return element._baseLineComponent
+  }
+
+  static getInstance(element) {
+    return element._baseLineComponent || null
+  }
+}
+
+/**
+ * Data API implementation
+ */
+
+on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+  const target = SelectorEngine.getElementFromSelector(this)
+
+  if (['A', 'AREA'].includes(this.tagName)) {
+    event.preventDefault()
+  }
+
+    one(target, EVENT_SHOW, (showEvent) => {
+      if (showEvent.defaultPrevented) {
+        // only register focus restorer if modal will actually get shown
+        return
+      }
+
+      one(target, EVENT_HIDDEN, () => {
+        if (isVisible(this)) {
+          this.focus()
+        }
+      })
+    })
+
+  // avoid conflict when clicking modal toggler while another one is open
+  const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR)
+  if (alreadyOpen) {
+    Modal.getInstance(alreadyOpen).hide()
+  }
+
+  const data = Modal.getOrCreateInstance(target)
+
+  data.toggle(this)
+})
+
+enableDismissTrigger(Modal)
+
+export default Modal
+