@gitlab/duo-ui 3.0.0 → 4.0.0

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

@@ -1,248 +0,0 @@
-import {
-  stringifyQueryObj,
-  parseQuery,
-  computeHref,
-  isRouterLink,
-  computeRel,
-  computeTag
-} from './router'
-
-describe('utils/router', () => {
-  // stringifyQueryObject() utility method
-  describe('stringifyQueryObj()', () => {
-    it('returns empty string when noting passed', async () => {
-      expect(stringifyQueryObj()).toEqual('')
-    })
-
-    it('handles special chars', async () => {
-      expect(stringifyQueryObj({ foo: ", !'()*" })).toEqual('?foo=,%20%21%27%28%29%2a')
-      expect(stringifyQueryObj({ ", !'()*": 'foo' })).toEqual('?,%20%21%27%28%29%2a=foo')
-    })
-
-    it('handles multiple keys', async () => {
-      const obj = {
-        foo: 1,
-        bar: 'baz'
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=1&bar=baz')
-    })
-
-    it('handles array as values', async () => {
-      const obj = {
-        foo: 1,
-        bar: ['a', 'b', 'c']
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=1&bar=a&bar=b&bar=c')
-    })
-
-    it('skips undefined values', async () => {
-      const obj = {
-        foo: 1,
-        bar: undefined,
-        baz: 2
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=1&baz=2')
-    })
-
-    it('skips undefined values in arrays', async () => {
-      const obj = {
-        foo: ['a', undefined, 'c']
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=a&foo=c')
-    })
-
-    it('leaves in null value keys', async () => {
-      const obj = {
-        foo: 1,
-        bar: null,
-        baz: 2
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=1&bar&baz=2')
-    })
-
-    it('leaves in null values in arrays', async () => {
-      const obj = {
-        foo: ['a', null, 'c']
-      }
-      expect(stringifyQueryObj(obj)).toEqual('?foo=a&foo&foo=c')
-    })
-  })
-
-  describe('parseQuery()', () => {
-    it('returns empty object when empty query', async () => {
-      expect(parseQuery('')).toEqual({})
-      expect(parseQuery('?')).toEqual({})
-    })
-
-    it('parses simple query', async () => {
-      expect(parseQuery('?foo=bar')).toEqual({ foo: 'bar' })
-      expect(parseQuery('?foo=bar&baz=buz')).toEqual({ foo: 'bar', baz: 'buz' })
-    })
-
-    it('parses empty values', async () => {
-      expect(parseQuery('?foo')).toEqual({ foo: null })
-      expect(parseQuery('?foo=bar&baz')).toEqual({ foo: 'bar', baz: null })
-      expect(parseQuery('?foo=&baz')).toEqual({ foo: '', baz: null })
-    })
-
-    it('handles null key/value pairs values', async () => {
-      expect(parseQuery('?foo=bar&&baz=fiz')).toEqual({ foo: 'bar', '': null, baz: 'fiz' })
-      expect(parseQuery('?foo=bar&=&baz=fiz')).toEqual({ foo: 'bar', '': '', baz: 'fiz' })
-    })
-
-    it('handles values with = characters', async () => {
-      expect(parseQuery('?foo=bar=baz')).toEqual({ foo: 'bar=baz' })
-    })
-
-    it('parses duplicate keys as arrays', async () => {
-      expect(parseQuery('?foo=bar&foo=baz')).toEqual({ foo: ['bar', 'baz'] })
-      expect(parseQuery('?foo=&foo=baz&foo')).toEqual({ foo: ['', 'baz', null] })
-      expect(parseQuery('?foo=bar&baz=buz&baz=fiz')).toEqual({ foo: 'bar', baz: ['buz', 'fiz'] })
-    })
-  })
-
-  // computeHref() utility method
-  describe('computeHref()', () => {
-    it('works with href', async () => {
-      const obj = { href: '/foo/bar?baz=123' }
-      expect(computeHref(obj)).toEqual(obj.href)
-    })
-
-    it('parses nothing to default', async () => {
-      expect(computeHref()).toEqual('#')
-      expect(computeHref(undefined, undefined, '/', '')).toEqual('/')
-      expect(computeHref(undefined, undefined, '', '')).toEqual('')
-    })
-
-    it('returns null when tag is not `a`', async () => {
-      expect(computeHref({}, 'div')).toEqual(null)
-      expect(computeHref(undefined, 'div', '/', '')).toEqual(null)
-      expect(computeHref(undefined, 'span', '', '/')).toEqual(null)
-    })
-
-    it('returns href when both href and to provided', async () => {
-      const obj = {
-        href: '/foo/bar?baz=123',
-        to: '/baz/bar'
-      }
-      expect(computeHref(obj)).toEqual(obj.href)
-    })
-
-    it('parses empty `href` to default', async () => {
-      expect(computeHref({ href: '' })).toEqual('#')
-      expect(computeHref({ href: '' }, 'a', '/', '')).toEqual('/')
-      expect(computeHref({ href: '' }, 'a', '', '')).toEqual('')
-    })
-
-    it('parses `to` when string', async () => {
-      const obj = {
-        to: '/baz/bar'
-      }
-      expect(computeHref(obj)).toEqual(obj.to)
-    })
-
-    it('parses `to` with only path', async () => {
-      const obj = {
-        to: {
-          path: '/baz/bar'
-        }
-      }
-      expect(computeHref(obj)).toEqual(obj.to.path)
-    })
-
-    it('parses `to` with only hash', async () => {
-      const obj = {
-        to: {
-          hash: '#foobar'
-        }
-      }
-      expect(computeHref(obj)).toEqual(obj.to.hash)
-    })
-
-    it('parses `to` with hash missing "#"', async () => {
-      const obj = {
-        to: {
-          hash: 'foobar'
-        }
-      }
-      expect(computeHref(obj)).toEqual('#foobar')
-    })
-
-    it('parses `to` with only query', async () => {
-      const obj = {
-        to: {
-          query: { foo: 'bar' }
-        }
-      }
-      expect(computeHref(obj)).toEqual('?foo=bar')
-    })
-
-    it('parses empty `to` to fallback default', async () => {
-      expect(computeHref({ to: {} })).toEqual('#')
-      expect(computeHref({ to: {} }, 'a', '#', '')).toEqual('#')
-      expect(computeHref({ to: {} }, 'a', '/', '#')).toEqual('/')
-    })
-
-    it('parses complete `to`', async () => {
-      const obj = {
-        to: {
-          path: '/foo',
-          query: {
-            bar: 1,
-            baz: ['a', 'b', 'c'],
-            bif: null,
-            zap: undefined
-          },
-          hash: '#fizzlerocks'
-        }
-      }
-      expect(computeHref(obj)).toEqual('/foo?bar=1&baz=a&baz=b&baz=c&bif#fizzlerocks')
-    })
-  })
-
-  // isRouterLink() utility method
-  describe('isRouterLink()', () => {
-    it('works', async () => {
-      expect(isRouterLink('a')).toBe(false)
-      expect(isRouterLink('router-link')).toBe(true)
-      expect(isRouterLink('nuxt-link')).toBe(true)
-      expect(isRouterLink()).toBe(false)
-    })
-  })
-
-  // computeRel() utility method
-  describe('computeRel()', () => {
-    it('works', async () => {
-      expect(computeRel({ target: '_blank', rel: null })).toBe('noopener')
-      expect(computeRel({ target: '_blank', rel: undefined })).toBe(null)
-      expect(computeRel({ target: '_blank' })).toBe(null)
-      expect(computeRel({ target: '_blank', rel: 'foo' })).toBe('foo')
-      expect(computeRel({ target: '_notblank', rel: null })).toBe(null)
-      expect(computeRel({ target: '_notblank', rel: undefined })).toBe(null)
-      expect(computeRel({ target: '_notblank', rel: 'foo' })).toBe('foo')
-      expect(computeRel({})).toBe(null)
-    })
-  })
-
-  // computeTag() utility method
-  describe('computeTag()', () => {
-    it('works', async () => {
-      const context1 = { $router: {} }
-      const context2 = { $router: {}, $nuxt: {} }
-      const context3 = {}
-
-      expect(computeTag({ to: '/foo' }, context1)).toBe('router-link')
-      expect(computeTag({ to: '/foo' }, context2)).toBe('nuxt-link')
-      expect(computeTag({ to: '/foo' }, context3)).toBe('a')
-      expect(computeTag({}, context1)).toBe('a')
-      expect(computeTag({}, context2)).toBe('a')
-      expect(computeTag({}, context3)).toBe('a')
-      expect(computeTag({ to: '/foo', disabled: true }, context1)).toBe('a')
-      expect(computeTag({ to: '/foo', disabled: true }, context2)).toBe('a')
-      expect(computeTag({ to: '/foo', disabled: true }, context3)).toBe('a')
-      expect(computeTag({ disabled: true }, context1)).toBe('a')
-      expect(computeTag({ disabled: true }, context2)).toBe('a')
-      expect(computeTag({ disabled: true }, context3)).toBe('a')
-    })
-  })
-})

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

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

package/src/vendor/bootstrap-vue/src/utils/stable-sort.js

@@ -1,31 +0,0 @@
-/*
- * Consistent and stable sort function across JavaScript platforms
- *
- * Inconsistent sorts can cause SSR problems between client and server
- * such as in <b-table> if sortBy is applied to the data on server side render.
- * Chrome and V8 native sorts are inconsistent/unstable
- *
- * This function uses native sort with fallback to index compare when the a and b
- * compare returns 0
- *
- * Algorithm based on:
- * https://stackoverflow.com/questions/1427608/fast-stable-sorting-algorithm-implementation-in-javascript/45422645#45422645
- *
- * @param {array} array to sort
- * @param {function} sort compare function
- * @return {array}
- */
-export const stableSort = (array, compareFn) => {
-  // Using `.bind(compareFn)` on the wrapped anonymous function improves
-  // performance by avoiding the function call setup. We don't use an arrow
-  // function here as it binds `this` to the `stableSort` context rather than
-  // the `compareFn` context, which wouldn't give us the performance increase.
-  return array
-    .map((a, index) => [index, a])
-    .sort(
-      function(a, b) {
-        return this(a[1], b[1]) || a[0] - b[0]
-      }.bind(compareFn)
-    )
-    .map(e => e[1])
-}

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

@@ -1,59 +0,0 @@
-// String utilities
-import {
-  RX_HYPHENATE,
-  RX_LOWER_UPPER,
-  RX_REGEXP_REPLACE,
-  RX_START_SPACE_WORD,
-  RX_TRIM_LEFT,
-  RX_TRIM_RIGHT,
-  RX_UNDERSCORE
-} from '../constants/regex'
-import { isArray, isPlainObject, isString, isUndefinedOrNull } from './inspect'
-
-// --- Utilities ---
-
-// Converts PascalCase or camelCase to kebab-case
-export const kebabCase = str => {
-  return str.replace(RX_HYPHENATE, '-$1').toLowerCase()
-}
-
-// Converts a string, including strings in camelCase or snake_case, into Start Case
-// It keeps original single quote and hyphen in the word
-// https://github.com/UrbanCompass/to-start-case
-export const startCase = str =>
-  str
-    .replace(RX_UNDERSCORE, ' ')
-    .replace(RX_LOWER_UPPER, (str, $1, $2) => $1 + ' ' + $2)
-    .replace(RX_START_SPACE_WORD, (str, $1, $2) => $1 + $2.toUpperCase())
-
-// Uppercases the first letter of a string and returns a new string
-export const upperFirst = str => {
-  str = isString(str) ? str.trim() : String(str)
-  return str.charAt(0).toUpperCase() + str.slice(1)
-}
-
-// Escape characters to be used in building a regular expression
-export const escapeRegExp = str => str.replace(RX_REGEXP_REPLACE, '\\$&')
-
-// Convert a value to a string that can be rendered
-// `undefined`/`null` will be converted to `''`
-// Plain objects and arrays will be JSON stringified
-export const toString = (val, spaces = 2) => {
-  return isUndefinedOrNull(val)
-    ? ''
-    : isArray(val) || (isPlainObject(val) && val.toString === Object.prototype.toString)
-      ? JSON.stringify(val, null, spaces)
-      : String(val)
-}
-
-// Remove leading white space from a string
-export const trimLeft = str => toString(str).replace(RX_TRIM_LEFT, '')
-
-// Remove Trailing white space from a string
-export const trimRight = str => toString(str).replace(RX_TRIM_RIGHT, '')
-
-// Remove leading and trailing white space from a string
-export const trim = str => toString(str).trim()
-
-// Lower case a string
-export const lowerCase = str => toString(str).toLowerCase()

package/src/vendor/bootstrap-vue/src/utils/string.spec.js

@@ -1,65 +0,0 @@
-import { escapeRegExp, kebabCase, startCase, toString, upperFirst } from './string'
-
-describe('utils/string', () => {
-  it('kebabCase() works', async () => {
-    expect(kebabCase('foo')).toBe('foo')
-    expect(kebabCase('Foo')).toBe('foo')
-    expect(kebabCase('fooBar')).toBe('foo-bar')
-    expect(kebabCase('FooBar')).toBe('foo-bar')
-    expect(kebabCase('XFooBar')).toBe('x-foo-bar')
-  })
-
-  it('startCase() works', async () => {
-    expect(startCase('foobar')).toBe('Foobar')
-    expect(startCase('Foobar')).toBe('Foobar')
-    expect(startCase('foo_bar')).toBe('Foo Bar')
-    expect(startCase('foo bar')).toBe('Foo Bar')
-    expect(startCase('fooBar')).toBe('Foo Bar')
-  })
-
-  it('upperFirst() works', async () => {
-    expect(upperFirst('lower')).toBe('Lower')
-    expect(upperFirst(' lower ')).toBe('Lower')
-    expect(upperFirst('lower case')).toBe('Lower case')
-    expect(upperFirst(null)).toBe('Null')
-    expect(upperFirst(undefined)).toBe('Undefined')
-    expect(upperFirst({})).toBe('[object Object]')
-    expect(upperFirst([])).toBe('')
-    expect(upperFirst(['foo', 'bar'])).toBe('Foo,bar')
-  })
-
-  it('escapeRegExp() works', async () => {
-    expect(escapeRegExp('Hello?')).toBe('Hello\\?')
-    expect(escapeRegExp('$100')).toBe('\\$100')
-    expect(escapeRegExp('10 * 5')).toBe('10 \\* 5')
-    expect(escapeRegExp('[-/\\^$*+?.()|[\\]{}]')).toBe(
-      '\\[\\-\\/\\\\\\^\\$\\*\\+\\?\\.\\(\\)\\|\\[\\\\\\]\\{\\}\\]'
-    )
-  })
-
-  it('toString() works', async () => {
-    expect(toString(null)).toBe('')
-    expect(toString(undefined)).toBe('')
-    expect(toString(true)).toBe('true')
-    expect(toString(false)).toBe('false')
-    expect(toString({ a: 1, b: 2, c: { d: 'foo' } })).toBe(`{
-  "a": 1,
-  "b": 2,
-  "c": {
-    "d": "foo"
-  }
-}`)
-    expect(toString({ a: 1, b: 2, c: { d: 'foo' } }, 4)).toBe(`{
-    "a": 1,
-    "b": 2,
-    "c": {
-        "d": "foo"
-    }
-}`)
-    expect(toString([])).toBe('[]')
-    expect(toString(['foo', 'bar'])).toBe(`[
-  "foo",
-  "bar"
-]`)
-  })
-})

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

@@ -1,31 +0,0 @@
-import { isDate, isObject, isUndefinedOrNull } from './inspect'
-import { keys } from './object'
-import { toString } from './string'
-
-// Recursively stringifies the values of an object, space separated, in an
-// SSR safe deterministic way (keys are sorted before stringification)
-//
-//   ex:
-//     { b: 3, c: { z: 'zzz', d: null, e: 2 }, d: [10, 12, 11], a: 'one' }
-//   becomes
-//     'one 3 2 zzz 10 12 11'
-//
-// Strings are returned as-is
-// Numbers get converted to string
-// `null` and `undefined` values are filtered out
-// Dates are converted to their native string format
-export const stringifyObjectValues = value => {
-  if (isUndefinedOrNull(value)) {
-    return ''
-  }
-  // Arrays are also object, and keys just returns the array indexes
-  // Date objects we convert to strings
-  if (isObject(value) && !isDate(value)) {
-    return keys(value)
-      .sort() // Sort to prevent SSR issues on pre-rendered sorted tables
-      .map(k => stringifyObjectValues(value[k]))
-      .filter(v => !!v) // Ignore empty strings
-      .join(' ')
-  }
-  return toString(value)
-}

package/src/vendor/bootstrap-vue/src/utils/stringify-object-values.spec.js

@@ -1,47 +0,0 @@
-import { stringifyObjectValues } from './stringify-object-values'
-
-describe('stringifyObjectValues()', () => {
-  it('handles `null` and `undefined`', async () => {
-    expect(stringifyObjectValues(null)).toBe('')
-    expect(stringifyObjectValues(undefined)).toBe('')
-    expect(stringifyObjectValues()).toBe('')
-  })
-
-  it('returns strings as-is', async () => {
-    expect(stringifyObjectValues('foo')).toBe('foo')
-    expect(stringifyObjectValues('123')).toBe('123')
-    expect(stringifyObjectValues('  bar  ')).toBe('  bar  ')
-  })
-
-  it('converts numbers to string', async () => {
-    expect(stringifyObjectValues(0)).toBe('0')
-    expect(stringifyObjectValues(1)).toBe('1')
-    expect(stringifyObjectValues(-1)).toBe('-1')
-  })
-
-  it('converts dates to native string format', async () => {
-    const date1 = new Date(2020, 1, 1)
-    const date2 = new Date(2030, 1, 1)
-    const date3 = new Date(1970, 1, 1)
-
-    expect(stringifyObjectValues(date1)).toBe(date1.toString())
-    expect(stringifyObjectValues(date2)).toBe(date2.toString())
-    expect(stringifyObjectValues(date3)).toBe(date3.toString())
-  })
-
-  it('converts array values to a string', async () => {
-    expect(stringifyObjectValues([])).toBe('')
-    expect(stringifyObjectValues([1, 'foo'])).toBe('1 foo')
-    expect(stringifyObjectValues([undefined, null])).toBe('')
-  })
-
-  it('converts object values to a string', async () => {
-    expect(stringifyObjectValues({})).toBe('')
-    expect(stringifyObjectValues({ a: 1, b: 'foo' })).toBe('1 foo')
-    expect(stringifyObjectValues({ a: null, b: undefined })).toBe('')
-    expect(stringifyObjectValues({ a: [undefined, null, { b: 1 }] })).toBe('1')
-    expect(
-      stringifyObjectValues({ b: 3, c: { z: 'zzz', d: null, e: 2 }, d: [10, 12, 11], a: 'one' })
-    ).toBe('one 3 2 zzz 10 12 11')
-  })
-})

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

@@ -1,42 +0,0 @@
-import { IS_BROWSER, HAS_MUTATION_OBSERVER_SUPPORT } from '../constants/env'
-import { getNoWarn } from './env'
-
-/**
- * Log a warning message to the console with BootstrapVue formatting
- * @param {string} message
- */
-export const warn = (message, source = null) => /* istanbul ignore next */ {
-  if (!getNoWarn()) {
-    console.warn(`[BootstrapVue warn]: ${source ? `${source} - ` : ''}${message}`)
-  }
-}
-
-/**
- * Warn when no Promise support is given
- * @param {string} source
- * @returns {boolean} warned
- */
-export const warnNotClient = source => {
-  /* istanbul ignore else */
-  if (IS_BROWSER) {
-    return false
-  } else {
-    warn(`${source}: Can not be called during SSR.`)
-    return true
-  }
-}
-
-/**
- * Warn when no MutationObserver support is given
- * @param {string} source
- * @returns {boolean} warned
- */
-export const warnNoMutationObserverSupport = source => {
-  /* istanbul ignore else */
-  if (HAS_MUTATION_OBSERVER_SUPPORT) {
-    return false
-  } else {
-    warn(`${source}: Requires MutationObserver support.`)
-    return true
-  }
-}

package/src/vendor/bootstrap-vue/src/utils/warn.spec.js

@@ -1,54 +0,0 @@
-import { warn } from './warn'
-
-describe('utils/warn', () => {
-  const dummyWarning = 'This is a dummy warning.'
-  const dummySource = 'DummyComponent'
-
-  let originalProcess
-
-  beforeAll(() => {
-    jest.spyOn(console, 'warn').mockImplementation(() => {})
-    originalProcess = global.process
-  })
-
-  afterEach(() => {
-    console.warn.mockClear()
-    global.process = originalProcess
-  })
-
-  describe('with "BOOTSTRAP_VUE_NO_WARN" environment variable set', () => {
-    beforeEach(() => {
-      global.process = {
-        env: {
-          BOOTSTRAP_VUE_NO_WARN: true
-        }
-      }
-    })
-
-    it('does not call "console.warn()"', () => {
-      warn(dummyWarning)
-
-      expect(console.warn).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('without process object', () => {
-    beforeEach(() => {
-      delete global.process
-    })
-
-    it('calls "console.warn()" with warning', () => {
-      warn(dummyWarning)
-
-      expect(console.warn).toHaveBeenCalledWith(`[BootstrapVue warn]: ${dummyWarning}`)
-    })
-
-    it('calls "console.warn()" with warning and source', () => {
-      warn(dummyWarning, dummySource)
-
-      expect(console.warn).toHaveBeenCalledWith(
-        `[BootstrapVue warn]: ${dummySource} - ${dummyWarning}`
-      )
-    })
-  })
-})

package/src/vendor/bootstrap-vue/src/vue-injections.d.ts

@@ -1,13 +0,0 @@
-/**
- * Augment the typings of Vue.js
- */
-import Vue from 'vue'
-import { BvModal } from './components/modal'
-import { BvToast } from './components/toast'
-
-declare module 'vue/types/vue' {
-  interface Vue {
-    readonly $bvModal: BvModal
-    readonly $bvToast: BvToast
-  }
-}