@gitlab/duo-ui 2.0.0 → 3.0.1

package/src/vendor/bootstrap-vue/src/mixins/listen-on-root.spec.js

@@ -1,77 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { listenOnRootMixin } from './listen-on-root'
-
-describe('mixins/listen-on-root', () => {
-  it('works', async () => {
-    const spyOn = jest.fn()
-    const spyOnce = jest.fn()
-
-    const TestComponent = {
-      mixins: [listenOnRootMixin],
-      created() {
-        this.listenOnRoot('root-on', spyOn)
-        this.listenOnRootOnce('root-once', spyOnce)
-      },
-      render(h) {
-        return h('div', this.$slots.default)
-      }
-    }
-
-    const App = {
-      components: { TestComponent },
-      props: {
-        destroy: {
-          type: Boolean,
-          default: false
-        }
-      },
-      render(h) {
-        return h('div', [this.destroy ? h() : h(TestComponent, 'test-component')])
-      }
-    }
-
-    const wrapper = mount(App, {
-      propsData: {
-        destroy: false
-      }
-    })
-
-    expect(wrapper.vm).toBeDefined()
-    expect(wrapper.text()).toEqual('test-component')
-
-    expect(spyOn).not.toHaveBeenCalled()
-    expect(spyOnce).not.toHaveBeenCalled()
-
-    const $root = wrapper.vm.$root
-
-    $root.$emit('root-on')
-    expect(spyOn).toHaveBeenCalledTimes(1)
-    expect(spyOnce).not.toHaveBeenCalled()
-
-    $root.$emit('root-once')
-    expect(spyOn).toHaveBeenCalledTimes(1)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    $root.$emit('root-on')
-    expect(spyOn).toHaveBeenCalledTimes(2)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    $root.$emit('root-once')
-    expect(spyOn).toHaveBeenCalledTimes(2)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    await wrapper.setProps({ destroy: true })
-    expect(spyOn).toHaveBeenCalledTimes(2)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    $root.$emit('root-on')
-    expect(spyOn).toHaveBeenCalledTimes(2)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    $root.$emit('root-once')
-    expect(spyOn).toHaveBeenCalledTimes(2)
-    expect(spyOnce).toHaveBeenCalledTimes(1)
-
-    wrapper.destroy()
-  })
-})

package/src/vendor/bootstrap-vue/src/mixins/listen-on-window.js

@@ -1,64 +0,0 @@
-import { extend } from '../vue'
-import { IS_BROWSER } from '../constants/env'
-import { EVENT_OPTIONS_NO_CAPTURE } from '../constants/events'
-import { arrayIncludes } from '../utils/array'
-import { eventOn, eventOff } from '../utils/events'
-import { keys } from '../utils/object'
-
-// --- Constants ---
-
-const PROP = '$_windowListeners'
-
-// --- Mixin ---
-
-// @vue/component
-export const listenOnWindowMixin = extend({
-  created() {
-    // Define non-reactive property
-    // Object of arrays, keyed by event name,
-    // where value is an array of callbacks
-    this[PROP] = {}
-  },
-  beforeDestroy() {
-    // Unregister all registered listeners
-    keys(this[PROP] || {}).forEach(event => {
-      this[PROP][event].forEach(callback => {
-        this.listenOffWindow(event, callback)
-      })
-    })
-
-    this[PROP] = null
-  },
-  methods: {
-    registerWindowListener(event, callback) {
-      if (this[PROP]) {
-        this[PROP][event] = this[PROP][event] || []
-        if (!arrayIncludes(this[PROP][event], callback)) {
-          this[PROP][event].push(callback)
-        }
-      }
-    },
-    unregisterWindowListener(event, callback) {
-      if (this[PROP] && this[PROP][event]) {
-        this[PROP][event] = this[PROP][event].filter(cb => cb !== callback)
-      }
-    },
-
-    listenWindow(on, event, callback) {
-      on ? this.listenOnWindow(event, callback) : this.listenOffWindow(event, callback)
-    },
-    listenOnWindow(event, callback) {
-      if (IS_BROWSER) {
-        eventOn(window, event, callback, EVENT_OPTIONS_NO_CAPTURE)
-        this.registerWindowListener(event, callback)
-      }
-    },
-    listenOffWindow(event, callback) {
-      if (IS_BROWSER) {
-        eventOff(window, event, callback, EVENT_OPTIONS_NO_CAPTURE)
-      }
-
-      this.unregisterWindowListener(event, callback)
-    }
-  }
-})

