@gitlab/duo-ui 0.1.0 → 0.2.0

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

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

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

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

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

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

package/translations.js

@@ -1,7 +1,5 @@
 /* eslint-disable import/no-default-export */
 export default {
-  'ClearIconButton.title': 'Clear',
-  'CloseButton.title': 'Close',
   'DuoChatContextItemPopover.DisabledReason': 'This item is disabled',
   'DuoChatContextItemTypeLabel.File': 'Project file',
   'DuoChatContextItemTypeLabel.GitCommit': 'Local Git repository commit',
@@ -9,13 +7,6 @@ export default {
   'DuoChatContextItemTypeLabel.GitDiff': 'Local Git repository diff',
   'DuoChatContextItemTypeLabel.Issue': 'Issue',
   'DuoChatContextItemTypeLabel.MergeRequest': 'Merge request',
-  'GlAlert.closeButtonTitle': 'Dismiss',
-  'GlBanner.closeButtonTitle': 'Dismiss',
-  'GlBreadcrumb.showMoreLabel': 'Show more breadcrumbs',
-  'GlBroadcastMessage.closeButtonTitle': 'Dismiss',
-  'GlCollapsibleListbox.srOnlyResultsLabel': null,
-  'GlDatepicker.monthLabel': 'Month',
-  'GlDatepicker.yearLabel': 'Year',
   'GlDuoChat.chatCancelLabel': 'Cancel',
   'GlDuoChat.chatCloseLabel': 'Close the Code Explanation',
   'GlDuoChat.chatDefaultPredefinedPromptsChangePassword': 'How do I change my password in GitLab?',
@@ -65,21 +56,4 @@ export default {
   'GlDuoWorkflowPrompt.promptLabel': 'Description',
   'GlDuoWorkflowPrompt.promptLabelDescription': 'What would you like to do and how.',
   'GlDuoWorkflowPrompt.title': 'Goal',
-  'GlKeysetPagination.navigationLabel': 'Pagination',
-  'GlKeysetPagination.nextText': 'Next',
-  'GlKeysetPagination.prevText': 'Previous',
-  'GlModal.closeButtonTitle': 'Close',
-  'GlPagination.labelFirstPage': 'Go to first page',
-  'GlPagination.labelLastPage': 'Go to last page',
-  'GlPagination.labelNextPage': 'Go to next page',
-  'GlPagination.labelPage': 'Go to page %{page}',
-  'GlPagination.labelPrevPage': 'Go to previous page',
-  'GlPagination.nav': 'Pagination',
-  'GlPagination.nextText': 'Next',
-  'GlPagination.prevText': 'Previous',
-  'GlSearchBoxByType.clearButtonTitle': 'Clear',
-  'GlSearchBoxByType.input.placeholder': 'Search',
-  'GlSorting.sortAscending': 'Sort direction: ascending',
-  'GlSorting.sortDescending': 'Sort direction: descending',
-  'GlToken.closeButtonTitle': 'Remove',
 };