@gitlab/duo-ui 0.1.0

package/src/vendor/bootstrap-vue/src/utils/math.js

@@ -0,0 +1,11 @@
+// Math utilty functions
+
+export const mathMin = Math.min
+
+export const mathMax = Math.max
+
+export const mathCeil = Math.ceil
+
+export const mathPow = Math.pow
+
+export const mathRound = Math.round

package/src/vendor/bootstrap-vue/src/utils/memoize.js

@@ -0,0 +1,10 @@
+import { create } from './object'
+
+export const memoize = fn => {
+  const cache = create(null)
+
+  return (...args) => {
+    const argsKey = JSON.stringify(args)
+    return (cache[argsKey] = cache[argsKey] || fn.apply(null, args))
+  }
+}

package/src/vendor/bootstrap-vue/src/utils/model.js

@@ -0,0 +1,29 @@
+import { extend } from '../vue'
+import { EVENT_NAME_INPUT } from '../constants/events'
+import { PROP_TYPE_ANY } from '../constants/props'
+import { makeProp } from './props'
+
+export const makeModelMixin = (
+  prop,
+  {
+    type = PROP_TYPE_ANY,
+    defaultValue = undefined,
+    validator = undefined,
+    event = EVENT_NAME_INPUT
+  } = {}
+) => {
+  const props = {
+    [prop]: makeProp(type, defaultValue, validator)
+  }
+
+  // @vue/component
+  const mixin = extend({
+    model: {
+      prop,
+      event
+    },
+    props
+  })
+
+  return { mixin, props, prop, event }
+}

package/src/vendor/bootstrap-vue/src/utils/noop.js

@@ -0,0 +1 @@
+export const noop = () => {}

package/src/vendor/bootstrap-vue/src/utils/normalize-slot.js

@@ -0,0 +1,44 @@
+import { concat } from './array'
+import { identity } from './identity'
+import { isFunction } from './inspect'
+
+// Note for functional components:
+// In functional components, `slots` is a function so it must be called
+// first before passing to the below methods. `scopedSlots` is always an
+// object and may be undefined (for Vue < 2.6.x)
+
+/**
+ * Returns true if either scoped or unscoped named slot exists
+ *
+ * @param {String, Array} name or name[]
+ * @param {Object} scopedSlots
+ * @param {Object} slots
+ * @returns {Array|undefined} VNodes
+ */
+export const hasNormalizedSlot = (names, $scopedSlots = {}, $slots = {}) => {
+  // Ensure names is an array
+  names = concat(names).filter(identity)
+  // Returns true if the either a $scopedSlot or $slot exists with the specified name
+  return names.some(name => $scopedSlots[name] || $slots[name])
+}
+
+/**
+ * Returns VNodes for named slot either scoped or unscoped
+ *
+ * @param {String, Array} name or name[]
+ * @param {String} scope
+ * @param {Object} scopedSlots
+ * @param {Object} slots
+ * @returns {Array|undefined} VNodes
+ */
+export const normalizeSlot = (names, scope = {}, $scopedSlots = {}, $slots = {}) => {
+  // Ensure names is an array
+  names = concat(names).filter(identity)
+  let slot
+  for (let i = 0; i < names.length && !slot; i++) {
+    const name = names[i]
+    slot = $scopedSlots[name] || $slots[name]
+  }
+  // Note: in Vue 2.6.x, all named slots are also scoped slots
+  return isFunction(slot) ? slot(scope) : slot
+}

package/src/vendor/bootstrap-vue/src/utils/number.js

@@ -0,0 +1,19 @@
+// Number utilities
+
+// Converts a value (string, number, etc.) to an integer number
+// Assumes radix base 10
+export const toInteger = (value, defaultValue = NaN) => {
+  const integer = parseInt(value, 10)
+  return isNaN(integer) ? defaultValue : integer
+}
+
+// Converts a value (string, number, etc.) to a number
+export const toFloat = (value, defaultValue = NaN) => {
+  const float = parseFloat(value)
+  return isNaN(float) ? defaultValue : float
+}
+
+// Converts a value (string, number, etc.) to a string
+// representation with `precision` digits after the decimal
+// Returns the string 'NaN' if the value cannot be converted
+export const toFixed = (val, precision) => toFloat(val).toFixed(toInteger(precision, 0))

