@gitlab/ui 84.2.0 → 85.0.1

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')
+  })
+})

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

@@ -0,0 +1,145 @@
+import { RX_ENCODED_COMMA, RX_ENCODE_REVERSE, RX_PLUS, RX_QUERY_START } from '../constants/regex'
+import { isTag } from './dom'
+import { isArray, isNull, isPlainObject, isString, isUndefined } from './inspect'
+import { keys } from './object'
+import { safeVueInstance } from './safe-vue-instance'
+import { toString } from './string'
+
+const ANCHOR_TAG = 'a'
+
+// Method to replace reserved chars
+const encodeReserveReplacer = c => '%' + c.charCodeAt(0).toString(16)
+
+// Fixed encodeURIComponent which is more conformant to RFC3986:
+// - escapes [!'()*]
+// - preserve commas
+const encode = str =>
+  encodeURIComponent(toString(str))
+    .replace(RX_ENCODE_REVERSE, encodeReserveReplacer)
+    .replace(RX_ENCODED_COMMA, ',')
+
+const decode = decodeURIComponent
+
+// Stringifies an object of query parameters
+// See: https://github.com/vuejs/vue-router/blob/dev/src/util/query.js
+export const stringifyQueryObj = obj => {
+  if (!isPlainObject(obj)) {
+    return ''
+  }
+
+  const query = keys(obj)
+    .map(key => {
+      const value = obj[key]
+      if (isUndefined(value)) {
+        return ''
+      } else if (isNull(value)) {
+        return encode(key)
+      } else if (isArray(value)) {
+        return value
+          .reduce((results, value2) => {
+            if (isNull(value2)) {
+              results.push(encode(key))
+            } else if (!isUndefined(value2)) {
+              // Faster than string interpolation
+              results.push(encode(key) + '=' + encode(value2))
+            }
+            return results
+          }, [])
+          .join('&')
+      }
+      // Faster than string interpolation
+      return encode(key) + '=' + encode(value)
+    })
+    /* must check for length, as we only want to filter empty strings, not things that look falsey! */
+    .filter(x => x.length > 0)
+    .join('&')
+
+  return query ? `?${query}` : ''
+}
+
+export const parseQuery = query => {
+  const parsed = {}
+  query = toString(query)
+    .trim()
+    .replace(RX_QUERY_START, '')
+
+  if (!query) {
+    return parsed
+  }
+
+  query.split('&').forEach(param => {
+    const parts = param.replace(RX_PLUS, ' ').split('=')
+    const key = decode(parts.shift())
+    const value = parts.length > 0 ? decode(parts.join('=')) : null
+
+    if (isUndefined(parsed[key])) {
+      parsed[key] = value
+    } else if (isArray(parsed[key])) {
+      parsed[key].push(value)
+    } else {
+      parsed[key] = [parsed[key], value]
+    }
+  })
+
+  return parsed
+}
+
+export const isLink = props => !!(props.href || props.to)
+
+export const isRouterLink = tag => !!(tag && !isTag(tag, 'a'))
+
+export const computeTag = ({ to, disabled, routerComponentName }, thisOrParent) => {
+  const hasRouter = !!safeVueInstance(thisOrParent).$router
+  const hasNuxt = !!safeVueInstance(thisOrParent).$nuxt
+  if (!hasRouter || (hasRouter && (disabled || !to))) {
+    return ANCHOR_TAG
+  }
+
+  // TODO:
+  //   Check registered components for existence of user supplied router link component name
+  //   We would need to check PascalCase, kebab-case, and camelCase versions of name:
+  //   const name = routerComponentName
+  //   const names = [name, PascalCase(name), KebabCase(name), CamelCase(name)]
+  //   exists = names.some(name => !!thisOrParent.$options.components[name])
+  //   And may want to cache the result for performance or we just let the render fail
+  //   if the component is not registered
+  return routerComponentName || (hasNuxt ? 'nuxt-link' : 'router-link')
+}
+
+export const computeRel = ({ target, rel } = {}) =>
+  target === '_blank' && isNull(rel) ? 'noopener' : rel || null
+
+export const computeHref = (
+  { href, to } = {},
+  tag = ANCHOR_TAG,
+  fallback = '#',
+  toFallback = '/'
+) => {
+  // Return `href` when explicitly provided
+  if (href) {
+    return href
+  }
+
+  // We've checked for `$router` in `computeTag()`, so `isRouterLink()` indicates a live router
+  // When deferring to Vue Router's `<router-link>`, don't use the `href` attribute at all
+  // We return `null`, and then remove `href` from the attributes passed to `<router-link>`
+  if (isRouterLink(tag)) {
+    return null
+  }
+
+  // Fallback to `to` prop (if `to` is a string)
+  if (isString(to)) {
+    return to || toFallback
+  }
+  // Fallback to `to.path' + `to.query` + `to.hash` prop (if `to` is an object)
+  if (isPlainObject(to) && (to.path || to.query || to.hash)) {
+    const path = toString(to.path)
+    const query = stringifyQueryObj(to.query)
+    let hash = toString(to.hash)
+    hash = !hash || hash.charAt(0) === '#' ? hash : `#${hash}`
+    return `${path}${query}${hash}` || toFallback
+  }
+
+  // If nothing is provided return the fallback
+  return fallback
+}

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/safe-vue-instance.js