package/src/vendor/bootstrap-vue/src/mixins/listen-on-window.spec.js

@@ -1,115 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { listenOnWindowMixin } from './listen-on-window'
-
-describe('mixins/listen-on-window', () => {
-  it('works', async () => {
-    const spyResize1 = jest.fn()
-    const spyResize2 = jest.fn()
-    const spyScroll = jest.fn()
-
-    const TestComponent = {
-      mixins: [listenOnWindowMixin],
-      props: {
-        offResizeOne: {
-          type: Boolean,
-          default: false
-        }
-      },
-      mounted() {
-        this.listenOnWindow('resize', spyResize1)
-        this.listenOnWindow('scroll', spyScroll)
-        this.listenOnWindow('resize', spyResize2)
-      },
-      watch: {
-        offResizeOne(newValue) {
-          if (newValue) {
-            this.listenOffWindow('resize', spyResize1)
-          }
-        }
-      },
-      render(h) {
-        return h('div', this.$slots.default)
-      }
-    }
-
-    const App = {
-      components: { TestComponent },
-      props: {
-        offResizeOne: {
-          type: Boolean,
-          default: false
-        },
-        destroy: {
-          type: Boolean,
-          default: false
-        }
-      },
-      render(h) {
-        const props = {
-          offResizeOne: this.offResizeOne
-        }
-        return h('div', [this.destroy ? h() : h(TestComponent, { props }, 'test-component')])
-      }
-    }
-
-    const wrapper = mount(App, {
-      attachTo: document.body,
-      propsData: {
-        destroy: false
-      }
-    })
-
-    expect(wrapper.vm).toBeDefined()
-    expect(wrapper.text()).toEqual('test-component')
-
-    expect(spyResize1).not.toHaveBeenCalled()
-    expect(spyResize2).not.toHaveBeenCalled()
-    expect(spyScroll).not.toHaveBeenCalled()
-
-    window.dispatchEvent(new Event('scroll'))
-
-    expect(spyResize1).not.toHaveBeenCalled()
-    expect(spyResize2).not.toHaveBeenCalled()
-    expect(spyScroll).toHaveBeenCalledTimes(1)
-
-    window.dispatchEvent(new Event('resize'))
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(1)
-    expect(spyScroll).toHaveBeenCalledTimes(1)
-
-    await wrapper.setProps({ offResizeOne: true })
-
-    window.dispatchEvent(new Event('resize'))
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(2)
-    expect(spyScroll).toHaveBeenCalledTimes(1)
-
-    window.dispatchEvent(new Event('scroll'))
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(2)
-    expect(spyScroll).toHaveBeenCalledTimes(2)
-
-    await wrapper.setProps({ destroy: true })
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(2)
-    expect(spyScroll).toHaveBeenCalledTimes(2)
-
-    window.dispatchEvent(new Event('scroll'))
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(2)
-    expect(spyScroll).toHaveBeenCalledTimes(2)
-
-    window.dispatchEvent(new Event('resize'))
-
-    expect(spyResize1).toHaveBeenCalledTimes(1)
-    expect(spyResize2).toHaveBeenCalledTimes(2)
-    expect(spyScroll).toHaveBeenCalledTimes(2)
-
-    wrapper.destroy()
-  })
-})

package/src/vendor/bootstrap-vue/src/mixins/listeners.js

@@ -1,24 +0,0 @@
-import { makePropCacheMixin } from '../utils/cache'
-import { extend, isVue3 } from '../vue'
-
-const listenersMixinVue2 = makePropCacheMixin('$listeners', 'bvListeners')
-
-const listenersMixinVue3 = extend({
-  data() {
-    return {
-      bvListeners: {}
-    }
-  },
-  created() {
-    this.bvListeners = {
-      ...this.$listeners
-    }
-  },
-  beforeUpdate() {
-    this.bvListeners = {
-      ...this.$listeners
-    }
-  }
-})
-
-export const listenersMixin = isVue3 ? listenersMixinVue3 : listenersMixinVue2

package/src/vendor/bootstrap-vue/src/mixins/listeners.spec.js

