@gitlab/duo-ui 3.0.0 → 3.0.1

package/src/vendor/bootstrap-vue/src/components/modal/modal.js

@@ -1,981 +0,0 @@
-import { COMPONENT_UID_KEY, extend } from '../../vue'
-import { NAME_MODAL } from '../../constants/components'
-import { IS_BROWSER } from '../../constants/env'
-import {
-  EVENT_NAME_CANCEL,
-  EVENT_NAME_CHANGE,
-  EVENT_NAME_CLOSE,
-  EVENT_NAME_HIDDEN,
-  EVENT_NAME_HIDE,
-  EVENT_NAME_OK,
-  EVENT_NAME_SHOW,
-  EVENT_NAME_SHOWN,
-  EVENT_NAME_TOGGLE,
-  EVENT_OPTIONS_NO_CAPTURE
-} from '../../constants/events'
-import { CODE_ESC } from '../../constants/key-codes'
-import {
-  PROP_TYPE_ARRAY_OBJECT_STRING,
-  PROP_TYPE_ARRAY_STRING,
-  PROP_TYPE_BOOLEAN,
-  PROP_TYPE_OBJECT,
-  PROP_TYPE_STRING
-} from '../../constants/props'
-import { HTMLElement } from '../../constants/safe-types'
-import {
-  SLOT_NAME_DEFAULT,
-  SLOT_NAME_MODAL_BACKDROP,
-  SLOT_NAME_MODAL_CANCEL,
-  SLOT_NAME_MODAL_FOOTER,
-  SLOT_NAME_MODAL_HEADER,
-  SLOT_NAME_MODAL_HEADER_CLOSE,
-  SLOT_NAME_MODAL_OK,
-  SLOT_NAME_MODAL_TITLE
-} from '../../constants/slots'
-import { arrayIncludes, concat } from '../../utils/array'
-import {
-  attemptFocus,
-  closest,
-  contains,
-  getActiveElement,
-  getTabables,
-  requestAF,
-  select
-} from '../../utils/dom'
-import { getRootActionEventName, getRootEventName, eventOn, eventOff } from '../../utils/events'
-import { htmlOrText } from '../../utils/html'
-import { identity } from '../../utils/identity'
-import { isString, isUndefinedOrNull } from '../../utils/inspect'
-import { makeModelMixin } from '../../utils/model'
-import { sortKeys } from '../../utils/object'
-import { observeDom } from '../../utils/observe-dom'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { attrsMixin } from '../../mixins/attrs'
-import { idMixin, props as idProps } from '../../mixins/id'
-import { listenOnDocumentMixin } from '../../mixins/listen-on-document'
-import { listenOnRootMixin } from '../../mixins/listen-on-root'
-import { listenOnWindowMixin } from '../../mixins/listen-on-window'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-import { scopedStyleMixin } from '../../mixins/scoped-style'
-import { BButton } from '../button/button'
-import { BButtonClose } from '../button/button-close'
-import { BVTransition } from '../transition/bv-transition'
-import { BVTransporter } from '../transporter/transporter'
-import { BvModalEvent } from './helpers/bv-modal-event.class'
-import { modalManager } from './helpers/modal-manager'
-
-// --- Constants ---
-
-const {
-  mixin: modelMixin,
-  props: modelProps,
-  prop: MODEL_PROP_NAME,
-  event: MODEL_EVENT_NAME
-} = makeModelMixin('visible', {
-  type: PROP_TYPE_BOOLEAN,
-  defaultValue: false,
-  event: EVENT_NAME_CHANGE
-})
-
-const TRIGGER_BACKDROP = 'backdrop'
-const TRIGGER_ESC = 'esc'
-const TRIGGER_FORCE = 'FORCE'
-const TRIGGER_TOGGLE = 'toggle'
-
-const BUTTON_CANCEL = 'cancel'
-// TODO: This should be renamed to 'close'
-const BUTTON_CLOSE = 'headerclose'
-const BUTTON_OK = 'ok'
-
-const BUTTONS = [BUTTON_CANCEL, BUTTON_CLOSE, BUTTON_OK]
-
-// `ObserveDom` config to detect changes in modal content
-// so that we can adjust the modal padding if needed
-const OBSERVER_CONFIG = {
-  subtree: true,
-  childList: true,
-  characterData: true,
-  attributes: true,
-  attributeFilter: ['style', 'class']
-}
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  sortKeys({
-    ...idProps,
-    ...modelProps,
-    ariaLabel: makeProp(PROP_TYPE_STRING),
-    autoFocusButton: makeProp(
-      PROP_TYPE_STRING,
-      null,
-      /* istanbul ignore next */ value => {
-        return isUndefinedOrNull(value) || arrayIncludes(BUTTONS, value)
-      }
-    ),
-    bodyClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    busy: makeProp(PROP_TYPE_BOOLEAN, false),
-    buttonSize: makeProp(PROP_TYPE_STRING),
-    cancelDisabled: makeProp(PROP_TYPE_BOOLEAN, false),
-    cancelTitle: makeProp(PROP_TYPE_STRING, 'Cancel'),
-    cancelTitleHtml: makeProp(PROP_TYPE_STRING),
-    cancelVariant: makeProp(PROP_TYPE_STRING, 'secondary'),
-    centered: makeProp(PROP_TYPE_BOOLEAN, false),
-    contentClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    dialogClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    footerClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    footerTag: makeProp(PROP_TYPE_STRING, 'footer'),
-    headerClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    headerCloseContent: makeProp(PROP_TYPE_STRING, '×'),
-    headerCloseLabel: makeProp(PROP_TYPE_STRING, 'Close'),
-    headerTag: makeProp(PROP_TYPE_STRING, 'header'),
-    // TODO: Rename to `noBackdrop` and deprecate `hideBackdrop`
-    hideBackdrop: makeProp(PROP_TYPE_BOOLEAN, false),
-    // TODO: Rename to `noFooter` and deprecate `hideFooter`
-    hideFooter: makeProp(PROP_TYPE_BOOLEAN, false),
-    // TODO: Rename to `noHeader` and deprecate `hideHeader`
-    hideHeader: makeProp(PROP_TYPE_BOOLEAN, false),
-    // TODO: Rename to `noHeaderClose` and deprecate `hideHeaderClose`
-    hideHeaderClose: makeProp(PROP_TYPE_BOOLEAN, false),
-    ignoreEnforceFocusSelector: makeProp(PROP_TYPE_ARRAY_STRING),
-    lazy: makeProp(PROP_TYPE_BOOLEAN, false),
-    modalClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    noCloseOnBackdrop: makeProp(PROP_TYPE_BOOLEAN, false),
-    noCloseOnEsc: makeProp(PROP_TYPE_BOOLEAN, false),
-    noEnforceFocus: makeProp(PROP_TYPE_BOOLEAN, false),
-    noFade: makeProp(PROP_TYPE_BOOLEAN, false),
-    noStacking: makeProp(PROP_TYPE_BOOLEAN, false),
-    okDisabled: makeProp(PROP_TYPE_BOOLEAN, false),
-    okOnly: makeProp(PROP_TYPE_BOOLEAN, false),
-    okTitle: makeProp(PROP_TYPE_STRING, 'OK'),
-    okTitleHtml: makeProp(PROP_TYPE_STRING),
-    okVariant: makeProp(PROP_TYPE_STRING, 'primary'),
-    // HTML Element, CSS selector string or Vue component instance
-    returnFocus: makeProp([HTMLElement, PROP_TYPE_OBJECT, PROP_TYPE_STRING]),
-    scrollable: makeProp(PROP_TYPE_BOOLEAN, false),
-    size: makeProp(PROP_TYPE_STRING, 'md'),
-    static: makeProp(PROP_TYPE_BOOLEAN, false),
-    title: makeProp(PROP_TYPE_STRING),
-    titleClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-    titleHtml: makeProp(PROP_TYPE_STRING),
-    titleSrOnly: makeProp(PROP_TYPE_BOOLEAN, false),
-    titleTag: makeProp(PROP_TYPE_STRING, 'h5')
-  }),
-  NAME_MODAL
-)
-
-// --- Main component ---
-
-// @vue/component
-export const BModal = /*#__PURE__*/ extend({
-  name: NAME_MODAL,
-  mixins: [
-    attrsMixin,
-    idMixin,
-    modelMixin,
-    listenOnDocumentMixin,
-    listenOnRootMixin,
-    listenOnWindowMixin,
-    normalizeSlotMixin,
-    scopedStyleMixin
-  ],
-  inheritAttrs: false,
-  props,
-  data() {
-    return {
-      isHidden: true, // If modal should not be in document
-      isVisible: false, // Controls modal visible state
-      isTransitioning: false, // Used for style control
-      isShow: false, // Used for style control
-      isBlock: false, // Used for style control
-      isOpening: false, // To signal that the modal is in the process of opening
-      isClosing: false, // To signal that the modal is in the process of closing
-      ignoreBackdropClick: false, // Used to signify if click out listener should ignore the click
-      isModalOverflowing: false,
-      // The following items are controlled by the modalManager instance
-      scrollbarWidth: 0,
-      zIndex: modalManager.getBaseZIndex(),
-      isTop: true,
-      isBodyOverflowing: false
-    }
-  },
-  computed: {
-    modalId() {
-      return this.safeId()
-    },
-    modalOuterId() {
-      return this.safeId('__BV_modal_outer_')
-    },
-    modalHeaderId() {
-      return this.safeId('__BV_modal_header_')
-    },
-    modalBodyId() {
-      return this.safeId('__BV_modal_body_')
-    },
-    modalTitleId() {
-      return this.safeId('__BV_modal_title_')
-    },
-    modalContentId() {
-      return this.safeId('__BV_modal_content_')
-    },
-    modalFooterId() {
-      return this.safeId('__BV_modal_footer_')
-    },
-    modalBackdropId() {
-      return this.safeId('__BV_modal_backdrop_')
-    },
-    modalClasses() {
-      return [
-        {
-          fade: !this.noFade,
-          show: this.isShow,
-          'd-block': this.isBlock
-        },
-        this.modalClass
-      ]
-    },
-    modalStyles() {
-      const sbWidth = `${this.scrollbarWidth}px`
-      return {
-        paddingLeft: !this.isBodyOverflowing && this.isModalOverflowing ? sbWidth : '',
-        paddingRight: this.isBodyOverflowing && !this.isModalOverflowing ? sbWidth : ''
-      }
-    },
-    dialogClasses() {
-      return [
-        {
-          [`modal-${this.size}`]: this.size,
-          'modal-dialog-centered': this.centered,
-          'modal-dialog-scrollable': this.scrollable
-        },
-        this.dialogClass
-      ]
-    },
-    titleClasses() {
-      return [{ 'sr-only': this.titleSrOnly }, this.titleClass]
-    },
-    modalOuterStyle() {
-      // Styles needed for proper stacking of modals
-      return {
-        position: 'absolute',
-        zIndex: this.zIndex
-      }
-    },
-    slotScope() {
-      return {
-        cancel: this.onCancel,
-        close: this.onClose,
-        hide: this.hide,
-        ok: this.onOk,
-        visible: this.isVisible
-      }
-    },
-    computeIgnoreEnforceFocusSelector() {
-      // Normalize to an single selector with selectors separated by `,`
-      return concat(this.ignoreEnforceFocusSelector)
-        .filter(identity)
-        .join(',')
-        .trim()
-    },
-    computedAttrs() {
-      // If the parent has a scoped style attribute, and the modal
-      // is portalled, add the scoped attribute to the modal wrapper
-      const scopedStyleAttrs = !this.static ? this.scopedStyleAttrs : {}
-
-      return {
-        ...scopedStyleAttrs,
-        ...this.bvAttrs,
-        id: this.modalOuterId
-      }
-    },
-    computedModalAttrs() {
-      const { isVisible, ariaLabel } = this
-
-      return {
-        id: this.modalId,
-        role: 'dialog',
-        'aria-hidden': isVisible ? null : 'true',
-        'aria-modal': isVisible ? 'true' : null,
-        'aria-label': ariaLabel,
-        'aria-labelledby':
-          this.hideHeader ||
-          ariaLabel ||
-          // TODO: Rename slot to `title` and deprecate `modal-title`
-          !(this.hasNormalizedSlot(SLOT_NAME_MODAL_TITLE) || this.titleHtml || this.title)
-            ? null
-            : this.modalTitleId,
-        'aria-describedby': this.modalBodyId
-      }
-    }
-  },
-  watch: {
-    [MODEL_PROP_NAME](newValue, oldValue) {
-      if (newValue !== oldValue) {
-        this[newValue ? 'show' : 'hide']()
-      }
-    }
-  },
-  created() {
-    // Define non-reactive properties
-    this.$_observer = null
-    this.$_returnFocus = this.returnFocus || null
-  },
-  mounted() {
-    // Set initial z-index as queried from the DOM
-    this.zIndex = modalManager.getBaseZIndex()
-    // Listen for events from others to either open or close ourselves
-    // and listen to all modals to enable/disable enforce focus
-    this.listenOnRoot(getRootActionEventName(NAME_MODAL, EVENT_NAME_SHOW), this.showHandler)
-    this.listenOnRoot(getRootActionEventName(NAME_MODAL, EVENT_NAME_HIDE), this.hideHandler)
-    this.listenOnRoot(getRootActionEventName(NAME_MODAL, EVENT_NAME_TOGGLE), this.toggleHandler)
-    // Listen for `bv:modal::show events`, and close ourselves if the
-    // opening modal not us
-    this.listenOnRoot(getRootEventName(NAME_MODAL, EVENT_NAME_SHOW), this.modalListener)
-    // Initially show modal?
-    if (this[MODEL_PROP_NAME] === true) {
-      this.$nextTick(this.show)
-    }
-  },
-  beforeDestroy() {
-    // Ensure everything is back to normal
-    modalManager.unregisterModal(this)
-    this.setObserver(false)
-    if (this.isVisible) {
-      this.isVisible = false
-      this.isShow = false
-      this.isTransitioning = false
-    }
-  },
-  methods: {
-    setObserver(on = false) {
-      this.$_observer && this.$_observer.disconnect()
-      this.$_observer = null
-      if (on) {
-        this.$_observer = observeDom(
-          this.$refs.content,
-          this.checkModalOverflow.bind(this),
-          OBSERVER_CONFIG
-        )
-      }
-    },
-    // Private method to update the v-model
-    updateModel(value) {
-      if (value !== this[MODEL_PROP_NAME]) {
-        this.$emit(MODEL_EVENT_NAME, value)
-      }
-    },
-    // Private method to create a BvModalEvent object
-    buildEvent(type, options = {}) {
-      return new BvModalEvent(type, {
-        // Default options
-        cancelable: false,
-        target: this.$refs.modal || this.$el || null,
-        relatedTarget: null,
-        trigger: null,
-        // Supplied options
-        ...options,
-        // Options that can't be overridden
-        vueTarget: this,
-        componentId: this.modalId
-      })
-    },
-    // Public method to show modal
-    show() {
-      if (this.isVisible || this.isOpening) {
-        // If already open, or in the process of opening, do nothing
-        /* istanbul ignore next */
-        return
-      }
-      /* istanbul ignore next */
-      if (this.isClosing) {
-        // If we are in the process of closing, wait until hidden before re-opening
-        /* istanbul ignore next */
-        this.$once(EVENT_NAME_HIDDEN, this.show)
-        /* istanbul ignore next */
-        return
-      }
-      this.isOpening = true
-      // Set the element to return focus to when closed
-      this.$_returnFocus = this.$_returnFocus || this.getActiveElement()
-      const showEvent = this.buildEvent(EVENT_NAME_SHOW, {
-        cancelable: true
-      })
-      this.emitEvent(showEvent)
-      // Don't show if canceled
-      if (showEvent.defaultPrevented || this.isVisible) {
-        this.isOpening = false
-        // Ensure the v-model reflects the current state
-        this.updateModel(false)
-        return
-      }
-      // Show the modal
-      this.doShow()
-    },
-    // Public method to hide modal
-    hide(trigger = '') {
-      if (!this.isVisible || this.isClosing) {
-        /* istanbul ignore next */
-        return
-      }
-      this.isClosing = true
-      const hideEvent = this.buildEvent(EVENT_NAME_HIDE, {
-        cancelable: trigger !== TRIGGER_FORCE,
-        trigger: trigger || null
-      })
-      // We emit specific event for one of the three built-in buttons
-      if (trigger === BUTTON_OK) {
-        this.$emit(EVENT_NAME_OK, hideEvent)
-      } else if (trigger === BUTTON_CANCEL) {
-        this.$emit(EVENT_NAME_CANCEL, hideEvent)
-      } else if (trigger === BUTTON_CLOSE) {
-        this.$emit(EVENT_NAME_CLOSE, hideEvent)
-      }
-      this.emitEvent(hideEvent)
-      // Hide if not canceled
-      if (hideEvent.defaultPrevented || !this.isVisible) {
-        this.isClosing = false
-        // Ensure v-model reflects current state
-        this.updateModel(true)
-        return
-      }
-      // Stop observing for content changes
-      this.setObserver(false)
-      // Trigger the hide transition
-      this.isVisible = false
-      // Update the v-model
-      this.updateModel(false)
-    },
-    // Public method to toggle modal visibility
-    toggle(triggerEl) {
-      if (triggerEl) {
-        this.$_returnFocus = triggerEl
-      }
-      if (this.isVisible) {
-        this.hide(TRIGGER_TOGGLE)
-      } else {
-        this.show()
-      }
-    },
-    // Private method to get the current document active element
-    getActiveElement() {
-      // Returning focus to `document.body` may cause unwanted scrolls,
-      // so we exclude setting focus on body
-      const activeElement = getActiveElement(IS_BROWSER ? [document.body] : [])
-      // Preset the fallback return focus value if it is not set
-      // `document.activeElement` should be the trigger element that was clicked or
-      // in the case of using the v-model, which ever element has current focus
-      // Will be overridden by some commands such as toggle, etc.
-      // Note: On IE 11, `document.activeElement` may be `null`
-      // So we test it for truthiness first
-      // https://github.com/bootstrap-vue/bootstrap-vue/issues/3206
-      return activeElement && activeElement.focus ? activeElement : null
-    },
-    // Private method to finish showing modal
-    doShow() {
-      /* istanbul ignore next: commenting out for now until we can test stacking */
-      if (modalManager.modalsAreOpen && this.noStacking) {
-        // If another modal(s) is already open, wait for it(them) to close
-        this.listenOnRootOnce(getRootEventName(NAME_MODAL, EVENT_NAME_HIDDEN), this.doShow)
-        return
-      }
-      modalManager.registerModal(this)
-      // Place modal in DOM
-      this.isHidden = false
-      this.$nextTick(() => {
-        // We do this in `$nextTick()` to ensure the modal is in DOM first
-        // before we show it
-        this.isVisible = true
-        this.isOpening = false
-        // Update the v-model
-        this.updateModel(true)
-        this.$nextTick(() => {
-          // Observe changes in modal content and adjust if necessary
-          // In a `$nextTick()` in case modal content is lazy
-          this.setObserver(true)
-        })
-      })
-    },
-    // Transition handlers
-    onBeforeEnter() {
-      this.isTransitioning = true
-      this.setResizeEvent(true)
-    },
-    onEnter() {
-      this.isBlock = true
-      // We add the `show` class 1 frame later
-      // `requestAF()` runs the callback before the next repaint, so we need
-      // two calls to guarantee the next frame has been rendered
-      requestAF(() => {
-        requestAF(() => {
-          this.isShow = true
-        })
-      })
-    },
-    onAfterEnter() {
-      this.checkModalOverflow()
-      this.isTransitioning = false
-      // We use `requestAF()` to allow transition hooks to complete
-      // before passing control over to the other handlers
-      // This will allow users to not have to use `$nextTick()` or `requestAF()`
-      // when trying to pre-focus an element
-      requestAF(() => {
-        this.emitEvent(this.buildEvent(EVENT_NAME_SHOWN))
-        this.setEnforceFocus(true)
-        this.$nextTick(() => {
-          // Delayed in a `$nextTick()` to allow users time to pre-focus
-          // an element if the wish
-          this.focusFirst()
-        })
-      })
-    },
-    onBeforeLeave() {
-      this.isTransitioning = true
-      this.setResizeEvent(false)
-      this.setEnforceFocus(false)
-    },
-    onLeave() {
-      // Remove the 'show' class
-      this.isShow = false
-    },
-    onAfterLeave() {
-      this.isBlock = false
-      this.isTransitioning = false
-      this.isModalOverflowing = false
-      this.isHidden = true
-      this.$nextTick(() => {
-        this.isClosing = false
-        modalManager.unregisterModal(this)
-        this.returnFocusTo()
-        // TODO: Need to find a way to pass the `trigger` property
-        //       to the `hidden` event, not just only the `hide` event
-        this.emitEvent(this.buildEvent(EVENT_NAME_HIDDEN))
-      })
-    },
-    emitEvent(bvEvent) {
-      const { type } = bvEvent
-      // We emit on `$root` first in case a global listener wants to cancel
-      // the event first before the instance emits its event
-      this.emitOnRoot(getRootEventName(NAME_MODAL, type), bvEvent, bvEvent.componentId)
-      this.$emit(type, bvEvent)
-    },
-    // UI event handlers
-    onDialogMousedown() {
-      // Watch to see if the matching mouseup event occurs outside the dialog
-      // And if it does, cancel the clickOut handler
-      const modal = this.$refs.modal
-      const onceModalMouseup = event => {
-        eventOff(modal, 'mouseup', onceModalMouseup, EVENT_OPTIONS_NO_CAPTURE)
-        if (event.target === modal) {
-          this.ignoreBackdropClick = true
-        }
-      }
-      eventOn(modal, 'mouseup', onceModalMouseup, EVENT_OPTIONS_NO_CAPTURE)
-    },
-    onClickOut(event) {
-      if (this.ignoreBackdropClick) {
-        // Click was initiated inside the modal content, but finished outside.
-        // Set by the above onDialogMousedown handler
-        this.ignoreBackdropClick = false
-        return
-      }
-      // Do nothing if not visible, backdrop click disabled, or element
-      // that generated click event is no longer in document body
-      if (!this.isVisible || this.noCloseOnBackdrop || !contains(document.body, event.target)) {
-        return
-      }
-      // If backdrop clicked, hide modal
-      if (!contains(this.$refs.content, event.target)) {
-        this.hide(TRIGGER_BACKDROP)
-      }
-    },
-    onOk() {
-      this.hide(BUTTON_OK)
-    },
-    onCancel() {
-      this.hide(BUTTON_CANCEL)
-    },
-    onClose() {
-      this.hide(BUTTON_CLOSE)
-    },
-    onEsc(event) {
-      // If ESC pressed, hide modal
-      if (event.keyCode === CODE_ESC && this.isVisible && !this.noCloseOnEsc) {
-        this.hide(TRIGGER_ESC)
-      }
-    },
-    // Document focusin listener
-    focusHandler(event) {
-      // If focus leaves modal content, bring it back
-      const content = this.$refs.content
-      const { target } = event
-      if (
-        this.noEnforceFocus ||
-        !this.isTop ||
-        !this.isVisible ||
-        !content ||
-        document === target ||
-        contains(content, target) ||
-        (this.computeIgnoreEnforceFocusSelector &&
-          closest(this.computeIgnoreEnforceFocusSelector, target, true))
-      ) {
-        return
-      }
-      const tabables = getTabables(this.$refs.content)
-      const bottomTrap = this.$refs['bottom-trap']
-      const topTrap = this.$refs['top-trap']
-      if (bottomTrap && target === bottomTrap) {
-        // If user pressed TAB out of modal into our bottom trab trap element
-        // Find the first tabable element in the modal content and focus it
-        if (attemptFocus(tabables[0])) {
-          // Focus was successful
-          return
-        }
-      } else if (topTrap && target === topTrap) {
-        // If user pressed CTRL-TAB out of modal and into our top tab trap element
-        // Find the last tabable element in the modal content and focus it
-        if (attemptFocus(tabables[tabables.length - 1])) {
-          // Focus was successful
-          return
-        }
-      }
-      // Otherwise focus the modal content container
-      attemptFocus(content, { preventScroll: true })
-    },
-    // Turn on/off focusin listener
-    setEnforceFocus(on) {
-      this.listenDocument(on, 'focusin', this.focusHandler)
-    },
-    // Resize listener
-    setResizeEvent(on) {
-      this.listenWindow(on, 'resize', this.checkModalOverflow)
-      this.listenWindow(on, 'orientationchange', this.checkModalOverflow)
-    },
-    // Root listener handlers
-    showHandler(id, triggerEl) {
-      if (id === this.modalId) {
-        this.$_returnFocus = triggerEl || this.getActiveElement()
-        this.show()
-      }
-    },
-    hideHandler(id) {
-      if (id === this.modalId) {
-        this.hide('event')
-      }
-    },
-    toggleHandler(id, triggerEl) {
-      if (id === this.modalId) {
-        this.toggle(triggerEl)
-      }
-    },
-    modalListener(bvEvent) {
-      // If another modal opens, close this one if stacking not permitted
-      if (this.noStacking && bvEvent.vueTarget !== this) {
-        this.hide()
-      }
-    },
-    // Focus control handlers
-    focusFirst() {
-      // Don't try and focus if we are SSR
-      if (IS_BROWSER) {
-        requestAF(() => {
-          const modal = this.$refs.modal
-          const content = this.$refs.content
-          const activeElement = this.getActiveElement()
-          // If the modal contains the activeElement, we don't do anything
-          if (modal && content && !(activeElement && contains(content, activeElement))) {
-            const ok = this.$refs['ok-button']
-            const cancel = this.$refs['cancel-button']
-            const close = this.$refs['close-button']
-            // Focus the appropriate button or modal content wrapper
-            const autoFocus = this.autoFocusButton
-            /* istanbul ignore next */
-            const el =
-              autoFocus === BUTTON_OK && ok
-                ? ok.$el || ok
-                : autoFocus === BUTTON_CANCEL && cancel
-                  ? cancel.$el || cancel
-                  : autoFocus === BUTTON_CLOSE && close
-                    ? close.$el || close
-                    : content
-            // Focus the element
-            attemptFocus(el)
-            if (el === content) {
-              // Make sure top of modal is showing (if longer than the viewport)
-              this.$nextTick(() => {
-                modal.scrollTop = 0
-              })
-            }
-          }
-        })
-      }
-    },
-    returnFocusTo() {
-      // Prefer `returnFocus` prop over event specified
-      // `return_focus` value
-      let el = this.returnFocus || this.$_returnFocus || null
-      this.$_returnFocus = null
-      this.$nextTick(() => {
-        // Is el a string CSS selector?
-        el = isString(el) ? select(el) : el
-        if (el) {
-          // Possibly could be a component reference
-          el = el.$el || el
-          attemptFocus(el)
-        }
-      })
-    },
-    checkModalOverflow() {
-      if (this.isVisible) {
-        const modal = this.$refs.modal
-        this.isModalOverflowing = modal.scrollHeight > document.documentElement.clientHeight
-      }
-    },
-    makeModal(h) {
-      // Modal header
-      let $header = h()
-      if (!this.hideHeader) {
-        // TODO: Rename slot to `header` and deprecate `modal-header`
-        let $modalHeader = this.normalizeSlot(SLOT_NAME_MODAL_HEADER, this.slotScope)
-        if (!$modalHeader) {
-          let $closeButton = h()
-          if (!this.hideHeaderClose) {
-            $closeButton = h(
-              BButtonClose,
-              {
-                props: {
-                  content: this.headerCloseContent,
-                  disabled: this.isTransitioning,
-                  ariaLabel: this.headerCloseLabel
-                },
-                on: { click: this.onClose },
-                ref: 'close-button'
-              },
-              // TODO: Rename slot to `header-close` and deprecate `modal-header-close`
-              [this.normalizeSlot(SLOT_NAME_MODAL_HEADER_CLOSE)]
-            )
-          }
-
-          $modalHeader = [
-            h(
-              this.titleTag,
-              {
-                staticClass: 'modal-title',
-                class: this.titleClasses,
-                attrs: { id: this.modalTitleId },
-                // TODO: Rename slot to `title` and deprecate `modal-title`
-                domProps: this.hasNormalizedSlot(SLOT_NAME_MODAL_TITLE)
-                  ? {}
-                  : htmlOrText(this.titleHtml, this.title)
-              },
-              // TODO: Rename slot to `title` and deprecate `modal-title`
-              this.normalizeSlot(SLOT_NAME_MODAL_TITLE, this.slotScope)
-            ),
-            $closeButton
-          ]
-        }
-
-        $header = h(
-          this.headerTag,
-          {
-            staticClass: 'modal-header',
-            class: this.headerClass,
-            attrs: { id: this.modalHeaderId },
-            ref: 'header'
-          },
-          [$modalHeader]
-        )
-      }
-
-      // Modal body
-      const $body = h(
-        'div',
-        {
-          staticClass: 'modal-body',
-          class: this.bodyClass,
-          attrs: { id: this.modalBodyId },
-          ref: 'body'
-        },
-        this.normalizeSlot(SLOT_NAME_DEFAULT, this.slotScope)
-      )
-
-      // Modal footer
-      let $footer = h()
-      if (!this.hideFooter) {
-        // TODO: Rename slot to `footer` and deprecate `modal-footer`
-        let $modalFooter = this.normalizeSlot(SLOT_NAME_MODAL_FOOTER, this.slotScope)
-        if (!$modalFooter) {
-          let $cancelButton = h()
-          if (!this.okOnly) {
-            $cancelButton = h(
-              BButton,
-              {
-                props: {
-                  variant: this.cancelVariant,
-                  size: this.buttonSize,
-                  disabled: this.cancelDisabled || this.busy || this.isTransitioning
-                },
-                // TODO: Rename slot to `cancel-button` and deprecate `modal-cancel`
-                domProps: this.hasNormalizedSlot(SLOT_NAME_MODAL_CANCEL)
-                  ? {}
-                  : htmlOrText(this.cancelTitleHtml, this.cancelTitle),
-                on: { click: this.onCancel },
-                ref: 'cancel-button'
-              },
-              // TODO: Rename slot to `cancel-button` and deprecate `modal-cancel`
-              this.normalizeSlot(SLOT_NAME_MODAL_CANCEL)
-            )
-          }
-
-          const $okButton = h(
-            BButton,
-            {
-              props: {
-                variant: this.okVariant,
-                size: this.buttonSize,
-                disabled: this.okDisabled || this.busy || this.isTransitioning
-              },
-              // TODO: Rename slot to `ok-button` and deprecate `modal-ok`
-              domProps: this.hasNormalizedSlot(SLOT_NAME_MODAL_OK)
-                ? {}
-                : htmlOrText(this.okTitleHtml, this.okTitle),
-              on: { click: this.onOk },
-              ref: 'ok-button'
-            },
-            // TODO: Rename slot to `ok-button` and deprecate `modal-ok`
-            this.normalizeSlot(SLOT_NAME_MODAL_OK)
-          )
-
-          $modalFooter = [$cancelButton, $okButton]
-        }
-
-        $footer = h(
-          this.footerTag,
-          {
-            staticClass: 'modal-footer',
-            class: this.footerClass,
-            attrs: { id: this.modalFooterId },
-            ref: 'footer'
-          },
-          [$modalFooter]
-        )
-      }
-
-      // Assemble modal content
-      const $modalContent = h(
-        'div',
-        {
-          staticClass: 'modal-content',
-          class: this.contentClass,
-          attrs: {
-            id: this.modalContentId,
-            tabindex: '-1'
-          },
-          ref: 'content'
-        },
-        [$header, $body, $footer]
-      )
-
-      // Tab traps to prevent page from scrolling to next element in
-      // tab index during enforce-focus tab cycle
-      let $tabTrapTop = h()
-      let $tabTrapBottom = h()
-      if (this.isVisible && !this.noEnforceFocus) {
-        $tabTrapTop = h('span', {
-          attrs: { tabindex: '0' },
-          ref: 'top-trap'
-        })
-        $tabTrapBottom = h('span', {
-          attrs: { tabindex: '0' },
-          ref: 'bottom-trap'
-        })
-      }
-
-      // Modal dialog wrapper
-      const $modalDialog = h(
-        'div',
-        {
-          staticClass: 'modal-dialog',
-          class: this.dialogClasses,
-          on: { mousedown: this.onDialogMousedown },
-          ref: 'dialog'
-        },
-        [$tabTrapTop, $modalContent, $tabTrapBottom]
-      )
-
-      // Modal
-      let $modal = h(
-        'div',
-        {
-          staticClass: 'modal',
-          class: this.modalClasses,
-          style: this.modalStyles,
-          attrs: this.computedModalAttrs,
-          on: { keydown: this.onEsc, click: this.onClickOut },
-          directives: [{ name: 'show', value: this.isVisible }],
-          ref: 'modal'
-        },
-        [$modalDialog]
-      )
-
-      // Wrap modal in transition
-      // Sadly, we can't use `BVTransition` here due to the differences in
-      // transition durations for `.modal` and `.modal-dialog`
-      // At least until https://github.com/vuejs/vue/issues/9986 is resolved
-      $modal = h(
-        'transition',
-        {
-          props: {
-            enterClass: '',
-            enterToClass: '',
-            enterActiveClass: '',
-            leaveClass: '',
-            leaveActiveClass: '',
-            leaveToClass: ''
-          },
-          on: {
-            beforeEnter: this.onBeforeEnter,
-            enter: this.onEnter,
-            afterEnter: this.onAfterEnter,
-            beforeLeave: this.onBeforeLeave,
-            leave: this.onLeave,
-            afterLeave: this.onAfterLeave
-          }
-        },
-        [$modal]
-      )
-
-      // Modal backdrop
-      let $backdrop = h()
-      if (!this.hideBackdrop && this.isVisible) {
-        $backdrop = h(
-          'div',
-          {
-            staticClass: 'modal-backdrop',
-            attrs: { id: this.modalBackdropId }
-          },
-          // TODO: Rename slot to `backdrop` and deprecate `modal-backdrop`
-          this.normalizeSlot(SLOT_NAME_MODAL_BACKDROP)
-        )
-      }
-      $backdrop = h(BVTransition, { props: { noFade: this.noFade } }, [$backdrop])
-
-      // Assemble modal and backdrop in an outer <div>
-      return h(
-        'div',
-        {
-          style: this.modalOuterStyle,
-          attrs: this.computedAttrs,
-          key: `modal-outer-${this[COMPONENT_UID_KEY]}`
-        },
-        [$modal, $backdrop]
-      )
-    }
-  },
-  render(h) {
-    if (this.static) {
-      return this.lazy && this.isHidden ? h() : this.makeModal(h)
-    } else {
-      return this.isHidden ? h() : h(BVTransporter, [this.makeModal(h)])
-    }
-  }
-})