@@ -0,0 +1,13 @@
+import { isVue3 } from '../vue'
+
+export function safeVueInstance(target) {
+  if (!isVue3) {
+    return target
+  }
+
+  return new Proxy(target, {
+    get(target, prop) {
+      return prop in target ? target[prop] : undefined
+    }
+  })
+}

package/src/vendor/bootstrap-vue/src/utils/stable-sort.js

@@ -0,0 +1,31 @@
+/*
+ * Consistent and stable sort function across JavaScript platforms
+ *
+ * Inconsistent sorts can cause SSR problems between client and server
+ * such as in <b-table> if sortBy is applied to the data on server side render.
+ * Chrome and V8 native sorts are inconsistent/unstable
+ *
+ * This function uses native sort with fallback to index compare when the a and b
+ * compare returns 0
+ *
+ * Algorithm based on:
+ * https://stackoverflow.com/questions/1427608/fast-stable-sorting-algorithm-implementation-in-javascript/45422645#45422645
+ *
+ * @param {array} array to sort
+ * @param {function} sort compare function
+ * @return {array}
+ */
+export const stableSort = (array, compareFn) => {
+  // Using `.bind(compareFn)` on the wrapped anonymous function improves
+  // performance by avoiding the function call setup. We don't use an arrow
+  // function here as it binds `this` to the `stableSort` context rather than
+  // the `compareFn` context, which wouldn't give us the performance increase.
+  return array
+    .map((a, index) => [index, a])
+    .sort(
+      function(a, b) {
+        return this(a[1], b[1]) || a[0] - b[0]
+      }.bind(compareFn)
+    )
+    .map(e => e[1])
+}

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

@@ -0,0 +1,75 @@
+// String utilities
+import {
+  RX_HYPHENATE,
+  RX_LOWER_UPPER,
+  RX_REGEXP_REPLACE,
+  RX_START_SPACE_WORD,
+  RX_TRIM_LEFT,
+  RX_TRIM_RIGHT,
+  RX_UNDERSCORE,
+  RX_UN_KEBAB
+} from '../constants/regex'
+import { isArray, isPlainObject, isString, isUndefinedOrNull } from './inspect'
+
+// --- Utilities ---
+
+// Converts PascalCase or camelCase to kebab-case
+export const kebabCase = str => {
+  return str.replace(RX_HYPHENATE, '-$1').toLowerCase()
+}
+
+// Converts a kebab-case or camelCase string to PascalCase
+export const pascalCase = str => {
+  str = kebabCase(str).replace(RX_UN_KEBAB, (_, c) => (c ? c.toUpperCase() : ''))
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+// Converts a string, including strings in camelCase or snake_case, into Start Case
+// It keeps original single quote and hyphen in the word
+// https://github.com/UrbanCompass/to-start-case
+export const startCase = str =>
+  str
+    .replace(RX_UNDERSCORE, ' ')
+    .replace(RX_LOWER_UPPER, (str, $1, $2) => $1 + ' ' + $2)
+    .replace(RX_START_SPACE_WORD, (str, $1, $2) => $1 + $2.toUpperCase())
+
+// Lowercases the first letter of a string and returns a new string
+export const lowerFirst = str => {
+  str = isString(str) ? str.trim() : String(str)
+  return str.charAt(0).toLowerCase() + str.slice(1)
+}
+
+// Uppercases the first letter of a string and returns a new string
+export const upperFirst = str => {
+  str = isString(str) ? str.trim() : String(str)
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+// Escape characters to be used in building a regular expression
+export const escapeRegExp = str => str.replace(RX_REGEXP_REPLACE, '\\$&')
+
+// Convert a value to a string that can be rendered
+// `undefined`/`null` will be converted to `''`
+// Plain objects and arrays will be JSON stringified
+export const toString = (val, spaces = 2) => {
+  return isUndefinedOrNull(val)
+    ? ''
+    : isArray(val) || (isPlainObject(val) && val.toString === Object.prototype.toString)
+      ? JSON.stringify(val, null, spaces)
+      : String(val)
+}
+
+// Remove leading white space from a string
+export const trimLeft = str => toString(str).replace(RX_TRIM_LEFT, '')
+
+// Remove Trailing white space from a string
+export const trimRight = str => toString(str).replace(RX_TRIM_RIGHT, '')
+
+// Remove leading and trailing white space from a string
+export const trim = str => toString(str).trim()
+
+// Lower case a string
+export const lowerCase = str => toString(str).toLowerCase()
+
+// Upper case a string
+export const upperCase = str => toString(str).toUpperCase()