@gitlab/ui 114.1.0 → 114.1.1

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

@@ -1,72 +0,0 @@
-import { toFixed, toFloat, toInteger } from './number'
-
-describe('utils/number', () => {
-  it('toInteger works', async () => {
-    expect(toInteger(1)).toBe(1)
-    expect(toInteger('1')).toBe(1)
-    expect(toInteger(1e5)).toBe(100000)
-    expect(toInteger('1e5')).toBe(1)
-    expect(toInteger('256 foobar')).toBe(256)
-    expect(toInteger('foo 256bar')).toBe(NaN)
-    expect(toInteger({})).toBe(NaN)
-    expect(toInteger([])).toBe(NaN)
-    expect(toInteger(new Date())).toBe(NaN)
-    expect(toInteger(null)).toBe(NaN)
-    expect(toInteger(undefined)).toBe(NaN)
-    expect(toInteger(null, 0)).toBe(0)
-    expect(toInteger(undefined, -1)).toBe(-1)
-  })
-
-  it('toFloat works', async () => {
-    expect(toFloat(1)).toBe(1)
-    expect(toFloat('1')).toBe(1)
-    expect(toFloat(1.23)).toBe(1.23)
-    expect(toFloat('1.23')).toBe(1.23)
-    expect(toFloat(1e5)).toBe(100000)
-    // `parseFloat()` works differently than `parseInt()` in this case
-    expect(toFloat('1e5')).toBe(100000)
-    expect(toFloat('256 foobar')).toBe(256)
-    expect(toFloat('256.78 foobar')).toBe(256.78)
-    expect(toFloat('foo 256bar')).toBe(NaN)
-    expect(toFloat({})).toBe(NaN)
-    expect(toFloat([])).toBe(NaN)
-    expect(toFloat(new Date())).toBe(NaN)
-    expect(toFloat(null)).toBe(NaN)
-    expect(toFloat(undefined)).toBe(NaN)
-    expect(toFloat(null, 0)).toBe(0)
-    expect(toFloat(undefined, -1)).toBe(-1)
-  })
-
-  it('toFixed works', async () => {
-    expect(toFixed(1)).toBe('1')
-    expect(toFixed(1.23)).toBe('1')
-    expect(toFixed(1.78)).toBe('2')
-    expect(toFixed('1')).toBe('1')
-    expect(toFixed('1.23')).toBe('1')
-    expect(toFixed('1.78')).toBe('2')
-    expect(toFixed(1, 2)).toBe('1.00')
-    expect(toFixed('1', 2)).toBe('1.00')
-    expect(toFixed('1 foo', 2)).toBe('1.00')
-    expect(toFixed('foo 1 bar', 2)).toBe('NaN')
-    expect(toFixed('1.23', 4)).toBe('1.2300')
-    expect(toFixed('1.78', 2)).toBe('1.78')
-    expect(toFixed({})).toBe('NaN')
-    expect(toFixed([])).toBe('NaN')
-    expect(toFixed(new Date())).toBe('NaN')
-    expect(toFixed(null)).toBe('NaN')
-    expect(toFixed(undefined)).toBe('NaN')
-    expect(toFixed({}, 3)).toBe('NaN')
-    expect(toFixed([], 2)).toBe('NaN')
-    expect(toFixed(new Date(), 1)).toBe('NaN')
-    expect(toFixed(null, 4)).toBe('NaN')
-    expect(toFixed(undefined, 3)).toBe('NaN')
-    expect(toFixed(1, '2')).toBe('1.00')
-    expect(toFixed('1', '2')).toBe('1.00')
-    expect(toFixed('1 foo', '2')).toBe('1.00')
-    expect(toFixed('foo 1 bar', '2')).toBe('NaN')
-    expect(toFixed(1, 'foo')).toBe('1')
-    expect(toFixed('1', undefined)).toBe('1')
-    expect(toFixed('1 foo', null)).toBe('1')
-    expect(toFixed('foo 1 bar', {})).toBe('NaN')
-  })
-})

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

@@ -1,61 +0,0 @@
-import { pick, omit, mergeDeep } from './object'
-
-describe('utils/object', () => {
-  it('pick() works', async () => {
-    const obj = { a: 1, b: 2, c: 3, d: null, e: [] }
-
-    expect(pick(obj, ['a', 'b', 'c'])).toEqual({ a: 1, b: 2, c: 3 })
-    expect(pick(obj, Object.keys(obj))).toEqual(obj)
-    expect(pick(obj, [])).toEqual({})
-  })
-
-  it('omit() works', async () => {
-    const obj = { a: 1, b: 2, c: 3, d: null, e: [] }
-
-    expect(omit(obj, ['a', 'b', 'c'])).toEqual({ d: null, e: [] })
-    expect(omit(obj, Object.keys(obj))).toEqual({})
-    expect(omit(obj, [])).toEqual(obj)
-  })
-
-  it('mergeDeep() works', async () => {
-    const A = {
-      a: {
-        loc: 'Earth',
-        title: 'Hello World',
-        type: 'Planet',
-        deeper: {
-          map: new Map([['a', 'AAA'], ['b', 'BBB']]),
-          mapId: 15473
-        }
-      }
-    }
-    const B = {
-      a: {
-        type: 'Star',
-        deeper: {
-          mapId: 9999,
-          alt_map: new Map([['x', 'XXXX'], ['y', 'YYYY']])
-        }
-      }
-    }
-
-    const C = mergeDeep(A, B)
-    const D = mergeDeep({ a: 1 }, { b: { c: { d: { e: 12345 } } } })
-    const E = mergeDeep({ b: { c: 'hallo' } }, { b: { c: { d: { e: 12345 } } } })
-    const F = mergeDeep(
-      { b: { c: { d: { e: 12345 } }, d: 'dag', f: 'one' } },
-      { b: { c: 'hallo', e: 'ok', f: 'two' } }
-    )
-
-    expect(C.a.type).toEqual('Star')
-    expect(C.a.deeper.alt_map.get('x')).toEqual('XXXX')
-    expect(C.a.deeper.map.get('b')).toEqual('BBB')
-    expect(D.a).toEqual(1)
-    expect(D.b.c.d.e).toEqual(12345)
-    expect(E.b.c.d.e).toEqual(12345)
-    expect(F.b.c).toEqual('hallo')
-    expect(F.b.d).toEqual('dag')
-    expect(F.b.e).toEqual('ok')
-    expect(F.b.f).toEqual('two')
-  })
-})

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.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/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.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.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}`
-      )
-    })
-  })
-})