@gitlab/duo-ui 0.1.0

package/src/vendor/bootstrap-vue/src/components/layout/form-row.js

@@ -0,0 +1,31 @@
+import { extend, mergeData } from '../../vue'
+import { NAME_FORM_ROW } from '../../constants/components'
+import { PROP_TYPE_STRING } from '../../constants/props'
+import { makeProp, makePropsConfigurable } from '../../utils/props'
+
+// --- Props ---
+
+export const props = makePropsConfigurable(
+  {
+    tag: makeProp(PROP_TYPE_STRING, 'div')
+  },
+  NAME_FORM_ROW
+)
+
+// --- Main component ---
+
+// @vue/component
+export const BFormRow = /*#__PURE__*/ extend({
+  name: NAME_FORM_ROW,
+  functional: true,
+  props,
+  render(h, { props, data, children }) {
+    return h(
+      props.tag,
+      mergeData(data, {
+        staticClass: 'form-row'
+      }),
+      children
+    )
+  }
+})

package/src/vendor/bootstrap-vue/src/components/layout/index.js

@@ -0,0 +1,4 @@
+import { BCol } from './col'
+import { BFormRow } from './form-row'
+
+export { BCol, BFormRow }

package/src/vendor/bootstrap-vue/src/components/link/index.js

@@ -0,0 +1,3 @@
+import { BLink } from './link'
+
+export { BLink }

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