package/src/vendor/bootstrap-vue/src/utils/object.js

@@ -0,0 +1,61 @@
+import { isObject } from './inspect'
+
+// --- Static ---
+
+export const assign = (...args) => Object.assign(...args)
+export const create = (proto, optionalProps) => Object.create(proto, optionalProps)
+export const defineProperties = (obj, props) => Object.defineProperties(obj, props)
+export const defineProperty = (obj, prop, descriptor) =>
+  Object.defineProperty(obj, prop, descriptor)
+export const getOwnPropertyNames = obj => Object.getOwnPropertyNames(obj)
+export const keys = obj => Object.keys(obj)
+
+// --- "Instance" ---
+
+export const hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+
+// --- Utilities ---
+
+// Shallow copy an object
+export const clone = obj => ({ ...obj })
+
+// Return a shallow copy of object with the specified properties only
+// See: https://gist.github.com/bisubus/2da8af7e801ffd813fab7ac221aa7afc
+export const pick = (obj, props) =>
+  keys(obj)
+    .filter(key => props.indexOf(key) !== -1)
+    .reduce((result, key) => ({ ...result, [key]: obj[key] }), {})
+
+// Return a shallow copy of object with the specified properties omitted
+// See: https://gist.github.com/bisubus/2da8af7e801ffd813fab7ac221aa7afc
+export const omit = (obj, props) =>
+  keys(obj)
+    .filter(key => props.indexOf(key) === -1)
+    .reduce((result, key) => ({ ...result, [key]: obj[key] }), {})
+
+// Merges two object deeply together
+// See: https://gist.github.com/Salakar/1d7137de9cb8b704e48a
+export const mergeDeep = (target, source) => {
+  if (isObject(target) && isObject(source)) {
+    keys(source).forEach(key => {
+      if (isObject(source[key])) {
+        if (!target[key] || !isObject(target[key])) {
+          target[key] = source[key]
+        }
+        mergeDeep(target[key], source[key])
+      } else {
+        assign(target, { [key]: source[key] })
+      }
+    })
+  }
+  return target
+}
+
+// Returns a shallow copy of the object with keys in sorted order
+export const sortKeys = obj =>
+  keys(obj)
+    .sort()
+    .reduce((result, key) => ({ ...result, [key]: obj[key] }), {})
+
+// Convenience method to create a read-only descriptor
+export const readonlyDescriptor = () => ({ enumerable: true, configurable: false, writable: false })

package/src/vendor/bootstrap-vue/src/utils/observe-dom.js

