@gitlab/duo-ui 3.0.0 → 3.0.1

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

@@ -1,77 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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/props.spec.js

@@ -1,112 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { setConfig } from './config-set'
-import { copyProps, makeProp, makePropsConfigurable } from './props'
-
-describe('utils/props', () => {
-  it('copyProps() works with array props', async () => {
-    const props = ['a', 'b', 'c']
-
-    expect(copyProps(props)).toEqual(props)
-    // Should be a new array reference
-    expect(copyProps(props)).not.toBe(props)
-  })
-
-  it('copyProps() works with object props', async () => {
-    const props = {
-      a: { type: String, default: 'foobar' },
-      b: { type: [Object, Array], default: null },
-      c: 'c'
-    }
-
-    expect(copyProps(props)).toEqual(props)
-    // Should be a new object reference
-    expect(copyProps(props)).not.toBe(props)
-    // Properties should be new object references
-    expect(copyProps(props).a).not.toBe(props.a)
-    expect(copyProps(props).a).toEqual(props.a)
-    expect(copyProps(props).b).not.toBe(props.b)
-    expect(copyProps(props).b).toEqual(props.b)
-    // Except for primatives
-    expect(copyProps(props).c).toBe(props.c)
-    expect(copyProps(props).c).toEqual(props.c)
-  })
-
-  it('makeProp() works', async () => {
-    expect(makeProp()).toEqual({})
-    expect(makeProp(undefined)).toEqual({})
-    expect(makeProp(null)).toEqual({})
-    expect(makeProp('')).toEqual({})
-
-    expect(makeProp(Array)).toEqual({ type: Array })
-    expect(makeProp(Boolean)).toEqual({ type: Boolean })
-    expect(makeProp(Function)).toEqual({ type: Function })
-    expect(makeProp(Number)).toEqual({ type: Number })
-    expect(makeProp(Object)).toEqual({ type: Object })
-    expect(makeProp(String)).toEqual({ type: String })
-
-    expect(makeProp(Array, null)).toEqual({ type: Array, default: null })
-    expect(makeProp(Boolean, false)).toEqual({ type: Boolean, default: false })
-    expect(makeProp(Function, null)).toEqual({ type: Function, default: null })
-    expect(makeProp(Number, 0)).toEqual({ type: Number, default: 0 })
-    expect(makeProp(Object, null)).toEqual({ type: Object, default: null })
-    expect(makeProp(String, '')).toEqual({ type: String, default: '' })
-
-    expect(typeof makeProp(Array, []).default).toEqual('function')
-    expect(makeProp(Array, []).default()).toEqual([])
-
-    const fn = () => {}
-    expect(typeof makeProp(Function, fn).default).toEqual('function')
-    expect(makeProp(Function, fn).default).toEqual(fn)
-
-    expect(typeof makeProp(Object, {}).default).toEqual('function')
-    expect(makeProp(Object, {}).default()).toEqual({})
-
-    expect(makeProp(Array, undefined, true)).toEqual({ type: Array, required: true })
-    expect(makeProp(Boolean, undefined, true)).toEqual({ type: Boolean, required: true })
-    expect(makeProp(Function, undefined, true)).toEqual({ type: Function, required: true })
-    expect(makeProp(Number, undefined, true)).toEqual({ type: Number, required: true })
-    expect(makeProp(Object, undefined, true)).toEqual({ type: Object, required: true })
-    expect(makeProp(String, undefined, true)).toEqual({ type: String, required: true })
-
-    const validator = value => !!value
-    expect(makeProp(String, '', undefined)).toEqual({ type: String, default: '' })
-    expect(makeProp(String, '', validator)).toEqual({ type: String, default: '', validator })
-    expect(makeProp(String, undefined, validator)).toEqual({ type: String, validator })
-    expect(makeProp(String, '', true, validator)).toEqual({
-      type: String,
-      required: true,
-      validator
-    })
-  })
-
-  it('makePropsConfigurable() works', async () => {
-    const NAME = 'MyComponent'
-    const props = {
-      text: {
-        type: String,
-        default: 'foo'
-      }
-    }
-    const config = {
-      [NAME]: { text: 'bar' }
-    }
-    const ConfigurableComponent = {
-      name: NAME,
-      props: makePropsConfigurable(props, NAME),
-      render(h) {
-        return h('div', this.text)
-      }
-    }
-
-    setConfig(config)
-
-    const wrapper = mount(ConfigurableComponent)
-
-    expect(wrapper.vm).toBeDefined()
-    expect(wrapper.element.tagName).toBe('DIV')
-    expect(wrapper.text()).toBe('bar')
-
-    await wrapper.setProps({ text: 'baz' })
-    expect(wrapper.text()).toBe('baz')
-  })
-})

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

@@ -1,145 +0,0 @@
-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
-}