@gitlab/duo-ui 0.1.0 → 0.3.0

package/src/vendor/bootstrap-vue/src/utils/loose-equal.spec.js

@@ -0,0 +1,203 @@
+import { looseEqual } from './loose-equal'
+
+describe('utils/looseEqual', () => {
+  it('compares booleans correctly', () => {
+    expect(looseEqual(true, true)).toBe(true)
+    expect(looseEqual(false, false)).toBe(true)
+    expect(looseEqual(true, false)).toBe(false)
+    expect(looseEqual(true, true)).toBe(true)
+    expect(looseEqual(true, 1)).toBe(false)
+    expect(looseEqual(false, 0)).toBe(false)
+  })
+
+  it('compares strings correctly', () => {
+    const text = 'Lorem ipsum'
+    const number = 1
+    const bool = true
+
+    expect(looseEqual(text, text)).toBe(true)
+    expect(looseEqual(text, text.slice(0, -1))).toBe(false)
+    expect(looseEqual(String(number), number)).toBe(true)
+    expect(looseEqual(String(bool), bool)).toBe(true)
+  })
+
+  it('compares numbers correctly', () => {
+    const number = 100
+    const decimal = 2.5
+    const multiplier = 1.0000001
+
+    expect(looseEqual(number, number)).toBe(true)
+    expect(looseEqual(number, number - 1)).toBe(false)
+    expect(looseEqual(decimal, decimal)).toBe(true)
+    expect(looseEqual(decimal, decimal * multiplier)).toBe(false)
+    expect(looseEqual(number, number * multiplier)).toBe(false)
+    expect(looseEqual(multiplier, multiplier)).toBe(true)
+  })
+
+  it('compares dates correctly', () => {
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date2 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date3 = new Date(2020, 1, 2, 3, 4, 5, 7)
+    const date4 = new Date(2219, 1, 2, 3, 4, 5, 6)
+
+    // Identical date object references
+    expect(looseEqual(date1, date1)).toBe(true)
+    // Different date references with identical values
+    expect(looseEqual(date1, date2)).toBe(true)
+    // Dates with slightly different time (ms)
+    expect(looseEqual(date1, date3)).toBe(false)
+    // Dates with different year
+    expect(looseEqual(date1, date4)).toBe(false)
+  })
+
+  it('compares files correctly', () => {
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date2 = new Date(2020, 1, 2, 3, 4, 5, 7)
+    const file1 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file2 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file3 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date2 })
+    const file4 = new File([''], 'filename.csv', { type: 'text/csv', lastModified: date1 })
+    const file5 = new File(['abcdef'], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file6 = new File(['12345'], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+
+    // Identical file object references
+    expect(looseEqual(file1, file1)).toBe(true)
+    // Different file references with identical values
+    expect(looseEqual(file1, file2)).toBe(true)
+    // Files with slightly different dates
+    expect(looseEqual(file1, file3)).toBe(false)
+    // Two different file types
+    expect(looseEqual(file1, file4)).toBe(false)
+    // Two files with same name, modified date, but different content
+    expect(looseEqual(file5, file6)).toBe(false)
+  })
+
+  it('compares arrays correctly', () => {
+    const arr1 = [1, 2, 3, 4]
+    const arr2 = [1, 2, 3, '4']
+    const arr3 = [1, 2, 3, 4, 5]
+    const arr4 = [1, 2, 3, 4, { a: 5 }]
+
+    // Identical array references
+    expect(looseEqual(arr1, arr1)).toBe(true)
+    // Different array references with identical values
+    expect(looseEqual(arr1, arr1.slice())).toBe(true)
+    expect(looseEqual(arr4, arr4.slice())).toBe(true)
+    // Array with one value different (loose)
+    expect(looseEqual(arr1, arr2)).toBe(true)
+    // Array with one value different
+    expect(looseEqual(arr3, arr4)).toBe(false)
+    // Arrays with different lengths
+    expect(looseEqual(arr1, arr3)).toBe(false)
+    // Arrays with values in different order
+    expect(looseEqual(arr1, arr1.slice().reverse())).toBe(false)
+  })
+
+  it('compares RegExp correctly', () => {
+    const rx1 = /^foo$/
+    const rx2 = /^foo$/
+    const rx3 = /^bar$/
+    const rx4 = /^bar$/i
+
+    // Identical regex references
+    expect(looseEqual(rx1, rx1)).toBe(true)
+    // Different regex references with identical values
+    expect(looseEqual(rx1, rx2)).toBe(true)
+    // Different regex
+    expect(looseEqual(rx1, rx3)).toBe(false)
+    // Same regex with different options
+    expect(looseEqual(rx3, rx4)).toBe(false)
+  })
+
+  it('compares objects correctly', () => {
+    const obj1 = { foo: 'bar' }
+    const obj2 = { foo: 'bar1' }
+    const obj3 = { a: 1, b: 2, c: 3 }
+    const obj4 = { b: 2, c: 3, a: 1 }
+    const obj5 = { ...obj4, z: 999 }
+    const nestedObj1 = { ...obj1, bar: [{ ...obj1 }, { ...obj1 }] }
+    const nestedObj2 = { ...obj1, bar: [{ ...obj1 }, { ...obj2 }] }
+
+    // Identical object references
+    expect(looseEqual(obj1, obj1)).toBe(true)
+    // Two objects with identical keys/values
+    expect(looseEqual(obj1, { ...obj1 })).toBe(true)
+    // Different key values
+    expect(looseEqual(obj1, obj2)).toBe(false)
+    // Keys in different orders
+    expect(looseEqual(obj3, obj4)).toBe(true)
+    // One object has additional key
+    expect(looseEqual(obj4, obj5)).toBe(false)
+    // Identical object references with nested array
+    expect(looseEqual(nestedObj1, nestedObj1)).toBe(true)
+    // Identical object definitions with nested array
+    expect(looseEqual(nestedObj1, { ...nestedObj1 })).toBe(true)
+    // Object definitions with nested array (which has different order)
+    expect(looseEqual(nestedObj1, nestedObj2)).toBe(false)
+  })
+
+  it('compares different types correctly', () => {
+    const obj1 = {}
+    const obj2 = { a: 1 }
+    const obj3 = { 0: 0, 1: 1, 2: 2 }
+    const arr1 = []
+    const arr2 = [1]
+    const arr3 = [0, 1, 2]
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const file1 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+
+    expect(looseEqual(123, '123')).toBe(true)
+    expect(looseEqual(123, new Date(123))).toBe(false)
+    expect(looseEqual(`123`, new Date(123))).toBe(false)
+    expect(looseEqual([1, 2, 3], '1,2,3')).toBe(false)
+    expect(looseEqual(obj1, arr1)).toBe(false)
+    expect(looseEqual(obj2, arr2)).toBe(false)
+    expect(looseEqual(obj1, '[object Object]')).toBe(false)
+    expect(looseEqual(arr1, '[object Array]')).toBe(false)
+    expect(looseEqual(obj1, date1)).toBe(false)
+    expect(looseEqual(obj2, date1)).toBe(false)
+    expect(looseEqual(arr1, date1)).toBe(false)
+    expect(looseEqual(arr2, date1)).toBe(false)
+    expect(looseEqual(obj2, file1)).toBe(false)
+    expect(looseEqual(arr2, file1)).toBe(false)
+    expect(looseEqual(date1, file1)).toBe(false)
+    // Special case where an object's keys are the same as keys (indexes) of an array
+    expect(looseEqual(obj3, arr3)).toBe(false)
+  })
+
+  it('compares null and undefined values correctly', () => {
+    expect(looseEqual(null, null)).toBe(true)
+    expect(looseEqual(undefined, undefined)).toBe(true)
+    // eslint-disable-next-line no-void
+    expect(looseEqual(void 0, undefined)).toBe(true)
+    expect(looseEqual(null, undefined)).toBe(false)
+    // eslint-disable-next-line no-void
+    expect(looseEqual(null, void 0)).toBe(false)
+    expect(looseEqual(null, '')).toBe(false)
+    expect(looseEqual(null, false)).toBe(false)
+    expect(looseEqual(undefined, false)).toBe(false)
+  })
+
+  it('compares sparse arrays correctly', () => {
+    // The following arrays all have a length of 3
+    // But the first two are "sparse"
+    const arr1 = []
+    arr1[2] = true
+    const arr2 = []
+    arr2[2] = true
+    const arr3 = [false, false, true]
+    const arr4 = [undefined, undefined, true]
+    // This one is also sparse (missing index 1)
+    const arr5 = []
+    arr5[0] = arr5[2] = true
+
+    expect(looseEqual(arr1, arr2)).toBe(true)
+    expect(looseEqual(arr2, arr1)).toBe(true)
+    expect(looseEqual(arr1, arr3)).toBe(false)
+    expect(looseEqual(arr3, arr1)).toBe(false)
+    expect(looseEqual(arr1, arr4)).toBe(true)
+    expect(looseEqual(arr4, arr1)).toBe(true)
+    expect(looseEqual(arr1, arr5)).toBe(false)
+    expect(looseEqual(arr5, arr1)).toBe(false)
+  })
+})

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