@@ -0,0 +1,77 @@
+import { MutationObs, isElement } from './dom'
+import { warnNoMutationObserverSupport } from './warn'
+
+/**
+ * Observe a DOM element changes, falls back to eventListener mode
+ * @param {Element} el The DOM element to observe
+ * @param {Function} callback callback to be called on change
+ * @param {object} [options={childList: true, subtree: true}] observe options
+ * @see https://stackoverflow.com/questions/3219758
+ */
+export const observeDom = (
+  el,
+  callback,
+  options
+) => /* istanbul ignore next: difficult to test in JSDOM */ {
+  // Handle cases where we might be passed a Vue instance
+  el = el ? el.$el || el : null
+
+  // Early exit when we have no element
+  /* istanbul ignore next: difficult to test in JSDOM */
+  if (!isElement(el)) {
+    return null
+  }
+
+  // Exit and throw a warning when `MutationObserver` isn't available
+  if (warnNoMutationObserverSupport('observeDom')) {
+    return null
+  }
+
+  // Define a new observer
+  const obs = new MutationObs(mutations => {
+    let changed = false
+
+    // A mutation can contain several change records, so we loop
+    // through them to see what has changed
+    // We break out of the loop early if any "significant" change
+    // has been detected
+    for (let i = 0; i < mutations.length && !changed; i++) {
+      // The mutation record
+      const mutation = mutations[i]
+      // Mutation type
+      const type = mutation.type
+      // DOM node (could be any DOM node type - HTMLElement, Text, comment, etc.)
+      const target = mutation.target
+
+      // Detect whether a change happened based on type and target
+      if (type === 'characterData' && target.nodeType === Node.TEXT_NODE) {
+        // We ignore nodes that are not TEXT (i.e. comments, etc.)
+        // as they don't change layout
+        changed = true
+      } else if (type === 'attributes') {
+        changed = true
+      } else if (
+        type === 'childList' &&
+        (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)
+      ) {
+        // This includes HTMLElement and text nodes being
+        // added/removed/re-arranged
+        changed = true
+      }
+    }
+
+    // We only call the callback if a change that could affect
+    // layout/size truly happened
+    if (changed) {
+      callback()
+    }
+  })
+
+  // Have the observer observe foo for changes in children, etc
+  obs.observe(el, { childList: true, subtree: true, ...options })
+
+  // We return a reference to the observer so that `obs.disconnect()`
+  // can be called if necessary
+  // To reduce overhead when the root element is hidden
+  return obs
+}

package/src/vendor/bootstrap-vue/src/utils/plugins.js