@@ -0,0 +1,212 @@
+import { extend } from '../../vue'
+import { NAME_LINK } from '../../constants/components'
+import { EVENT_NAME_CLICK } from '../../constants/events'
+import {
+  PROP_TYPE_ARRAY_STRING,
+  PROP_TYPE_BOOLEAN,
+  PROP_TYPE_OBJECT_STRING,
+  PROP_TYPE_STRING
+} from '../../constants/props'
+import { concat } from '../../utils/array'
+import { attemptBlur, attemptFocus, isTag } from '../../utils/dom'
+import { getRootEventName, stopEvent } from '../../utils/events'
+import { isBoolean, isEvent, isFunction, isUndefined } from '../../utils/inspect'
+import { omit, sortKeys } from '../../utils/object'
+import { makeProp, makePropsConfigurable, pluckProps } from '../../utils/props'
+import { computeHref, computeRel, computeTag, isRouterLink } from '../../utils/router'
+import { attrsMixin } from '../../mixins/attrs'
+import { listenOnRootMixin } from '../../mixins/listen-on-root'
+import { listenersMixin } from '../../mixins/listeners'
+import { normalizeSlotMixin } from '../../mixins/normalize-slot'
+
+// --- Constants ---
+
+const ROOT_EVENT_NAME_CLICKED = getRootEventName(NAME_LINK, 'clicked')
+
+// --- Props ---
+
+// `<router-link>` specific props
+export const routerLinkProps = {
+  activeClass: makeProp(PROP_TYPE_STRING),
+  append: makeProp(PROP_TYPE_BOOLEAN, false),
+  event: makeProp(PROP_TYPE_ARRAY_STRING),
+  exact: makeProp(PROP_TYPE_BOOLEAN, false),
+  exactActiveClass: makeProp(PROP_TYPE_STRING),
+  exactPath: makeProp(PROP_TYPE_BOOLEAN, false),
+  exactPathActiveClass: makeProp(PROP_TYPE_STRING),
+  replace: makeProp(PROP_TYPE_BOOLEAN, false),
+  routerTag: makeProp(PROP_TYPE_STRING),
+  to: makeProp(PROP_TYPE_OBJECT_STRING)
+}
+
+// `<nuxt-link>` specific props
+export const nuxtLinkProps = {
+  noPrefetch: makeProp(PROP_TYPE_BOOLEAN, false),
+  // Must be `null` to fall back to the value defined in the
+  // `nuxt.config.js` configuration file for `router.prefetchLinks`
+  // We convert `null` to `undefined`, so that Nuxt.js will use the
+  // compiled default
+  // Vue treats `undefined` as default of `false` for Boolean props,
+  // so we must set it as `null` here to be a true tri-state prop
+  prefetch: makeProp(PROP_TYPE_BOOLEAN, null)
+}
+
+// All `<b-link>` props
+export const props = makePropsConfigurable(
+  sortKeys({
+    ...nuxtLinkProps,
+    ...routerLinkProps,
+    active: makeProp(PROP_TYPE_BOOLEAN, false),
+    disabled: makeProp(PROP_TYPE_BOOLEAN, false),
+    href: makeProp(PROP_TYPE_STRING),
+    // Must be `null` if no value provided
+    rel: makeProp(PROP_TYPE_STRING, null),
+    // To support 3rd party router links based on `<router-link>` (i.e. `g-link` for Gridsome)
+    // Default is to auto choose between `<router-link>` and `<nuxt-link>`
+    // Gridsome doesn't provide a mechanism to auto detect and has caveats
+    // such as not supporting FQDN URLs or hash only URLs
+    routerComponentName: makeProp(PROP_TYPE_STRING),
+    target: makeProp(PROP_TYPE_STRING, '_self')
+  }),
+  NAME_LINK
+)
+
+// --- Main component ---
+
+// @vue/component
+export const BLink = /*#__PURE__*/ extend({
+  name: NAME_LINK,
+  // Mixin order is important!
+  mixins: [attrsMixin, listenersMixin, listenOnRootMixin, normalizeSlotMixin],
+  inheritAttrs: false,
+  props,
+  computed: {
+    computedTag() {
+      // We don't pass `this` as the first arg as we need reactivity of the props
+      const { to, disabled, routerComponentName } = this
+      return computeTag({ to, disabled, routerComponentName }, this)
+    },
+    isRouterLink() {
+      return isRouterLink(this.computedTag)
+    },
+    computedRel() {
+      // We don't pass `this` as the first arg as we need reactivity of the props
+      const { target, rel } = this
+      return computeRel({ target, rel })
+    },
+    computedHref() {
+      // We don't pass `this` as the first arg as we need reactivity of the props
+      const { to, href } = this
+      return computeHref({ to, href }, this.computedTag)
+    },
+    computedProps() {
+      const { event, prefetch, routerTag } = this
+      return this.isRouterLink
+        ? {
+            ...pluckProps(
+              omit(
+                { ...routerLinkProps, ...(this.computedTag === 'nuxt-link' ? nuxtLinkProps : {}) },
+                ['event', 'prefetch', 'routerTag']
+              ),
+              this
+            ),
+            // Only add these props, when actually defined
+            ...(event ? { event } : {}),
+            ...(isBoolean(prefetch) ? { prefetch } : {}),
+            // Pass `router-tag` as `tag` prop
+            ...(routerTag ? { tag: routerTag } : {})
+          }
+        : {}
+    },
+    computedAttrs() {
+      const {
+        bvAttrs,
+        computedHref: href,
+        computedRel: rel,
+        disabled,
+        target,
+        routerTag,
+        isRouterLink
+      } = this
+
+      return {
+        ...bvAttrs,
+        // If `href` attribute exists on `<router-link>` (even `undefined` or `null`)
+        // it fails working on SSR, so we explicitly add it here if needed
+        // (i.e. if `computedHref` is truthy)
+        ...(href ? { href } : {}),
+        // We don't render `rel` or `target` on non link tags when using `vue-router`
+        ...(isRouterLink && routerTag && !isTag(routerTag, 'a') ? {} : { rel, target }),
+        tabindex: disabled ? '-1' : isUndefined(bvAttrs.tabindex) ? null : bvAttrs.tabindex,
+        'aria-disabled': disabled ? 'true' : null
+      }
+    },
+    computedListeners() {
+      return {
+        // Transfer all listeners (native) to the root element
+        ...this.bvListeners,
+        // We want to overwrite any click handler since our callback
+        // will invoke the user supplied handler(s) if `!this.disabled`
+        click: this.onClick
+      }
+    }
+  },
+  methods: {
+    onClick(event) {
+      const eventIsEvent = isEvent(event)
+      const isRouterLink = this.isRouterLink
+      const suppliedHandler = this.bvListeners.click
+      if (eventIsEvent && this.disabled) {
+        // Stop event from bubbling up
+        // Kill the event loop attached to this specific `EventTarget`
+        // Needed to prevent `vue-router` for doing its thing
+        stopEvent(event, { immediatePropagation: true })
+      } else {
+        // Router links do not emit instance `click` events, so we
+        // add in an `$emit('click', event)` on its Vue instance
+        //
+        // seems not to be required for Vue3 compat build
+        /* istanbul ignore next: difficult to test, but we know it works */
+        if (isRouterLink) {
+          event.currentTarget.__vue__?.$emit(EVENT_NAME_CLICK, event)
+        }
+        // Call the suppliedHandler(s), if any provided
+        concat(suppliedHandler)
+          .filter(h => isFunction(h))
+          .forEach(handler => {
+            handler(...arguments)
+          })
+        // Emit the global `$root` click event
+        this.emitOnRoot(ROOT_EVENT_NAME_CLICKED, event)
+        // TODO: Remove deprecated 'clicked::link' event with next major release
+        this.emitOnRoot('clicked::link', event)
+      }
+      // Stop scroll-to-top behavior or navigation on
+      // regular links when href is just '#'
+      if (eventIsEvent && !isRouterLink && this.computedHref === '#') {
+        stopEvent(event, { propagation: false })
+      }
+    },
+    focus() {
+      attemptFocus(this.$el)
+    },
+    blur() {
+      attemptBlur(this.$el)
+    }
+  },
+  render(h) {
+    const { active, disabled } = this
+
+    return h(
+      this.computedTag,
+      {
+        class: { active, disabled },
+        attrs: this.computedAttrs,
+        props: this.computedProps,
+        // We must use `nativeOn` for `<router-link>`/`<nuxt-link>` instead of `on`
+        [this.isRouterLink ? 'nativeOn' : 'on']: this.computedListeners
+      },
+      this.normalizeSlot()
+    )
+  }
+})

