@gitlab/duo-ui 3.0.0 → 4.0.0

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

@@ -1,57 +0,0 @@
-import { hasOwnProperty, keys } from './object'
-import { isArray, isDate, isObject } from './inspect'
-
-// Assumes both a and b are arrays!
-// Handles when arrays are "sparse" (array.every(...) doesn't handle sparse)
-const compareArrays = (a, b) => {
-  if (a.length !== b.length) {
-    return false
-  }
-  let equal = true
-  for (let i = 0; equal && i < a.length; i++) {
-    equal = looseEqual(a[i], b[i])
-  }
-  return equal
-}
-
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- * Returns boolean true or false
- */
-export const looseEqual = (a, b) => {
-  if (a === b) {
-    return true
-  }
-  let aValidType = isDate(a)
-  let bValidType = isDate(b)
-  if (aValidType || bValidType) {
-    return aValidType && bValidType ? a.getTime() === b.getTime() : false
-  }
-  aValidType = isArray(a)
-  bValidType = isArray(b)
-  if (aValidType || bValidType) {
-    return aValidType && bValidType ? compareArrays(a, b) : false
-  }
-  aValidType = isObject(a)
-  bValidType = isObject(b)
-  if (aValidType || bValidType) {
-    /* istanbul ignore if: this if will probably never be called */
-    if (!aValidType || !bValidType) {
-      return false
-    }
-    const aKeysCount = keys(a).length
-    const bKeysCount = keys(b).length
-    if (aKeysCount !== bKeysCount) {
-      return false
-    }
-    for (const key in a) {
-      const aHasKey = hasOwnProperty(a, key)
-      const bHasKey = hasOwnProperty(b, key)
-      if ((aHasKey && !bHasKey) || (!aHasKey && bHasKey) || !looseEqual(a[key], b[key])) {
-        return false
-      }
-    }
-  }
-  return String(a) === String(b)
-}

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

@@ -1,203 +0,0 @@
-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/loose-index-of.js

@@ -1,11 +0,0 @@
-import { looseEqual } from './loose-equal'
-
-// Assumes that the first argument is an array
-export const looseIndexOf = (array, value) => {
-  for (let i = 0; i < array.length; i++) {
-    if (looseEqual(array[i], value)) {
-      return i
-    }
-  }
-  return -1
-}

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

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

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

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

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

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

@@ -1,44 +0,0 @@
-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/normalize-slot.spec.js

@@ -1,63 +0,0 @@
-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.js

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

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