@gitlab/duo-ui 0.1.0

package/src/vendor/bootstrap-vue/src/directives/tooltip/tooltip.js

@@ -0,0 +1,270 @@
+import { NAME_TOOLTIP } from '../../constants/components'
+import { IS_BROWSER } from '../../constants/env'
+import { EVENT_NAME_SHOW } from '../../constants/events'
+import { concat } from '../../utils/array'
+import { isVue3, nextTick } from '../../vue'
+import { getComponentConfig } from '../../utils/config'
+import { getScopeId } from '../../utils/get-scope-id'
+import { identity } from '../../utils/identity'
+import { getInstanceFromDirective } from '../../utils/get-instance-from-directive'
+import {
+  isFunction,
+  isNumber,
+  isPlainObject,
+  isString,
+  isUndefined,
+  isUndefinedOrNull
+} from '../../utils/inspect'
+import { looseEqual } from '../../utils/loose-equal'
+import { toInteger } from '../../utils/number'
+import { keys } from '../../utils/object'
+import { createNewChildComponent } from '../../utils/create-new-child-component'
+import { BVTooltip } from '../../components/tooltip/helpers/bv-tooltip'
+
+// Key which we use to store tooltip object on element
+const BV_TOOLTIP = '__BV_Tooltip__'
+
+// Default trigger
+const DefaultTrigger = 'hover focus'
+
+// Valid event triggers
+const validTriggers = {
+  focus: true,
+  hover: true,
+  click: true,
+  blur: true,
+  manual: true
+}
+
+// Directive modifier test regular expressions. Pre-compile for performance
+const htmlRE = /^html$/i
+const noninteractiveRE = /^noninteractive$/i
+const noFadeRE = /^nofade$/i
+const placementRE = /^(auto|top(left|right)?|bottom(left|right)?|left(top|bottom)?|right(top|bottom)?)$/i
+const boundaryRE = /^(window|viewport|scrollParent)$/i
+const delayRE = /^d\d+$/i
+const delayShowRE = /^ds\d+$/i
+const delayHideRE = /^dh\d+$/i
+const offsetRE = /^o-?\d+$/i
+const variantRE = /^v-.+$/i
+const spacesRE = /\s+/
+
+// Build a Tooltip config based on bindings (if any)
+// Arguments and modifiers take precedence over passed value config object
+const parseBindings = (bindings, vnode) => /* istanbul ignore next: not easy to test */ {
+  // We start out with a basic config
+  let config = {
+    title: undefined,
+    trigger: '', // Default set below if needed
+    placement: 'top',
+    fallbackPlacement: 'flip',
+    container: false, // Default of body
+    animation: true,
+    offset: 0,
+    id: null,
+    html: false,
+    interactive: true,
+    disabled: false,
+    delay: getComponentConfig(NAME_TOOLTIP, 'delay', 50),
+    boundary: String(getComponentConfig(NAME_TOOLTIP, 'boundary', 'scrollParent')),
+    boundaryPadding: toInteger(getComponentConfig(NAME_TOOLTIP, 'boundaryPadding', 5), 0),
+    variant: getComponentConfig(NAME_TOOLTIP, 'variant'),
+    customClass: getComponentConfig(NAME_TOOLTIP, 'customClass')
+  }
+  // Process `bindings.value`
+  if (isString(bindings.value) || isNumber(bindings.value)) {
+    // Value is tooltip content (HTML optionally supported)
+    config.title = bindings.value
+  } else if (isFunction(bindings.value)) {
+    // Title generator function
+    config.title = bindings.value
+  } else if (isPlainObject(bindings.value)) {
+    // Value is config object, so merge
+    config = { ...config, ...bindings.value }
+  }
+
+  // If title is not provided, try title attribute
+  if (isUndefined(config.title)) {
+    // Try attribute
+    const attrs = isVue3 ? vnode.props : (vnode.data || {}).attrs
+    config.title = attrs && !isUndefinedOrNull(attrs.title) ? attrs.title : undefined
+  }
+
+  // Normalize delay
+  if (!isPlainObject(config.delay)) {
+    config.delay = {
+      show: toInteger(config.delay, 0),
+      hide: toInteger(config.delay, 0)
+    }
+  }
+
+  // If argument, assume element ID of container element
+  if (bindings.arg) {
+    // Element ID specified as arg
+    // We must prepend '#' to become a CSS selector
+    config.container = `#${bindings.arg}`
+  }
+
+  // Process modifiers
+  keys(bindings.modifiers).forEach(mod => {
+    if (htmlRE.test(mod)) {
+      // Title allows HTML
+      config.html = true
+    } else if (noninteractiveRE.test(mod)) {
+      // Noninteractive
+      config.interactive = false
+    } else if (noFadeRE.test(mod)) {
+      // No animation
+      config.animation = false
+    } else if (placementRE.test(mod)) {
+      // Placement of tooltip
+      config.placement = mod
+    } else if (boundaryRE.test(mod)) {
+      // Boundary of tooltip
+      mod = mod === 'scrollparent' ? 'scrollParent' : mod
+      config.boundary = mod
+    } else if (delayRE.test(mod)) {
+      // Delay value
+      const delay = toInteger(mod.slice(1), 0)
+      config.delay.show = delay
+      config.delay.hide = delay
+    } else if (delayShowRE.test(mod)) {
+      // Delay show value
+      config.delay.show = toInteger(mod.slice(2), 0)
+    } else if (delayHideRE.test(mod)) {
+      // Delay hide value
+      config.delay.hide = toInteger(mod.slice(2), 0)
+    } else if (offsetRE.test(mod)) {
+      // Offset value, negative allowed
+      config.offset = toInteger(mod.slice(1), 0)
+    } else if (variantRE.test(mod)) {
+      // Variant
+      config.variant = mod.slice(2) || null
+    }
+  })
+
+  // Special handling of event trigger modifiers trigger is
+  // a space separated list
+  const selectedTriggers = {}
+
+  // Parse current config object trigger
+  concat(config.trigger || '')
+    .filter(identity)
+    .join(' ')
+    .trim()
+    .toLowerCase()
+    .split(spacesRE)
+    .forEach(trigger => {
+      if (validTriggers[trigger]) {
+        selectedTriggers[trigger] = true
+      }
+    })
+
+  // Parse modifiers for triggers
+  keys(bindings.modifiers).forEach(mod => {
+    mod = mod.toLowerCase()
+    if (validTriggers[mod]) {
+      // If modifier is a valid trigger
+      selectedTriggers[mod] = true
+    }
+  })
+
+  // Sanitize triggers
+  config.trigger = keys(selectedTriggers).join(' ')
+  if (config.trigger === 'blur') {
+    // Blur by itself is useless, so convert it to 'focus'
+    config.trigger = 'focus'
+  }
+  if (!config.trigger) {
+    // Use default trigger
+    config.trigger = DefaultTrigger
+  }
+
+  // Return the config
+  return config
+}
+
+// Add/update Tooltip on our element
+const applyTooltip = (el, bindings, vnode) => {
+  if (!IS_BROWSER) {
+    /* istanbul ignore next */
+    return
+  }
+  const config = parseBindings(bindings, vnode)
+  if (!el[BV_TOOLTIP]) {
+    const parent = getInstanceFromDirective(vnode, bindings)
+    el[BV_TOOLTIP] = createNewChildComponent(parent, BVTooltip, {
+      // Add the parent's scoped style attribute data
+      _scopeId: getScopeId(parent, undefined)
+    })
+    el[BV_TOOLTIP].__bv_prev_data__ = {}
+    el[BV_TOOLTIP].$on(EVENT_NAME_SHOW, () => /* istanbul ignore next: for now */ {
+      // Before showing the tooltip, we update the title if it is a function
+      if (isFunction(config.title)) {
+        el[BV_TOOLTIP].updateData({
+          title: config.title(el)
+        })
+      }
+    })
+  }
+  const data = {
+    title: config.title,
+    triggers: config.trigger,
+    placement: config.placement,
+    fallbackPlacement: config.fallbackPlacement,
+    variant: config.variant,
+    customClass: config.customClass,
+    container: config.container,
+    boundary: config.boundary,
+    delay: config.delay,
+    offset: config.offset,
+    noFade: !config.animation,
+    id: config.id,
+    interactive: config.interactive,
+    disabled: config.disabled,
+    html: config.html
+  }
+  const oldData = el[BV_TOOLTIP].__bv_prev_data__
+  el[BV_TOOLTIP].__bv_prev_data__ = data
+  if (!looseEqual(data, oldData)) {
+    // We only update the instance if data has changed
+    const newData = {
+      target: el
+    }
+    keys(data).forEach(prop => {
+      // We only pass data properties that have changed
+      if (data[prop] !== oldData[prop]) {
+        // if title is a function, we execute it here
+        newData[prop] = prop === 'title' && isFunction(data[prop]) ? data[prop](el) : data[prop]
+      }
+    })
+    el[BV_TOOLTIP].updateData(newData)
+  }
+}
+
+// Remove Tooltip on our element
+const removeTooltip = el => {
+  if (el[BV_TOOLTIP]) {
+    el[BV_TOOLTIP].$destroy()
+    el[BV_TOOLTIP] = null
+  }
+  delete el[BV_TOOLTIP]
+}
+
+// Export our directive
+export const VBTooltip = {
+  bind(el, bindings, vnode) {
+    applyTooltip(el, bindings, vnode)
+  },
+  // We use `componentUpdated` here instead of `update`, as the former
+  // waits until the containing component and children have finished updating
+  componentUpdated(el, bindings, vnode) {
+    // Performed in a `$nextTick()` to prevent render update loops
+    nextTick(() => {
+      applyTooltip(el, bindings, vnode)
+    })
+  },
+  unbind(el) {
+    removeTooltip(el)
+  }
+}

