@gitlab/duo-ui 3.0.0 → 4.0.0

package/src/vendor/bootstrap-vue/src/components/table/helpers/mixin-thead.js

@@ -1,238 +0,0 @@
-import { extend } from '../../../vue'
-import { EVENT_NAME_HEAD_CLICKED } from '../../../constants/events'
-import { CODE_ENTER, CODE_SPACE } from '../../../constants/key-codes'
-import { PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_STRING } from '../../../constants/props'
-import { SLOT_NAME_THEAD_TOP } from '../../../constants/slots'
-import { stopEvent } from '../../../utils/events'
-import { htmlOrText } from '../../../utils/html'
-import { identity } from '../../../utils/identity'
-import { isUndefinedOrNull } from '../../../utils/inspect'
-import { noop } from '../../../utils/noop'
-import { makeProp } from '../../../utils/props'
-import { safeVueInstance } from '../../../utils/safe-vue-instance'
-import { startCase } from '../../../utils/string'
-import { BThead } from '../thead'
-import { BTfoot } from '../tfoot'
-import { BTr } from '../tr'
-import { BTh } from '../th'
-import { filterEvent } from './filter-event'
-import { textSelectionActive } from './text-selection-active'
-
-// --- Helper methods ---
-
-const getHeadSlotName = value => `head(${value || ''})`
-
-const getFootSlotName = value => `foot(${value || ''})`
-
-// --- Props ---
-
-export const props = {
-  // Any Bootstrap theme variant (or custom)
-  headRowVariant: makeProp(PROP_TYPE_STRING),
-  // 'light', 'dark' or `null` (or custom)
-  headVariant: makeProp(PROP_TYPE_STRING),
-  theadClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
-  theadTrClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING)
-}
-
-// --- Mixin ---
-
-// @vue/component
-export const theadMixin = extend({
-  props,
-  methods: {
-    fieldClasses(field) {
-      // Header field (<th>) classes
-      return [field.class ? field.class : '', field.thClass ? field.thClass : '']
-    },
-    headClicked(event, field, isFoot) {
-      if (this.stopIfBusy && this.stopIfBusy(event)) {
-        // If table is busy (via provider) then don't propagate
-        return
-      } else if (filterEvent(event)) {
-        // Clicked on a non-disabled control so ignore
-        return
-      } else if (textSelectionActive(this.$el)) {
-        // User is selecting text, so ignore
-        /* istanbul ignore next: JSDOM doesn't support getSelection() */
-        return
-      }
-      stopEvent(event)
-      this.$emit(EVENT_NAME_HEAD_CLICKED, field.key, field, event, isFoot)
-    },
-    renderThead(isFoot = false) {
-      const {
-        computedFields: fields,
-        isSortable,
-        isSelectable,
-        headVariant,
-        footVariant,
-        headRowVariant,
-        footRowVariant
-      } = safeVueInstance(this)
-      const h = this.$createElement
-
-      // In always stacked mode, we don't bother rendering the head/foot
-      // Or if no field headings (empty table)
-      if (this.isStackedAlways || fields.length === 0) {
-        return h()
-      }
-
-      const hasHeadClickListener = isSortable || this.hasListener(EVENT_NAME_HEAD_CLICKED)
-
-      // Reference to `selectAllRows` and `clearSelected()`, if table is selectable
-      const selectAllRows = isSelectable ? this.selectAllRows : noop
-      const clearSelected = isSelectable ? this.clearSelected : noop
-
-      // Helper function to generate a field <th> cell
-      const makeCell = (field, colIndex) => {
-        const { label, labelHtml, variant, stickyColumn, key } = field
-
-        let ariaLabel = null
-        if (!field.label.trim() && !field.headerTitle) {
-          // In case field's label and title are empty/blank
-          // We need to add a hint about what the column is about for non-sighted users
-          /* istanbul ignore next */
-          ariaLabel = startCase(field.key)
-        }
-
-        const on = {}
-        if (hasHeadClickListener) {
-          on.click = event => {
-            this.headClicked(event, field, isFoot)
-          }
-          on.keydown = event => {
-            const keyCode = event.keyCode
-            if (keyCode === CODE_ENTER || keyCode === CODE_SPACE) {
-              this.headClicked(event, field, isFoot)
-            }
-          }
-        }
-
-        const sortAttrs = isSortable ? this.sortTheadThAttrs(key, field, isFoot) : {}
-        const sortClass = isSortable ? this.sortTheadThClasses(key, field, isFoot) : null
-        const sortLabel = isSortable ? this.sortTheadThLabel(key, field, isFoot) : null
-
-        const data = {
-          class: [
-            {
-              // We need to make the header cell relative when we have
-              // a `.sr-only` sort label to work around overflow issues
-              'position-relative': sortLabel
-            },
-            this.fieldClasses(field),
-            sortClass
-          ],
-          props: { variant, stickyColumn },
-          style: field.thStyle || {},
-          attrs: {
-            // We only add a `tabindex` of `0` if there is a head-clicked listener
-            // and the current field is sortable
-            tabindex: hasHeadClickListener && field.sortable ? '0' : null,
-            abbr: field.headerAbbr || null,
-            title: field.headerTitle || null,
-            'aria-colindex': colIndex + 1,
-            'aria-label': ariaLabel,
-            ...this.getThValues(null, key, field.thAttr, isFoot ? 'foot' : 'head', {}),
-            ...sortAttrs
-          },
-          on,
-          key
-        }
-
-        // Handle edge case where in-document templates are used with new
-        // `v-slot:name` syntax where the browser lower-cases the v-slot's
-        // name (attributes become lower cased when parsed by the browser)
-        // We have replaced the square bracket syntax with round brackets
-        // to prevent confusion with dynamic slot names
-        let slotNames = [
-          getHeadSlotName(key),
-          getHeadSlotName(key.toLowerCase()),
-          getHeadSlotName()
-        ]
-        // Footer will fallback to header slot names
-        if (isFoot) {
-          slotNames = [
-            getFootSlotName(key),
-            getFootSlotName(key.toLowerCase()),
-            getFootSlotName(),
-            ...slotNames
-          ]
-        }
-
-        const scope = {
-          label,
-          column: key,
-          field,
-          isFoot,
-          // Add in row select methods
-          selectAllRows,
-          clearSelected
-        }
-
-        const $content =
-          this.normalizeSlot(slotNames, scope) ||
-          h('div', { domProps: htmlOrText(labelHtml, label) })
-
-        const $srLabel = sortLabel ? h('span', { staticClass: 'sr-only' }, ` (${sortLabel})`) : null
-
-        // Return the header cell
-        return h(BTh, data, [$content, $srLabel].filter(identity))
-      }
-
-      // Generate the array of <th> cells
-      const $cells = fields.map(makeCell).filter(identity)
-
-      // Generate the row(s)
-      const $trs = []
-      if (isFoot) {
-        $trs.push(
-          h(
-            BTr,
-            {
-              class: this.tfootTrClass,
-              props: {
-                variant: isUndefinedOrNull(footRowVariant)
-                  ? headRowVariant
-                  : /* istanbul ignore next */ footRowVariant
-              }
-            },
-            $cells
-          )
-        )
-      } else {
-        const scope = {
-          columns: fields.length,
-          fields,
-          // Add in row select methods
-          selectAllRows,
-          clearSelected
-        }
-        $trs.push(this.normalizeSlot(SLOT_NAME_THEAD_TOP, scope) || h())
-
-        $trs.push(
-          h(
-            BTr,
-            {
-              class: this.theadTrClass,
-              props: { variant: headRowVariant }
-            },
-            $cells
-          )
-        )
-      }
-
-      return h(
-        isFoot ? BTfoot : BThead,
-        {
-          class: (isFoot ? this.tfootClass : this.theadClass) || null,
-          props: isFoot
-            ? { footVariant: footVariant || headVariant || null }
-            : { headVariant: headVariant || null },
-          key: isFoot ? 'bv-tfoot' : 'bv-thead'
-        },
-        $trs
-      )
-    }
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/helpers/mixin-top-row.js

@@ -1,37 +0,0 @@
-import { extend } from '../../../vue'
-import { SLOT_NAME_TOP_ROW } from '../../../constants/slots'
-import { isFunction } from '../../../utils/inspect'
-import { BTr } from '../tr'
-
-// --- Props ---
-
-export const props = {}
-
-// --- Mixin ---
-
-// @vue/component
-export const topRowMixin = extend({
-  methods: {
-    renderTopRow() {
-      const { computedFields: fields, stacked, tbodyTrClass, tbodyTrAttr } = this
-      const h = this.$createElement
-
-      // Add static Top Row slot (hidden in visibly stacked mode as we can't control the data-label)
-      // If in *always* stacked mode, we don't bother rendering the row
-      if (!this.hasNormalizedSlot(SLOT_NAME_TOP_ROW) || stacked === true || stacked === '') {
-        return h()
-      }
-
-      return h(
-        BTr,
-        {
-          staticClass: 'b-table-top-row',
-          class: [isFunction(tbodyTrClass) ? tbodyTrClass(null, 'row-top') : tbodyTrClass],
-          attrs: isFunction(tbodyTrAttr) ? tbodyTrAttr(null, 'row-top') : tbodyTrAttr,
-          key: 'b-top-row'
-        },
-        [this.normalizeSlot(SLOT_NAME_TOP_ROW, { columns: fields.length, fields })]
-      )
-    }
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/helpers/normalize-fields.js

@@ -1,71 +0,0 @@
-import { identity } from '../../../utils/identity'
-import { isArray, isFunction, isObject, isString } from '../../../utils/inspect'
-import { clone, keys } from '../../../utils/object'
-import { startCase } from '../../../utils/string'
-import { IGNORED_FIELD_KEYS } from './constants'
-
-// Private function to massage field entry into common object format
-const processField = (key, value) => {
-  let field = null
-  if (isString(value)) {
-    // Label shortcut
-    field = { key, label: value }
-  } else if (isFunction(value)) {
-    // Formatter shortcut
-    field = { key, formatter: value }
-  } else if (isObject(value)) {
-    field = clone(value)
-    field.key = field.key || key
-  } else if (value !== false) {
-    // Fallback to just key
-    /* istanbul ignore next */
-    field = { key }
-  }
-  return field
-}
-
-// We normalize fields into an array of objects
-// [ { key:..., label:..., ...}, {...}, ..., {..}]
-export const normalizeFields = (origFields, items) => {
-  const fields = []
-
-  if (isArray(origFields)) {
-    // Normalize array Form
-    origFields.filter(identity).forEach(f => {
-      if (isString(f)) {
-        fields.push({ key: f, label: startCase(f) })
-      } else if (isObject(f) && f.key && isString(f.key)) {
-        // Full object definition. We use assign so that we don't mutate the original
-        fields.push(clone(f))
-      } else if (isObject(f) && keys(f).length === 1) {
-        // Shortcut object (i.e. { 'foo_bar': 'This is Foo Bar' }
-        const key = keys(f)[0]
-        const field = processField(key, f[key])
-        if (field) {
-          fields.push(field)
-        }
-      }
-    })
-  }
-
-  // If no field provided, take a sample from first record (if exits)
-  if (fields.length === 0 && isArray(items) && items.length > 0) {
-    const sample = items[0]
-    keys(sample).forEach(k => {
-      if (!IGNORED_FIELD_KEYS[k]) {
-        fields.push({ key: k, label: startCase(k) })
-      }
-    })
-  }
-
-  // Ensure we have a unique array of fields and that they have String labels
-  const memo = {}
-  return fields.filter(f => {
-    if (!memo[f.key]) {
-      memo[f.key] = true
-      f.label = isString(f.label) ? f.label : startCase(f.key)
-      return true
-    }
-    return false
-  })
-}

package/src/vendor/bootstrap-vue/src/components/table/helpers/normalize-fields.spec.js

@@ -1,93 +0,0 @@
-import { normalizeFields } from './normalize-fields'
-
-describe('table/helpers/normalize-fields', () => {
-  it('uses first row of items when fields are not defined and items passed', async () => {
-    const fields = normalizeFields(null, [
-      { foo: 1, bar: { a: 2 }, 'foo bar': 3, baz_bar: 4 },
-      { foo: 1, bar: { a: 2 }, 'foo bar': 3, baz: 5 }
-    ])
-    expect(fields).toEqual([
-      { key: 'foo', label: 'Foo' },
-      { key: 'bar', label: 'Bar' },
-      { key: 'foo bar', label: 'Foo Bar' },
-      { key: 'baz_bar', label: 'Baz Bar' }
-    ])
-  })
-
-  it('ignores special fields in items when fields are not defined and items passed', async () => {
-    const fields = normalizeFields(null, [
-      {
-        foo: 1,
-        bar: 2,
-        _showDetails: true,
-        _rowVariant: 'primary',
-        _cellVariants: ['primary', 'secondary', 'info'],
-        baz: 3
-      }
-    ])
-    expect(fields).toEqual([
-      { key: 'foo', label: 'Foo' },
-      { key: 'bar', label: 'Bar' },
-      { key: 'baz', label: 'Baz' }
-    ])
-  })
-
-  it('returns and empty array when no fields or items passed', async () => {
-    expect(normalizeFields(undefined, undefined)).toEqual([])
-    expect(normalizeFields(null, null)).toEqual([])
-    expect(normalizeFields([], undefined)).toEqual([])
-    expect(normalizeFields(undefined, [])).toEqual([])
-    expect(normalizeFields([], [])).toEqual([])
-    expect(normalizeFields({}, [])).toEqual([])
-  })
-
-  it('handles simple array as fields', async () => {
-    const arr1 = ['foo', 'bar', 'foo_bar']
-    expect(normalizeFields(arr1, [])).toEqual([
-      { key: 'foo', label: 'Foo' },
-      { key: 'bar', label: 'Bar' },
-      { key: 'foo_bar', label: 'Foo Bar' }
-    ])
-  })
-
-  it('handles mixed array format', async () => {
-    const arr1 = ['foo', { bar: { label: 'Bar Label' } }, { baz: 'Baz Label' }]
-
-    expect(normalizeFields(arr1, [])).toEqual([
-      { key: 'foo', label: 'Foo' },
-      { key: 'bar', label: 'Bar Label' },
-      { key: 'baz', label: 'Baz Label' }
-    ])
-  })
-
-  it('handles formatter shortcut', async () => {
-    const formatter = value => value
-    const arr1 = [{ foo: formatter }]
-
-    expect(normalizeFields(arr1, [])).toEqual([{ key: 'foo', label: 'Foo', formatter }])
-  })
-
-  it('handles when "key: false" shortcut', async () => {
-    const arr1 = [{ foo: false }, { bar: 'BAR' }]
-
-    // Should filter out when key uses false shortcut
-    expect(normalizeFields(arr1, [])).toEqual([{ key: 'bar', label: 'BAR' }])
-  })
-
-  it('removes duplicate fields (preserving the first found)', async () => {
-    const arr1 = ['foo', 'bar', 'foo', 'foo_bar']
-    const arr2 = [{ key: 'foo', label: 'Fiz' }, 'bar', 'foo', 'foo_bar']
-
-    expect(normalizeFields(arr1, [])).toEqual([
-      { key: 'foo', label: 'Foo' },
-      { key: 'bar', label: 'Bar' },
-      { key: 'foo_bar', label: 'Foo Bar' }
-    ])
-
-    expect(normalizeFields(arr2, [])).toEqual([
-      { key: 'foo', label: 'Fiz' },
-      { key: 'bar', label: 'Bar' },
-      { key: 'foo_bar', label: 'Foo Bar' }
-    ])
-  })
-})

package/src/vendor/bootstrap-vue/src/components/table/helpers/sanitize-row.js

@@ -1,39 +0,0 @@
-import { arrayIncludes } from '../../../utils/array'
-import { isArray, isFunction } from '../../../utils/inspect'
-import { clone, keys, pick } from '../../../utils/object'
-import { IGNORED_FIELD_KEYS } from './constants'
-
-// Return a copy of a row after all reserved fields have been filtered out
-export const sanitizeRow = (row, ignoreFields, includeFields, fieldsObj = {}) => {
-  // We first need to format the row based on the field configurations
-  // This ensures that we add formatted values for keys that may not
-  // exist in the row itself
-  const formattedRow = keys(fieldsObj).reduce((result, key) => {
-    const field = fieldsObj[key]
-    const { filterByFormatted } = field
-    const formatter = isFunction(filterByFormatted)
-      ? /* istanbul ignore next */ filterByFormatted
-      : filterByFormatted
-        ? /* istanbul ignore next */ field.formatter
-        : null
-
-    if (isFunction(formatter)) {
-      result[key] = formatter(row[key], key, row)
-    }
-
-    return result
-  }, clone(row))
-
-  // Determine the allowed keys:
-  //   - Ignore special fields that start with `_`
-  //   - Ignore fields in the `ignoreFields` array
-  //   - Include only fields in the `includeFields` array
-  const allowedKeys = keys(formattedRow).filter(
-    key =>
-      !IGNORED_FIELD_KEYS[key] &&
-      !(isArray(ignoreFields) && ignoreFields.length > 0 && arrayIncludes(ignoreFields, key)) &&
-      !(isArray(includeFields) && includeFields.length > 0 && !arrayIncludes(includeFields, key))
-  )
-
-  return pick(formattedRow, allowedKeys)
-}

package/src/vendor/bootstrap-vue/src/components/table/helpers/stringify-record-values.js

@@ -1,11 +0,0 @@
-import { isObject } from '../../../utils/inspect'
-import { stringifyObjectValues } from '../../../utils/stringify-object-values'
-import { sanitizeRow } from './sanitize-row'
-
-// Stringifies the values of a record, ignoring any special top level field keys
-// TODO: Add option to stringify `scopedSlot` items
-export const stringifyRecordValues = (row, ignoreFields, includeFields, fieldsObj) => {
-  return isObject(row)
-    ? stringifyObjectValues(sanitizeRow(row, ignoreFields, includeFields, fieldsObj))
-    : /* istanbul ignore next */ ''
-}

package/src/vendor/bootstrap-vue/src/components/table/helpers/text-selection-active.js

@@ -1,13 +0,0 @@
-import { getSel, isElement } from '../../../utils/dom'
-
-// Helper to determine if a there is an active text selection on the document page
-// Used to filter out click events caused by the mouse up at end of selection
-//
-// Accepts an element as only argument to test to see if selection overlaps or is
-// contained within the element
-export const textSelectionActive = (el = document) => {
-  const sel = getSel()
-  return sel && sel.toString().trim() !== '' && sel.containsNode && isElement(el)
-    ? /* istanbul ignore next */ sel.containsNode(el, true)
-    : false
-}