@@ -1,245 +0,0 @@
-import { isVue3 } from '../vue'
-import { mount } from '@vue/test-utils'
-import { listenersMixin } from './listeners'
-
-// Note: The following tests indirectly test `utils/cache`
-
-describe('mixins > listeners', () => {
-  it('works', async () => {
-    const BTest = {
-      compatConfig: {
-        MODE: 3,
-        RENDER_FUNCTION: 'suppress-warning',
-        INSTANCE_LISTENERS: 'suppress-warning'
-      },
-      name: 'BTest',
-      mixins: [listenersMixin],
-      inheritAttrs: false,
-      render(h) {
-        return h('button', { on: this.bvListeners })
-      }
-    }
-    const App = {
-      compatConfig: { MODE: 3, RENDER_FUNCTION: 'suppress-warning' },
-      name: 'App',
-      props: ['listenClick', 'listenFocus', 'listenBlur'],
-      computed: {
-        listeners() {
-          const listeners = {}
-          if (this.listenClick) {
-            listeners.click = event => this.$emit('click', event)
-          }
-          if (this.listenFocus) {
-            listeners.focus = event => this.$emit('focus', event)
-          }
-          if (this.listenBlur) {
-            listeners.blur = event => this.$emit('blur', event)
-          }
-          return listeners
-        }
-      },
-      render(h) {
-        return h(BTest, { on: this.listeners })
-      }
-    }
-
-    const wrapper = mount(App)
-
-    expect(wrapper).toBeDefined()
-    expect(wrapper.vm).toBeDefined()
-    expect(wrapper.element.tagName).toBe('BUTTON')
-
-    const $test = wrapper.findComponent(BTest)
-
-    expect($test.exists()).toBe(true)
-    expect($test.vm).toBeDefined()
-
-    expect($test.vm.bvListeners).toBeDefined()
-    expect($test.vm.bvListeners.click).toBeUndefined()
-    expect($test.vm.bvListeners.focus).toBeUndefined()
-    expect($test.vm.bvListeners.blur).toBeUndefined()
-
-    // Correctly adds new listeners
-    await wrapper.setProps({
-      listenClick: true,
-      listenFocus: true
-    })
-
-    expect($test.vm.bvListeners.click).toBeDefined()
-    expect($test.vm.bvListeners.focus).toBeDefined()
-    expect($test.vm.bvListeners.blur).toBeUndefined()
-
-    // Correctly updates listeners
-    await wrapper.setProps({
-      listenClick: false,
-      listenBlur: true
-    })
-
-    expect($test.vm.bvListeners.click).toBeUndefined()
-    expect($test.vm.bvListeners.focus).toBeDefined()
-    expect($test.vm.bvListeners.blur).toBeDefined()
-
-    // Correctly removes listeners
-    await wrapper.setProps({
-      listenClick: false,
-      listenFocus: false,
-      listenBlur: false
-    })
-
-    expect($test.vm.bvListeners.click).toBeUndefined()
-    expect($test.vm.bvListeners.focus).toBeUndefined()
-    expect($test.vm.bvListeners.blur).toBeUndefined()
-
-    wrapper.destroy()
-  })
-
-  it('does not re-render parent child components', async () => {
-    let input1RenderCount = 0
-    let input2RenderCount = 0
-
-    const Input1 = {
-      compatConfig: {
-        MODE: 3,
-        RENDER_FUNCTION: 'suppress-warning',
-        INSTANCE_LISTENERS: 'suppress-warning'
-      },
-      props: ['value'],
-      render(h) {
-        input1RenderCount++
-        return h('input', {
-          attrs: { value: this.value },
-          domProps: { value: this.value },
-          on: { ...this.$listeners, input: e => this.$emit('input', e.target.value) }
-        })
-      }
-    }
-    const Input2 = {
-      compatConfig: {
-        MODE: 3,
-        RENDER_FUNCTION: 'suppress-warning',
-        INSTANCE_LISTENERS: 'suppress-warning'
-      },
-      props: ['value'],
-      mixins: [listenersMixin],
-      render(h) {
-        input2RenderCount++
-        return h('input', {
-          attrs: { value: this.value },
-          domProps: { value: this.value },
-          on: { ...this.bvListeners, input: e => this.$emit('input', e.target.value) }
-        })
-      }
-    }
-
-    const App1 = {
-      components: { Input1 },
-      props: ['listenFocus1', 'listenFocus2'],
-      methods: {
-        emit1($event) {
-          if (this.listenFocus1) {
-            this.$emit('focus1', $event)
-          }
-        },
-        emit2($event) {
-          if (this.listenFocus2) {
-            this.$emit('focus2', $event)
-          }
-        }
-      },
-      template: `<div>
-        <Input1 @focus="emit1" />
-        <Input1 @focus="emit2" />
-      </div>`
-    }
-    const App2 = {
-      components: { Input2 },
-      props: ['listenFocus1', 'listenFocus2'],
-      methods: {
-        emit1($event) {
-          if (this.listenFocus1) {
-            this.$emit('focus1', $event)
-          }
-        },
-        emit2($event) {
-          if (this.listenFocus2) {
-            this.$emit('focus2', $event)
-          }
-        }
-      },
-      template: `<div>
-        <Input2 @focus="emit1" />
-        <Input2 @focus="emit2" />
-      </div>`
-    }
-
-    const wrapper1 = mount(App1, { attachTo: document.body })
-    const wrapper2 = mount(App2, { attachTo: document.body })
-
-    // --- `Input1` tests ---
-
-    const $inputs1 = wrapper1.findAllComponents(Input1)
-    expect($inputs1.length).toBe(2)
-    expect($inputs1.at(0)).toBeDefined()
-    expect($inputs1.at(1)).toBeDefined()
-    expect(wrapper1.emitted().focus1).not.toBeTruthy()
-    expect(wrapper1.emitted().focus2).not.toBeTruthy()
-    expect(input1RenderCount).toBe(2)
-
-    await $inputs1.at(0).trigger('focus')
-    expect(wrapper1.emitted().focus1).not.toBeTruthy()
-    await $inputs1.at(1).trigger('focus')
-    expect(wrapper1.emitted().focus2).not.toBeTruthy()
-    expect(input1RenderCount).toBe(2)
-
-    // Enable focus events for the first input and trigger it
-    await wrapper1.setProps({ listenFocus1: true })
-    await $inputs1.at(0).trigger('focus')
-    expect(wrapper1.emitted().focus1).toBeTruthy()
-    expect(wrapper1.emitted().focus2).not.toBeTruthy()
-    // Both `Input1`'s are re-rendered (See: https://github.com/vuejs/vue/issues/7257)
-    expect(input1RenderCount).toBe(isVue3 ? 2 : 4)
-
-    // Enable focus events for the second input and trigger it
-    await wrapper1.setProps({ listenFocus2: true })
-    await $inputs1.at(1).trigger('focus')
-    expect(wrapper1.emitted().focus1).toBeTruthy()
-    expect(wrapper1.emitted().focus2).toBeTruthy()
-    // Both `Input1`'s are re-rendered (See: https://github.com/vuejs/vue/issues/7257)
-    expect(input1RenderCount).toBe(isVue3 ? 2 : 6)
-
-    // --- `Input2` tests ---
-
-    const $inputs2 = wrapper2.findAllComponents(Input2)
-    expect($inputs2.length).toBe(2)
-    expect($inputs2.at(0)).toBeDefined()
-    expect($inputs2.at(1)).toBeDefined()
-    expect(wrapper2.emitted().focus1).not.toBeTruthy()
-    expect(wrapper2.emitted().focus2).not.toBeTruthy()
-    expect(input2RenderCount).toBe(2)
-
-    await $inputs2.at(0).trigger('focus')
-    expect(wrapper2.emitted().focus1).not.toBeTruthy()
-    await $inputs2.at(1).trigger('focus')
-    expect(wrapper2.emitted().focus2).not.toBeTruthy()
-    expect(input2RenderCount).toBe(2)
-
-    // Enable focus events for the first input and trigger it
-    await wrapper2.setProps({ listenFocus1: true })
-    await $inputs2.at(0).trigger('focus')
-    expect(wrapper2.emitted().focus1).toBeTruthy()
-    expect(wrapper2.emitted().focus2).not.toBeTruthy()
-    // With `listenersMixin` only the affected `Input2` is re-rendered
-    expect(input2RenderCount).toBe(2)
-
-    // Enable focus events for the second input and trigger it
-    await wrapper2.setProps({ listenFocus2: true })
-    await $inputs2.at(1).trigger('focus')
-    expect(wrapper2.emitted().focus1).toBeTruthy()
-    expect(wrapper2.emitted().focus2).toBeTruthy()
-    // With `listenersMixin` only the affected `Input2` is re-rendered
-    expect(input2RenderCount).toBe(2)
-
-    wrapper1.destroy()
-    wrapper2.destroy()
-  })
-})