@@ -0,0 +1,169 @@
+import { Vue as OurVue } from '../vue'
+import { HAS_WINDOW_SUPPORT, IS_JSDOM } from '../constants/env'
+import { setConfig } from './config-set'
+import { warn } from './warn'
+
+/**
+ * Checks if there are multiple instances of Vue, and warns (once) about possible issues.
+ * @param {object} Vue
+ */
+export const checkMultipleVue = (() => {
+  let checkMultipleVueWarned = false
+
+  const MULTIPLE_VUE_WARNING = [
+    'Multiple instances of Vue detected!',
+    'You may need to set up an alias for Vue in your bundler config.',
+    'See: https://bootstrap-vue.org/docs#using-module-bundlers'
+  ].join('\n')
+
+  return Vue => {
+    /* istanbul ignore next */
+    if (!checkMultipleVueWarned && OurVue !== Vue && !IS_JSDOM) {
+      warn(MULTIPLE_VUE_WARNING)
+    }
+    checkMultipleVueWarned = true
+  }
+})()
+
+/**
+ * Plugin install factory function.
+ * @param {object} { components, directives }
+ * @returns {function} plugin install function
+ */
+export const installFactory = ({ components, directives, plugins } = {}) => {
+  const install = (Vue, config = {}) => {
+    if (install.installed) {
+      /* istanbul ignore next */
+      return
+    }
+    install.installed = true
+    checkMultipleVue(Vue)
+    setConfig(config, Vue)
+    registerComponents(Vue, components)
+    registerDirectives(Vue, directives)
+    registerPlugins(Vue, plugins)
+  }
+
+  install.installed = false
+
+  return install
+}
+
+/**
+ * Plugin install factory function (no plugin config option).
+ * @param {object} { components, directives }
+ * @returns {function} plugin install function
+ */
+export const installFactoryNoConfig = ({ components, directives, plugins } = {}) => {
+  const install = Vue => {
+    if (install.installed) {
+      /* istanbul ignore next */
+      return
+    }
+    install.installed = true
+    checkMultipleVue(Vue)
+    registerComponents(Vue, components)
+    registerDirectives(Vue, directives)
+    registerPlugins(Vue, plugins)
+  }
+
+  install.installed = false
+
+  return install
+}
+
+/**
+ * Plugin object factory function.
+ * @param {object} { components, directives, plugins }
+ * @returns {object} plugin install object
+ */
+export const pluginFactory = (options = {}, extend = {}) => ({
+  ...extend,
+  install: installFactory(options)
+})
+
+/**
+ * Plugin object factory function (no config option).
+ * @param {object} { components, directives, plugins }
+ * @returns {object} plugin install object
+ */
+export const pluginFactoryNoConfig = (options = {}, extend = {}) => ({
+  ...extend,
+  install: installFactoryNoConfig(options)
+})
+
+/**
+ * Load a group of plugins.
+ * @param {object} Vue
+ * @param {object} Plugin definitions
+ */
+export const registerPlugins = (Vue, plugins = {}) => {
+  for (const plugin in plugins) {
+    if (plugin && plugins[plugin]) {
+      Vue.use(plugins[plugin])
+    }
+  }
+}
+
+/**
+ * Load a component.
+ * @param {object} Vue
+ * @param {string} Component name
+ * @param {object} Component definition
+ */
+export const registerComponent = (Vue, name, def) => {
+  if (Vue && name && def) {
+    Vue.component(name, def)
+  }
+}
+
+/**
+ * Load a group of components.
+ * @param {object} Vue
+ * @param {object} Object of component definitions
+ */
+export const registerComponents = (Vue, components = {}) => {
+  for (const component in components) {
+    registerComponent(Vue, component, components[component])
+  }
+}
+
+/**
+ * Load a directive.
+ * @param {object} Vue
+ * @param {string} Directive name
+ * @param {object} Directive definition
+ */
+export const registerDirective = (Vue, name, def) => {
+  if (Vue && name && def) {
+    // Ensure that any leading V is removed from the
+    // name, as Vue adds it automatically
+    Vue.directive(name.replace(/^VB/, 'B'), def)
+  }
+}
+
+/**
+ * Load a group of directives.
+ * @param {object} Vue
+ * @param {object} Object of directive definitions
+ */
+export const registerDirectives = (Vue, directives = {}) => {
+  for (const directive in directives) {
+    registerDirective(Vue, directive, directives[directive])
+  }
+}
+
+/**
+ * Install plugin if window.Vue available
+ * @param {object} Plugin definition
+ */
+export const vueUse = VuePlugin => {
+  /* istanbul ignore next */
+  if (HAS_WINDOW_SUPPORT && window.Vue) {
+    window.Vue.use(VuePlugin)
+  }
+  /* istanbul ignore next */
+  if (HAS_WINDOW_SUPPORT && VuePlugin.NAME) {
+    window[VuePlugin.NAME] = VuePlugin
+  }
+}

package/src/vendor/bootstrap-vue/src/utils/props.js