package/src/vendor/bootstrap-vue/src/directives/visible/index.js

@@ -0,0 +1,3 @@
+import { VBVisible } from './visible'
+
+export { VBVisible }

package/src/vendor/bootstrap-vue/src/directives/visible/visible.js

@@ -0,0 +1,184 @@
+// v-b-visible
+// Private visibility check directive
+// Based on IntersectionObserver
+//
+// Usage:
+//  v-b-visibility.<margin>.<once>="<callback>"
+//
+//  Value:
+//  <callback>: method to be called when visibility state changes, receives one arg:
+//     true:  element is visible
+//     false: element is not visible
+//     null:  IntersectionObserver not supported
+//
+//  Modifiers:
+//    <margin>: a positive decimal value of pixels away from viewport edge
+//              before being considered "visible". default is 0
+//    <once>:   keyword 'once', meaning when the element becomes visible and
+//              callback is called observation/notification will stop.
+//
+// When used in a render function:
+// export default {
+//   directives: { 'b-visible': VBVisible },
+//   render(h) {
+//     h(
+//       'div',
+//       {
+//         directives: [
+//           { name: 'b-visible', value=this.callback, modifiers: { '123':true, 'once':true } }
+//         ]
+//       }
+//     )
+//   }
+
+import { RX_DIGITS } from '../../constants/regex'
+import { requestAF } from '../../utils/dom'
+import { isFunction } from '../../utils/inspect'
+import { looseEqual } from '../../utils/loose-equal'
+import { clone, keys } from '../../utils/object'
+import { nextTick } from '../../vue'
+
+const OBSERVER_PROP_NAME = '__bv__visibility_observer'
+
+class VisibilityObserver {
+  constructor(el, options) {
+    this.el = el
+    this.callback = options.callback
+    this.margin = options.margin || 0
+    this.once = options.once || false
+    this.observer = null
+    this.visible = undefined
+    this.doneOnce = false
+    // Create the observer instance (if possible)
+    this.createObserver()
+  }
+
+  createObserver() {
+    // Remove any previous observer
+    if (this.observer) {
+      /* istanbul ignore next */
+      this.stop()
+    }
+
+    // Should only be called once and `callback` prop should be a function
+    if (this.doneOnce || !isFunction(this.callback)) {
+      /* istanbul ignore next */
+      return
+    }
+
+    // Create the observer instance
+    try {
+      // Future: Possibly add in other modifiers for left/right/top/bottom
+      // offsets, root element reference, and thresholds
+      this.observer = new IntersectionObserver(this.handler.bind(this), {
+        // `null` = 'viewport'
+        root: null,
+        // Pixels away from view port to consider "visible"
+        rootMargin: this.margin,
+        // Intersection ratio of el and root (as a value from 0 to 1)
+        threshold: 0
+      })
+    } catch {
+      // No IntersectionObserver support, so just stop trying to observe
+      this.doneOnce = true
+      this.observer = undefined
+      this.callback(null)
+      return
+    }
+
+    // Start observing in a `$nextTick()` (to allow DOM to complete rendering)
+    /* istanbul ignore next: IntersectionObserver not supported in JSDOM */
+    nextTick(() => {
+      requestAF(() => {
+        // Placed in an `if` just in case we were destroyed before
+        // this `requestAnimationFrame` runs
+        if (this.observer) {
+          this.observer.observe(this.el)
+        }
+      })
+    })
+  }
+
+  /* istanbul ignore next */
+  handler(entries) {
+    const entry = entries ? entries[0] : {}
+    const isIntersecting = Boolean(entry.isIntersecting || entry.intersectionRatio > 0.0)
+    if (isIntersecting !== this.visible) {
+      this.visible = isIntersecting
+      this.callback(isIntersecting)
+      if (this.once && this.visible) {
+        this.doneOnce = true
+        this.stop()
+      }
+    }
+  }
+
+  stop() {
+    /* istanbul ignore next */
+    this.observer && this.observer.disconnect()
+    this.observer = null
+  }
+}
+
+const destroy = el => {
+  const observer = el[OBSERVER_PROP_NAME]
+  if (observer && observer.stop) {
+    observer.stop()
+  }
+  delete el[OBSERVER_PROP_NAME]
+}
+
+const bind = (el, { value, modifiers }) => {
+  // `value` is the callback function
+  const options = {
+    margin: '0px',
+    once: false,
+    callback: value
+  }
+  // Parse modifiers
+  keys(modifiers).forEach(mod => {
+    /* istanbul ignore else: Until <b-img-lazy> is switched to use this directive */
+    if (RX_DIGITS.test(mod)) {
+      options.margin = `${mod}px`
+    } else if (mod.toLowerCase() === 'once') {
+      options.once = true
+    }
+  })
+  // Destroy any previous observer
+  destroy(el)
+  // Create new observer
+  el[OBSERVER_PROP_NAME] = new VisibilityObserver(el, options)
+  // Store the current modifiers on the object (cloned)
+  el[OBSERVER_PROP_NAME]._prevModifiers = clone(modifiers)
+}
+
+// When the directive options may have been updated (or element)
+const componentUpdated = (el, { value, oldValue, modifiers }, vnode) => {
+  // Compare value/oldValue and modifiers to see if anything has changed
+  // and if so, destroy old observer and create new observer
+  /* istanbul ignore next */
+  modifiers = clone(modifiers)
+  /* istanbul ignore next */
+  if (
+    el &&
+    (value !== oldValue ||
+      !el[OBSERVER_PROP_NAME] ||
+      !looseEqual(modifiers, el[OBSERVER_PROP_NAME]._prevModifiers))
+  ) {
+    // Re-bind on element
+    bind(el, { value, modifiers }, vnode)
+  }
+}
+
+// When directive un-binds from element
+const unbind = el => {
+  // Remove the observer
+  destroy(el)
+}
+
+// Export the directive
+export const VBVisible = {
+  bind,
+  componentUpdated,
+  unbind
+}

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