package/src/vendor/bootstrap-vue/src/mixins/model.js

@@ -1,5 +0,0 @@
-import { makeModelMixin } from '../utils/model'
-
-const { mixin, props, prop, event } = makeModelMixin('value')
-
-export { mixin as modelMixin, props, prop as MODEL_PROP_NAME, event as MODEL_EVENT_NAME }

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

@@ -1,30 +0,0 @@
-import { extend } from '../vue'
-import { SLOT_NAME_DEFAULT } from '../constants/slots'
-import { hasNormalizedSlot, normalizeSlot } from '../utils/normalize-slot'
-import { concat } from '../utils/array'
-
-// @vue/component
-export const normalizeSlotMixin = extend({
-  methods: {
-    // Returns `true` if the either a `$scopedSlot` or `$slot` exists with the specified name
-    // `name` can be a string name or an array of names
-    hasNormalizedSlot(
-      name = SLOT_NAME_DEFAULT,
-      scopedSlots = this.$scopedSlots,
-      slots = this.$slots
-    ) {
-      return hasNormalizedSlot(name, scopedSlots, slots)
-    },
-    // Returns an array of rendered VNodes if slot found, otherwise `undefined`
-    // `name` can be a string name or an array of names
-    normalizeSlot(
-      name = SLOT_NAME_DEFAULT,
-      scope = {},
-      scopedSlots = this.$scopedSlots,
-      slots = this.$slots
-    ) {
-      const vNodes = normalizeSlot(name, scope, scopedSlots, slots)
-      return vNodes ? concat(vNodes) : vNodes
-    }
-  }
-})