@@ -0,0 +1,92 @@
+import { PROP_TYPE_ANY } from '../constants/props'
+import { cloneDeep } from './clone-deep'
+import { getComponentConfig } from './config'
+import { identity } from './identity'
+import { isArray, isFunction, isObject, isUndefined } from './inspect'
+import { clone, hasOwnProperty, keys } from './object'
+import { upperFirst } from './string'
+
+// Suffix can be a falsey value so nothing is appended to string
+// (helps when looping over props & some shouldn't change)
+// Use data last parameters to allow for currying
+export const suffixPropName = (suffix, value) => value + (suffix ? upperFirst(suffix) : '')
+
+// Generates a prop object
+export const makeProp = (
+  type = PROP_TYPE_ANY,
+  value = undefined,
+  requiredOrValidator = undefined,
+  validator = undefined
+) => {
+  const required = requiredOrValidator === true
+  validator = required ? validator : requiredOrValidator
+
+  return {
+    ...(type ? { type } : {}),
+    ...(required
+      ? { required }
+      : isUndefined(value)
+        ? {}
+        : { default: isObject(value) ? () => value : value }),
+    ...(isUndefined(validator) ? {} : { validator })
+  }
+}
+
+// Copies props from one array/object to a new array/object
+// Prop values are also cloned as new references to prevent possible
+// mutation of original prop object values
+// Optionally accepts a function to transform the prop name
+export const copyProps = (props, transformFn = identity) => {
+  if (isArray(props)) {
+    return props.map(transformFn)
+  }
+  const copied = {}
+  for (const prop in props) {
+    /* istanbul ignore else */
+    if (hasOwnProperty(props, prop)) {
+      // If the prop value is an object, do a shallow clone
+      // to prevent potential mutations to the original object
+      copied[transformFn(prop)] = isObject(props[prop]) ? clone(props[prop]) : props[prop]
+    }
+  }
+  return copied
+}
+
+// Given an array of properties or an object of property keys,
+// plucks all the values off the target object, returning a new object
+// that has props that reference the original prop values
+export const pluckProps = (keysToPluck, objToPluck, transformFn = identity) =>
+  (isArray(keysToPluck) ? keysToPluck.slice() : keys(keysToPluck)).reduce((memo, prop) => {
+    memo[transformFn(prop)] = objToPluck[prop]
+    return memo
+  }, {})
+
+// Make a prop object configurable by global configuration
+// Replaces the current `default` key of each prop with a `getComponentConfig()`
+// call that falls back to the current default value of the prop
+export const makePropConfigurable = (prop, key, componentKey) => ({
+  ...cloneDeep(prop),
+  default: function bvConfigurablePropDefault() {
+    const value = getComponentConfig(componentKey, key, prop.default)
+    return isFunction(value) ? value() : value
+  }
+})
+
+// Make a props object configurable by global configuration
+// Replaces the current `default` key of each prop with a `getComponentConfig()`
+// call that falls back to the current default value of the prop
+export const makePropsConfigurable = (props, componentKey) =>
+  keys(props).reduce(
+    (result, key) => ({ ...result, [key]: makePropConfigurable(props[key], key, componentKey) }),
+    {}
+  )
+
+// Get function name we use in `makePropConfigurable()`
+// for the prop default value override to compare
+// against in `hasPropFunction()`
+const configurablePropDefaultFnName = makePropConfigurable({}, '', '').default.name
+
+// Detect wether the given value is currently a function
+// and isn't the props default function
+export const hasPropFunction = fn =>
+  isFunction(fn) && fn.name && fn.name !== configurablePropDefaultFnName

package/src/vendor/bootstrap-vue/src/utils/router.js