package/src/vendor/bootstrap-vue/src/components/modal/_modal.scss

@@ -0,0 +1,5 @@
+// Needed to allow Vue transition system to work with Bootstrap v4 .modal-backdrop
+// as modal opacity is 1 by default
+.modal-backdrop {
+  opacity: $modal-backdrop-opacity;
+}

package/src/vendor/bootstrap-vue/src/components/modal/helpers/bv-modal-event.class.js

@@ -0,0 +1,22 @@
+import { BvEvent } from '../../../utils/bv-event.class'
+import { defineProperties, readonlyDescriptor } from '../../../utils/object'
+
+class BvModalEvent extends BvEvent {
+  constructor(type, eventInit = {}) {
+    super(type, eventInit)
+    // Freeze our new props as readonly, but leave them enumerable
+    defineProperties(this, {
+      trigger: readonlyDescriptor()
+    })
+  }
+
+  static get Defaults() {
+    return {
+      ...super.Defaults,
+      trigger: null
+    }
+  }
+}
+
+// Named exports
+export { BvModalEvent }

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

@@ -0,0 +1,219 @@
+/**
+ * Private ModalManager helper
+ * Handles controlling modal stacking zIndexes and body adjustments/classes
+ */
+
+import { extend } from '../../../vue'
+import { IS_BROWSER } from '../../../constants/env'
+import {
+  addClass,
+  getAttr,
+  getBCR,
+  getCS,
+  getStyle,
+  hasAttr,
+  removeAttr,
+  removeClass,
+  requestAF,
+  selectAll,
+  setAttr,
+  setStyle
+} from '../../../utils/dom'
+import { isNull } from '../../../utils/inspect'
+import { toFloat, toInteger } from '../../../utils/number'
+
+// --- Constants ---
+
+// Default modal backdrop z-index
+const DEFAULT_ZINDEX = 1040
+
+// Selectors for padding/margin adjustments
+const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'
+const SELECTOR_STICKY_CONTENT = '.sticky-top'
+const SELECTOR_NAVBAR_TOGGLER = '.navbar-toggler'
+
+// --- Main component ---
+
+// @vue/component
+const ModalManager = /*#__PURE__*/ extend({
+  data() {
+    return {
+      modals: [],
+      baseZIndex: null,
+      scrollbarWidth: null,
+      isBodyOverflowing: false
+    }
+  },
+  computed: {
+    modalCount() {
+      return this.modals.length
+    },
+    modalsAreOpen() {
+      return this.modalCount > 0
+    }
+  },
+  watch: {
+    modalCount(newCount, oldCount) {
+      if (IS_BROWSER) {
+        this.getScrollbarWidth()
+        if (newCount > 0 && oldCount === 0) {
+          // Transitioning to modal(s) open
+          this.checkScrollbar()
+          this.setScrollbar()
+          addClass(document.body, 'modal-open')
+        } else if (newCount === 0 && oldCount > 0) {
+          // Transitioning to modal(s) closed
+          this.resetScrollbar()
+          removeClass(document.body, 'modal-open')
+        }
+        setAttr(document.body, 'data-modal-open-count', String(newCount))
+      }
+    },
+    modals(newValue) {
+      this.checkScrollbar()
+      requestAF(() => {
+        this.updateModals(newValue || [])
+      })
+    }
+  },
+  methods: {
+    // Public methods
+    registerModal(modal) {
+      // Register the modal if not already registered
+      if (modal && this.modals.indexOf(modal) === -1) {
+        this.modals.push(modal)
+      }
+    },
+    unregisterModal(modal) {
+      const index = this.modals.indexOf(modal)
+      if (index > -1) {
+        // Remove modal from modals array
+        this.modals.splice(index, 1)
+        // Reset the modal's data
+        if (!modal._isBeingDestroyed && !modal._isDestroyed) {
+          this.resetModal(modal)
+        }
+      }
+    },
+    getBaseZIndex() {
+      if (IS_BROWSER && isNull(this.baseZIndex)) {
+        // Create a temporary `div.modal-backdrop` to get computed z-index
+        const div = document.createElement('div')
+        addClass(div, 'modal-backdrop')
+        addClass(div, 'd-none')
+        setStyle(div, 'display', 'none')
+        document.body.appendChild(div)
+        this.baseZIndex = toInteger(getCS(div).zIndex, DEFAULT_ZINDEX)
+        document.body.removeChild(div)
+      }
+      return this.baseZIndex || DEFAULT_ZINDEX
+    },
+    getScrollbarWidth() {
+      if (IS_BROWSER && isNull(this.scrollbarWidth)) {
+        // Create a temporary `div.measure-scrollbar` to get computed z-index
+        const div = document.createElement('div')
+        addClass(div, 'modal-scrollbar-measure')
+        document.body.appendChild(div)
+        this.scrollbarWidth = getBCR(div).width - div.clientWidth
+        document.body.removeChild(div)
+      }
+      return this.scrollbarWidth || 0
+    },
+    // Private methods
+    updateModals(modals) {
+      const baseZIndex = this.getBaseZIndex()
+      const scrollbarWidth = this.getScrollbarWidth()
+      modals.forEach((modal, index) => {
+        // We update data values on each modal
+        modal.zIndex = baseZIndex + index
+        modal.scrollbarWidth = scrollbarWidth
+        modal.isTop = index === this.modals.length - 1
+        modal.isBodyOverflowing = this.isBodyOverflowing
+      })
+    },
+    resetModal(modal) {
+      if (modal) {
+        modal.zIndex = this.getBaseZIndex()
+        modal.isTop = true
+        modal.isBodyOverflowing = false
+      }
+    },
+    checkScrollbar() {
+      // Determine if the body element is overflowing
+      const { left, right } = getBCR(document.body)
+      this.isBodyOverflowing = left + right < window.innerWidth
+    },
+    setScrollbar() {
+      const body = document.body
+      // Storage place to cache changes to margins and padding
+      // Note: This assumes the following element types are not added to the
+      // document after the modal has opened.
+      body._paddingChangedForModal = body._paddingChangedForModal || []
+      body._marginChangedForModal = body._marginChangedForModal || []
+      if (this.isBodyOverflowing) {
+        const scrollbarWidth = this.scrollbarWidth
+        // Adjust fixed content padding
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_FIXED_CONTENT).forEach(el => {
+          const actualPadding = getStyle(el, 'paddingRight') || ''
+          setAttr(el, 'data-padding-right', actualPadding)
+          setStyle(el, 'paddingRight', `${toFloat(getCS(el).paddingRight, 0) + scrollbarWidth}px`)
+          body._paddingChangedForModal.push(el)
+        })
+        // Adjust sticky content margin
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_STICKY_CONTENT).forEach(el => /* istanbul ignore next */ {
+          const actualMargin = getStyle(el, 'marginRight') || ''
+          setAttr(el, 'data-margin-right', actualMargin)
+          setStyle(el, 'marginRight', `${toFloat(getCS(el).marginRight, 0) - scrollbarWidth}px`)
+          body._marginChangedForModal.push(el)
+        })
+        // Adjust <b-navbar-toggler> margin
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_NAVBAR_TOGGLER).forEach(el => /* istanbul ignore next */ {
+          const actualMargin = getStyle(el, 'marginRight') || ''
+          setAttr(el, 'data-margin-right', actualMargin)
+          setStyle(el, 'marginRight', `${toFloat(getCS(el).marginRight, 0) + scrollbarWidth}px`)
+          body._marginChangedForModal.push(el)
+        })
+        // Adjust body padding
+        const actualPadding = getStyle(body, 'paddingRight') || ''
+        setAttr(body, 'data-padding-right', actualPadding)
+        setStyle(body, 'paddingRight', `${toFloat(getCS(body).paddingRight, 0) + scrollbarWidth}px`)
+      }
+    },
+    resetScrollbar() {
+      const body = document.body
+      if (body._paddingChangedForModal) {
+        // Restore fixed content padding
+        body._paddingChangedForModal.forEach(el => {
+          /* istanbul ignore next: difficult to test in JSDOM */
+          if (hasAttr(el, 'data-padding-right')) {
+            setStyle(el, 'paddingRight', getAttr(el, 'data-padding-right') || '')
+            removeAttr(el, 'data-padding-right')
+          }
+        })
+      }
+      if (body._marginChangedForModal) {
+        // Restore sticky content and navbar-toggler margin
+        body._marginChangedForModal.forEach(el => {
+          /* istanbul ignore next: difficult to test in JSDOM */
+          if (hasAttr(el, 'data-margin-right')) {
+            setStyle(el, 'marginRight', getAttr(el, 'data-margin-right') || '')
+            removeAttr(el, 'data-margin-right')
+          }
+        })
+      }
+      body._paddingChangedForModal = null
+      body._marginChangedForModal = null
+      // Restore body padding
+      if (hasAttr(body, 'data-padding-right')) {
+        setStyle(body, 'paddingRight', getAttr(body, 'data-padding-right') || '')
+        removeAttr(body, 'data-padding-right')
+      }
+    }
+  }
+})
+
+// Create and export our modal manager instance
+export const modalManager = new ModalManager()

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

@@ -0,0 +1,3 @@
+import { BModal } from './modal'
+
+export { BModal }

package/src/vendor/bootstrap-vue/src/components/modal/index.scss

@@ -0,0 +1 @@
+@import "modal";