@@ -0,0 +1,63 @@
+import { normalizeSlot } from './normalize-slot'
+
+describe('utils/normalizeSlot', () => {
+  it('works', async () => {
+    const $scoped = {
+      default(slotScope) {
+        return 'foo' + (slotScope.a || '')
+      }
+    }
+    const $slots = {
+      default: 'bar'
+    }
+    expect(typeof normalizeSlot).toBe('function')
+
+    // Prefers scopedSlots over slots
+    let result = normalizeSlot('default', {}, $scoped, $slots)
+    expect(result).toBe('foo')
+
+    // Passes slot scope to scopedSlot
+    result = normalizeSlot('default', { a: ' foo' }, $scoped, $slots)
+    expect(result).toBe('foo foo')
+
+    // Uses named slot if scopedSlot not found
+    result = normalizeSlot('default', {}, {}, $slots)
+    expect(result).toBe('bar')
+
+    // Works if only named slot found
+    result = normalizeSlot('default', { a: ' foo' }, {}, $slots)
+    expect(result).toBe('bar')
+
+    // Works if only named slot found and scopedSlots is undef
+    result = normalizeSlot('default', { a: ' foo' }, undefined, $slots)
+    expect(result).toBe('bar')
+
+    // Works if only scoped slot found
+    result = normalizeSlot('default', { a: ' bar' }, $scoped, {})
+    expect(result).toBe('foo bar')
+
+    // Works if only scoped slot found and scoped is undef
+    result = normalizeSlot('default', { a: ' bar' }, $scoped, undefined)
+    expect(result).toBe('foo bar')
+
+    // Returns undefined if slot name not found
+    result = normalizeSlot('default', {}, {}, {})
+    expect(result).toBeUndefined()
+
+    // Returns undefined if slot name not found
+    result = normalizeSlot('baz', {}, $scoped, $slots)
+    expect(result).toBeUndefined()
+
+    // Works with array (named slot)
+    result = normalizeSlot(['none', 'default'], { a: ' foo' }, undefined, $slots)
+    expect(result).toBe('bar')
+
+    // Works with arrays (scoped slot)
+    result = normalizeSlot(['none', 'default'], { a: ' bar' }, $scoped, {})
+    expect(result).toBe('foo bar')
+
+    // Returns undefined if slot name not found with array
+    result = normalizeSlot(['baz', 'bar'], {}, $scoped, $slots)
+    expect(result).toBeUndefined()
+  })
+})

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

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

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

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