@@ -0,0 +1,145 @@
+import { RX_ENCODED_COMMA, RX_ENCODE_REVERSE, RX_PLUS, RX_QUERY_START } from '../constants/regex'
+import { isTag } from './dom'
+import { isArray, isNull, isPlainObject, isString, isUndefined } from './inspect'
+import { keys } from './object'
+import { safeVueInstance } from './safe-vue-instance'
+import { toString } from './string'
+
+const ANCHOR_TAG = 'a'
+
+// Method to replace reserved chars
+const encodeReserveReplacer = c => '%' + c.charCodeAt(0).toString(16)
+
+// Fixed encodeURIComponent which is more conformant to RFC3986:
+// - escapes [!'()*]
+// - preserve commas
+const encode = str =>
+  encodeURIComponent(toString(str))
+    .replace(RX_ENCODE_REVERSE, encodeReserveReplacer)
+    .replace(RX_ENCODED_COMMA, ',')
+
+const decode = decodeURIComponent
+
+// Stringifies an object of query parameters
+// See: https://github.com/vuejs/vue-router/blob/dev/src/util/query.js
+export const stringifyQueryObj = obj => {
+  if (!isPlainObject(obj)) {
+    return ''
+  }
+
+  const query = keys(obj)
+    .map(key => {
+      const value = obj[key]
+      if (isUndefined(value)) {
+        return ''
+      } else if (isNull(value)) {
+        return encode(key)
+      } else if (isArray(value)) {
+        return value
+          .reduce((results, value2) => {
+            if (isNull(value2)) {
+              results.push(encode(key))
+            } else if (!isUndefined(value2)) {
+              // Faster than string interpolation
+              results.push(encode(key) + '=' + encode(value2))
+            }
+            return results
+          }, [])
+          .join('&')
+      }
+      // Faster than string interpolation
+      return encode(key) + '=' + encode(value)
+    })
+    /* must check for length, as we only want to filter empty strings, not things that look falsey! */
+    .filter(x => x.length > 0)
+    .join('&')
+
+  return query ? `?${query}` : ''
+}
+
+export const parseQuery = query => {
+  const parsed = {}
+  query = toString(query)
+    .trim()
+    .replace(RX_QUERY_START, '')
+
+  if (!query) {
+    return parsed
+  }
+
+  query.split('&').forEach(param => {
+    const parts = param.replace(RX_PLUS, ' ').split('=')
+    const key = decode(parts.shift())
+    const value = parts.length > 0 ? decode(parts.join('=')) : null
+
+    if (isUndefined(parsed[key])) {
+      parsed[key] = value
+    } else if (isArray(parsed[key])) {
+      parsed[key].push(value)
+    } else {
+      parsed[key] = [parsed[key], value]
+    }
+  })
+
+  return parsed
+}
+
+export const isLink = props => !!(props.href || props.to)
+
+export const isRouterLink = tag => !!(tag && !isTag(tag, 'a'))
+
+export const computeTag = ({ to, disabled, routerComponentName }, thisOrParent) => {
+  const hasRouter = !!safeVueInstance(thisOrParent).$router
+  const hasNuxt = !!safeVueInstance(thisOrParent).$nuxt
+  if (!hasRouter || (hasRouter && (disabled || !to))) {
+    return ANCHOR_TAG
+  }
+
+  // TODO:
+  //   Check registered components for existence of user supplied router link component name
+  //   We would need to check PascalCase, kebab-case, and camelCase versions of name:
+  //   const name = routerComponentName
+  //   const names = [name, PascalCase(name), KebabCase(name), CamelCase(name)]
+  //   exists = names.some(name => !!thisOrParent.$options.components[name])
+  //   And may want to cache the result for performance or we just let the render fail
+  //   if the component is not registered
+  return routerComponentName || (hasNuxt ? 'nuxt-link' : 'router-link')
+}
+
+export const computeRel = ({ target, rel } = {}) =>
+  target === '_blank' && isNull(rel) ? 'noopener' : rel || null
+
+export const computeHref = (
+  { href, to } = {},
+  tag = ANCHOR_TAG,
+  fallback = '#',
+  toFallback = '/'
+) => {
+  // Return `href` when explicitly provided
+  if (href) {
+    return href
+  }
+
+  // We've checked for `$router` in `computeTag()`, so `isRouterLink()` indicates a live router
+  // When deferring to Vue Router's `<router-link>`, don't use the `href` attribute at all
+  // We return `null`, and then remove `href` from the attributes passed to `<router-link>`
+  if (isRouterLink(tag)) {
+    return null
+  }
+
+  // Fallback to `to` prop (if `to` is a string)
+  if (isString(to)) {
+    return to || toFallback
+  }
+  // Fallback to `to.path' + `to.query` + `to.hash` prop (if `to` is an object)
+  if (isPlainObject(to) && (to.path || to.query || to.hash)) {
+    const path = toString(to.path)
+    const query = stringifyQueryObj(to.query)
+    let hash = toString(to.hash)
+    hash = !hash || hash.charAt(0) === '#' ? hash : `#${hash}`
+    return `${path}${query}${hash}` || toFallback
+  }
+
+  // If nothing is provided return the fallback
+  return fallback
+}

package/src/vendor/bootstrap-vue/src/utils/safe-vue-instance.js

@@ -0,0 +1,13 @@
+import { isVue3 } from '../vue'
+
+export function safeVueInstance(target) {
+  if (!isVue3) {
+    return target
+  }
+
+  return new Proxy(target, {
+    get(target, prop) {
+      return prop in target ? target[prop] : undefined
+    }
+  })
+}