package/src/vendor/bootstrap-vue/src/mixins/scoped-style.js

@@ -1,14 +0,0 @@
-import { extend } from '../vue'
-import { useParentMixin } from '../mixins/use-parent'
-import { getScopeId } from '../utils/get-scope-id'
-
-// @vue/component
-export const scopedStyleMixin = extend({
-  mixins: [useParentMixin],
-  computed: {
-    scopedStyleAttrs() {
-      const scopeId = getScopeId(this.bvParent)
-      return scopeId ? { [scopeId]: '' } : {}
-    }
-  }
-})

package/src/vendor/bootstrap-vue/src/mixins/use-parent.js

@@ -1,12 +0,0 @@
-import { extend } from '../vue'
-
-// --- Mixin ---
-
-// @vue/component
-export const useParentMixin = extend({
-  computed: {
-    bvParent() {
-      return this.$parent || (this.$root === this && this.$options.bvParent)
-    }
-  }
-})

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

@@ -1,17 +0,0 @@
-import { isFunction } from './inspect'
-
-// --- Static ---
-
-export const from = (...args) => Array.from(...args)
-
-// --- Instance ---
-
-export const arrayIncludes = (array, value) => array.indexOf(value) !== -1
-export const concat = (...args) => Array.prototype.concat.apply([], args)
-
-// --- Utilities ---
-
-export const createArray = (length, fillFn) => {
-  const mapFn = isFunction(fillFn) ? fillFn : () => fillFn
-  return Array.apply(null, { length }).map(mapFn)
-}

package/src/vendor/bootstrap-vue/src/utils/bv-event.class.js

@@ -1,60 +0,0 @@
-import { assign, defineProperty, defineProperties, readonlyDescriptor } from './object'
-
-export class BvEvent {
-  constructor(type, eventInit = {}) {
-    // Start by emulating native Event constructor
-    if (!type) {
-      /* istanbul ignore next */
-      throw new TypeError(
-        `Failed to construct '${this.constructor.name}'. 1 argument required, ${
-          arguments.length
-        } given.`
-      )
-    }
-
-    // Merge defaults first, the eventInit, and the type last
-    // so it can't be overwritten
-    assign(this, BvEvent.Defaults, this.constructor.Defaults, eventInit, { type })
-
-    // Freeze some props as readonly, but leave them enumerable
-    defineProperties(this, {
-      type: readonlyDescriptor(),
-      cancelable: readonlyDescriptor(),
-      nativeEvent: readonlyDescriptor(),
-      target: readonlyDescriptor(),
-      relatedTarget: readonlyDescriptor(),
-      vueTarget: readonlyDescriptor(),
-      componentId: readonlyDescriptor()
-    })
-
-    // Create a private variable using closure scoping
-    let defaultPrevented = false
-    // Recreate preventDefault method. One way setter
-    this.preventDefault = function preventDefault() {
-      if (this.cancelable) {
-        defaultPrevented = true
-      }
-    }
-
-    // Create `defaultPrevented` publicly accessible prop that
-    // can only be altered by the preventDefault method
-    defineProperty(this, 'defaultPrevented', {
-      enumerable: true,
-      get() {
-        return defaultPrevented
-      }
-    })
-  }
-
-  static get Defaults() {
-    return {
-      type: '',
-      cancelable: true,
-      nativeEvent: null,
-      target: null,
-      relatedTarget: null,
-      vueTarget: null,
-      componentId: null
-    }
-  }
-}