@@ -0,0 +1,187 @@
+import { installFactory } from './utils/plugins'
+import { componentsPlugin } from './components'
+import { BVConfigPlugin } from './bv-config'
+
+const NAME = 'BootstrapVue'
+
+// --- BootstrapVue installer ---
+const install = /*#__PURE__*/ installFactory({
+  plugins: {
+    componentsPlugin
+  }
+})
+
+// --- BootstrapVue plugin ---
+const BootstrapVue = /*#__PURE__*/ {
+  install,
+  NAME
+}
+
+// --- Named exports for BvConfigPlugin ---
+export {
+  // Installer exported in case the consumer does not import `default`
+  // as the plugin in CommonJS build (or does not have interop enabled for CommonJS)
+  // Both the following will work:
+  //   BootstrapVue = require('bootstrap-vue')
+  //   BootstrapVue = require('bootstrap-vue').default
+  //   Vue.use(BootstrapVue)
+  install,
+  NAME,
+  // BootstrapVue config plugin
+  BVConfigPlugin,
+  // `BVConfigPlugin` has been documented as `BVConfig` as well,
+  // so we add an alias to the shorter name for backwards compat
+  BVConfigPlugin as BVConfig,
+  // Main BootstrapVue plugin
+  BootstrapVue
+}
+
+// --- Export named injection plugins ---
+// TODO:
+//   We should probably move injections into their own
+//   parent directory (i.e. `/src/injections`)
+export { BVToastPlugin } from './components/toast/helpers/bv-toast'
+
+// Webpack 4 has optimization difficulties with re-export of re-exports,
+// so we import the components individually here for better tree shaking
+//
+// Webpack v5 fixes the optimizations with re-export of re-exports so this
+// can be reverted back to `export * from './table'` when Webpack v5 is released
+// See: https://github.com/webpack/webpack/pull/9203 (available in Webpack v5.0.0-alpha.15)
+
+// --- Export all individual components and component group plugins as named exports ---
+
+// export * from './components/badge'
+export { BBadge } from './components/badge/badge'
+
+// export * from './components/breadcrumb'
+export { BBreadcrumb } from './components/breadcrumb/breadcrumb'
+export { BBreadcrumbItem } from './components/breadcrumb/breadcrumb-item'
+
+// export * from './components/button'
+export { BButton } from './components/button/button'
+export { BButtonClose } from './components/button/button-close'
+
+// export * from './components/button-group'
+export { BButtonGroup } from './components/button-group/button-group'
+
+// export * from './components/collapse'
+export { BCollapse } from './components/collapse/collapse'
+
+// export * from './components/dropdown'
+export { BDropdown } from './components/dropdown/dropdown'
+export { BDropdownItem } from './components/dropdown/dropdown-item'
+export { BDropdownItemButton } from './components/dropdown/dropdown-item-button'
+export { BDropdownDivider } from './components/dropdown/dropdown-divider'
+export { BDropdownForm } from './components/dropdown/dropdown-form'
+export { BDropdownGroup } from './components/dropdown/dropdown-group'
+export { BDropdownHeader } from './components/dropdown/dropdown-header'
+export { BDropdownText } from './components/dropdown/dropdown-text'
+
+// export * from './components/form'
+export { BForm } from './components/form/form'
+export { BFormText } from './components/form/form-text'
+export { BFormInvalidFeedback } from './components/form/form-invalid-feedback'
+export { BFormValidFeedback } from './components/form/form-valid-feedback'
+
+// export * from './components/form-checkbox'
+export { BFormCheckbox } from './components/form-checkbox/form-checkbox'
+export { BFormCheckboxGroup } from './components/form-checkbox/form-checkbox-group'
+
+// export * from './components/form-group'
+export { BFormGroup } from './components/form-group/form-group'
+
+// export * from './components/form-input'
+export { BFormInput } from './components/form-input/form-input'
+
+// export * from './components/form-radio'
+export { BFormRadio } from './components/form-radio/form-radio'
+export { BFormRadioGroup } from './components/form-radio/form-radio-group'
+
+// export * from './components/form-select'
+export { BFormSelect } from './components/form-select/form-select'
+export { BFormSelectOption } from './components/form-select/form-select-option'
+export { BFormSelectOptionGroup } from './components/form-select/form-select-option-group'
+
+// export * from './components/form-textarea'
+export { BFormTextarea } from './components/form-textarea/form-textarea'
+
+// export * from './components/input-group'
+export { BInputGroup } from './components/input-group/input-group'
+export { BInputGroupAddon } from './components/input-group/input-group-addon'
+export { BInputGroupAppend } from './components/input-group/input-group-append'
+export { BInputGroupPrepend } from './components/input-group/input-group-prepend'
+export { BInputGroupText } from './components/input-group/input-group-text'
+
+// export * from './components/layout'
+export { BCol } from './components/layout/col'
+export { BFormRow } from './components/layout/form-row'
+
+// export * from './components/link'
+export { BLink } from './components/link/link'
+
+// export * from './components/modal'
+export { BModal } from './components/modal/modal'
+
+// export * from './components/nav'
+export { BNav } from './components/nav/nav'
+export { BNavItem } from './components/nav/nav-item'
+export { BNavItemDropdown } from './components/nav/nav-item-dropdown'
+
+// export * from './components/navbar'
+export { BNavbar } from './components/navbar/navbar'
+export { BNavbarBrand } from './components/navbar/navbar-brand'
+
+// export * from './components/popover'
+export { BPopover } from './components/popover/popover'
+
+// export * from './components/progress'
+export { BProgress } from './components/progress/progress'
+export { BProgressBar } from './components/progress/progress-bar'
+
+// export * from './components/table'
+export { BTable } from './components/table/table'
+export { BTableLite } from './components/table/table-lite'
+export { BTableSimple } from './components/table/table-simple'
+export { BTbody } from './components/table/tbody'
+export { BThead } from './components/table/thead'
+export { BTfoot } from './components/table/tfoot'
+export { BTr } from './components/table/tr'
+export { BTh } from './components/table/th'
+export { BTd } from './components/table/td'
+
+// export * from './components/tabs'
+export { BTabs } from './components/tabs/tabs'
+export { BTab } from './components/tabs/tab'
+
+// export * from './components/toast'
+export { ToastPlugin } from './components/toast'
+export { BToast } from './components/toast/toast'
+export { BToaster } from './components/toast/toaster'
+
+// export * from './components/tooltip'
+export { BTooltip } from './components/tooltip/tooltip'
+
+// --- Named exports of all directives (VB<Name>) ---
+
+// Webpack 4 has optimization difficulties with re-export of re-exports,
+// so we import the directives individually here for better tree shaking
+//
+// Webpack v5 fixes the optimizations with re-export of re-exports so this
+// can be reverted back to `export * from './scrollspy'` when Webpack v5 is released
+// https://github.com/webpack/webpack/pull/9203 (available in Webpack v5.0.0-alpha.15)
+
+// export * from './directives/modal'
+export { VBModal } from './directives/modal/modal'
+
+// export * from './directives/toggle'
+export { VBToggle } from './directives/toggle/toggle'
+
+// export * from './directives/tooltip'
+export { VBTooltip } from './directives/tooltip/tooltip'
+
+// export * from './directives/tooltip'
+export { VBVisible } from './directives/visible/visible'
+
+// Default export is the BootstrapVue plugin
+export default BootstrapVue

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

@@ -0,0 +1,11 @@
+// --- BootstrapVue Custom SCSS ---
+
+// Requires at least the Bootstrap functions, variables and
+// mixins to be imported first
+
+// Include variables and utilities first
+@import "variables";
+@import "utilities";
+
+// Include custom SCSS for components
+@import "components/index";

package/src/vendor/bootstrap-vue/src/mixins/attrs.js

@@ -0,0 +1,19 @@
+import { makePropCacheMixin } from '../utils/cache'
+import { extend, isVue3 } from '../vue'
+
+const attrsMixinVue2 = makePropCacheMixin('$attrs', 'bvAttrs')
+const attrsMixinVue3 = extend({
+  computed: {
+    bvAttrs() {
+      const bvAttrs = { ...this.$attrs }
+      Object.keys(bvAttrs).forEach(key => {
+        if (bvAttrs[key] === undefined) {
+          delete bvAttrs[key]
+        }
+      })
+      return bvAttrs
+    }
+  }
+})
+
+export const attrsMixin = isVue3 ? attrsMixinVue3 : attrsMixinVue2