@gitlab/duo-ui 3.0.0 → 3.0.1

package/src/vendor/bootstrap-vue/src/components/table/tbody.js

@@ -1,103 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_TBODY } from '../../constants/components'
-import { PROP_TYPE_OBJECT } from '../../constants/props'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { attrsMixin } from '../../mixins/attrs'
-import { listenersMixin } from '../../mixins/listeners'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  {
-    tbodyTransitionHandlers: makeProp(PROP_TYPE_OBJECT),
-    tbodyTransitionProps: makeProp(PROP_TYPE_OBJECT)
-  },
-  NAME_TBODY
-)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BTbody = /*#__PURE__*/ extend({
-  name: NAME_TBODY,
-  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
-  provide() {
-    return {
-      getBvTableRowGroup: () => this
-    }
-  },
-  inject: {
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    getBvTable: {
-      default: /* istanbul ignore next */ () => () => ({})
-    }
-  },
-  inheritAttrs: false,
-  props,
-  computed: {
-    bvTable() {
-      return this.getBvTable()
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isTbody() {
-      return true
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isDark() {
-      return this.bvTable.dark
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isStacked() {
-      return this.bvTable.isStacked
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isResponsive() {
-      return this.bvTable.isResponsive
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Sticky headers are only supported in thead
-    isStickyHeader() {
-      return false
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    hasStickyHeader() {
-      return !this.isStacked && this.bvTable.stickyHeader
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    tableVariant() {
-      return this.bvTable.tableVariant
-    },
-    isTransitionGroup() {
-      return this.tbodyTransitionProps || this.tbodyTransitionHandlers
-    },
-    tbodyAttrs() {
-      return { role: 'rowgroup', ...this.bvAttrs }
-    },
-    tbodyProps() {
-      const { tbodyTransitionProps } = this
-      return tbodyTransitionProps ? { ...tbodyTransitionProps, tag: 'tbody' } : {}
-    }
-  },
-  render(h) {
-    const data = {
-      props: this.tbodyProps,
-      attrs: this.tbodyAttrs
-    }
-    if (this.isTransitionGroup) {
-      // We use native listeners if a transition group for any delegated events
-      data.on = this.tbodyTransitionHandlers || {}
-      data.nativeOn = this.bvListeners
-    } else {
-      // Otherwise we place any listeners on the tbody element
-      data.on = this.bvListeners
-    }
-
-    return h(this.isTransitionGroup ? 'transition-group' : 'tbody', data, this.normalizeSlot())
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/td.js

@@ -1,195 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_TABLE_CELL } from '../../constants/components'
-import { PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER_STRING, PROP_TYPE_STRING } from '../../constants/props'
-import { isTag } from '../../utils/dom'
-import { isUndefinedOrNull } from '../../utils/inspect'
-import { toInteger } from '../../utils/number'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { toString } from '../../utils/string'
-import { attrsMixin } from '../../mixins/attrs'
-import { listenersMixin } from '../../mixins/listeners'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-
-// --- Helper methods ---
-
-// Parse a rowspan or colspan into a digit (or `null` if < `1` )
-const parseSpan = value => {
-  value = toInteger(value, 0)
-  return value > 0 ? value : null
-}
-
-/* istanbul ignore next */
-const spanValidator = value => isUndefinedOrNull(value) || parseSpan(value) > 0
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  {
-    colspan: makeProp(PROP_TYPE_NUMBER_STRING, null, spanValidator),
-    rowspan: makeProp(PROP_TYPE_NUMBER_STRING, null, spanValidator),
-    stackedHeading: makeProp(PROP_TYPE_STRING),
-    stickyColumn: makeProp(PROP_TYPE_BOOLEAN, false),
-    variant: makeProp(PROP_TYPE_STRING)
-  },
-  NAME_TABLE_CELL
-)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BTd = /*#__PURE__*/ extend({
-  name: NAME_TABLE_CELL,
-  // Mixin order is important!
-  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
-  inject: {
-    getBvTableTr: {
-      default: /* istanbul ignore next */ () => () => ({})
-    }
-  },
-  inheritAttrs: false,
-  props,
-  computed: {
-    bvTableTr() {
-      return this.getBvTableTr()
-    },
-    // Overridden by `<b-th>`
-    tag() {
-      return 'td'
-    },
-    inTbody() {
-      return this.bvTableTr.inTbody
-    },
-    inThead() {
-      return this.bvTableTr.inThead
-    },
-    inTfoot() {
-      return this.bvTableTr.inTfoot
-    },
-    isDark() {
-      return this.bvTableTr.isDark
-    },
-    isStacked() {
-      return this.bvTableTr.isStacked
-    },
-    // We only support stacked-heading in tbody in stacked mode
-    isStackedCell() {
-      return this.inTbody && this.isStacked
-    },
-    isResponsive() {
-      return this.bvTableTr.isResponsive
-    },
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    // Sticky headers only apply to cells in table `thead`
-    isStickyHeader() {
-      return this.bvTableTr.isStickyHeader
-    },
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    hasStickyHeader() {
-      return this.bvTableTr.hasStickyHeader
-    },
-    // Needed to handle background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    // Sticky column cells are only available in responsive
-    // mode (horizontal scrolling) or when sticky header mode
-    // Applies to cells in `thead`, `tbody` and `tfoot`
-    isStickyColumn() {
-      return !this.isStacked && (this.isResponsive || this.hasStickyHeader) && this.stickyColumn
-    },
-    rowVariant() {
-      return this.bvTableTr.variant
-    },
-    headVariant() {
-      return this.bvTableTr.headVariant
-    },
-    footVariant() {
-      return this.bvTableTr.footVariant
-    },
-    tableVariant() {
-      return this.bvTableTr.tableVariant
-    },
-    computedColspan() {
-      return parseSpan(this.colspan)
-    },
-    computedRowspan() {
-      return parseSpan(this.rowspan)
-    },
-    // We use computed props here for improved performance by caching
-    // the results of the string interpolation
-    cellClasses() {
-      let { variant, headVariant, isStickyColumn } = this
-      if (
-        (!variant && this.isStickyHeader && !headVariant) ||
-        (!variant && isStickyColumn && this.inTfoot && !this.footVariant) ||
-        (!variant && isStickyColumn && this.inThead && !headVariant) ||
-        (!variant && isStickyColumn && this.inTbody)
-      ) {
-        // Needed for sticky-header mode as Bootstrap v4 table cells do
-        // not inherit parent's `background-color`
-        variant = this.rowVariant || this.tableVariant || 'b-table-default'
-      }
-      return [
-        variant ? `${this.isDark ? 'bg' : 'table'}-${variant}` : null,
-        isStickyColumn ? 'b-table-sticky-column' : null
-      ]
-    },
-    cellAttrs() {
-      const { stackedHeading } = this
-
-      // We use computed props here for improved performance by caching
-      // the results of the object spread (Object.assign)
-      const headOrFoot = this.inThead || this.inTfoot
-      // Make sure col/rowspan's are > 0 or null
-      const colspan = this.computedColspan
-      const rowspan = this.computedRowspan
-      // Default role and scope
-      let role = 'cell'
-      let scope = null
-
-      // Compute role and scope
-      // We only add scopes with an explicit span of 1 or greater
-      if (headOrFoot) {
-        // Header or footer cells
-        role = 'columnheader'
-        scope = colspan > 0 ? 'colspan' : 'col'
-      } else if (isTag(this.tag, 'th')) {
-        // th's in tbody
-        role = 'rowheader'
-        scope = rowspan > 0 ? 'rowgroup' : 'row'
-      }
-
-      return {
-        colspan,
-        rowspan,
-        role,
-        scope,
-        // Allow users to override role/scope plus add other attributes
-        ...this.bvAttrs,
-        // Add in the stacked cell label data-attribute if in
-        // stacked mode (if a stacked heading label is provided)
-        'data-label':
-          this.isStackedCell && !isUndefinedOrNull(stackedHeading)
-            ? /* istanbul ignore next */ toString(stackedHeading)
-            : null
-      }
-    }
-  },
-  render(h) {
-    const $content = [this.normalizeSlot()]
-
-    return h(
-      this.tag,
-      {
-        class: this.cellClasses,
-        attrs: this.cellAttrs,
-        // Transfer any native listeners
-        on: this.bvListeners
-      },
-      [this.isStackedCell ? h('div', [$content]) : $content]
-    )
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/tfoot.js

@@ -1,95 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_TFOOT } from '../../constants/components'
-import { PROP_TYPE_STRING } from '../../constants/props'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { attrsMixin } from '../../mixins/attrs'
-import { listenersMixin } from '../../mixins/listeners'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  {
-    // Supported values: 'lite', 'dark', or null
-    footVariant: makeProp(PROP_TYPE_STRING)
-  },
-  NAME_TFOOT
-)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BTfoot = /*#__PURE__*/ extend({
-  name: NAME_TFOOT,
-  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
-  provide() {
-    return {
-      getBvTableRowGroup: () => this
-    }
-  },
-  inject: {
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    getBvTable: {
-      default: /* istanbul ignore next */ () => () => ({})
-    }
-  },
-  inheritAttrs: false,
-  props,
-  computed: {
-    bvTable() {
-      return this.getBvTable()
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isTfoot() {
-      return true
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isDark() {
-      return this.bvTable.dark
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isStacked() {
-      return this.bvTable.isStacked
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isResponsive() {
-      return this.bvTable.isResponsive
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Sticky headers are only supported in thead
-    isStickyHeader() {
-      return false
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    hasStickyHeader() {
-      return !this.isStacked && this.bvTable.stickyHeader
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    tableVariant() {
-      return this.bvTable.tableVariant
-    },
-    tfootClasses() {
-      return [this.footVariant ? `thead-${this.footVariant}` : null]
-    },
-    tfootAttrs() {
-      return { ...this.bvAttrs, role: 'rowgroup' }
-    }
-  },
-  render(h) {
-    return h(
-      'tfoot',
-      {
-        class: this.tfootClasses,
-        attrs: this.tfootAttrs,
-        // Pass down any native listeners
-        on: this.bvListeners
-      },
-      this.normalizeSlot()
-    )
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/th.js

@@ -1,25 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_TH } from '../../constants/components'
-import { makePropsConfigurable } from '../../utils/props'
-import { BTd, props as BTdProps } from './td'
-
-// --- Props ---
-
-export const props = makePropsConfigurable(BTdProps, NAME_TH)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BTh = /*#__PURE__*/ extend({
-  name: NAME_TH,
-  extends: BTd,
-  props,
-  computed: {
-    tag() {
-      return 'th'
-    }
-  }
-})

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

@@ -1,98 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_THEAD } from '../../constants/components'
-import { PROP_TYPE_STRING } from '../../constants/props'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { attrsMixin } from '../../mixins/attrs'
-import { listenersMixin } from '../../mixins/listeners'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  {
-    // Also sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Supported values: 'lite', 'dark', or `null`
-    headVariant: makeProp(PROP_TYPE_STRING)
-  },
-  NAME_THEAD
-)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BThead = /*#__PURE__*/ extend({
-  name: NAME_THEAD,
-  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
-  provide() {
-    return {
-      getBvTableRowGroup: () => this
-    }
-  },
-  inject: {
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    getBvTable: {
-      default: /* istanbul ignore next */ () => () => ({})
-    }
-  },
-  inheritAttrs: false,
-  props,
-  computed: {
-    bvTable() {
-      return this.getBvTable()
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isThead() {
-      return true
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isDark() {
-      return this.bvTable.dark
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isStacked() {
-      return this.bvTable.isStacked
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    isResponsive() {
-      return this.bvTable.isResponsive
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    // Sticky headers only apply to cells in table `thead`
-    isStickyHeader() {
-      return !this.isStacked && this.bvTable.stickyHeader
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    hasStickyHeader() {
-      return !this.isStacked && this.bvTable.stickyHeader
-    },
-    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
-    tableVariant() {
-      return this.bvTable.tableVariant
-    },
-    theadClasses() {
-      return [this.headVariant ? `thead-${this.headVariant}` : null]
-    },
-    theadAttrs() {
-      return { role: 'rowgroup', ...this.bvAttrs }
-    }
-  },
-  render(h) {
-    return h(
-      'thead',
-      {
-        class: this.theadClasses,
-        attrs: this.theadAttrs,
-        // Pass down any native listeners
-        on: this.bvListeners
-      },
-      this.normalizeSlot()
-    )
-  }
-})

package/src/vendor/bootstrap-vue/src/components/table/tr.js

@@ -1,122 +0,0 @@
-import { extend } from '../../vue'
-import { NAME_TR } from '../../constants/components'
-import { PROP_TYPE_STRING } from '../../constants/props'
-import { makeProp, makePropsConfigurable } from '../../utils/props'
-import { attrsMixin } from '../../mixins/attrs'
-import { listenersMixin } from '../../mixins/listeners'
-import { normalizeSlotMixin } from '../../mixins/normalize-slot'
-
-// --- Constants ---
-
-const LIGHT = 'light'
-const DARK = 'dark'
-
-// --- Props ---
-
-export const props = makePropsConfigurable(
-  {
-    variant: makeProp(PROP_TYPE_STRING)
-  },
-  NAME_TR
-)
-
-// --- Main component ---
-
-// TODO:
-//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
-//   to the child elements, so this can be converted to a functional component
-// @vue/component
-export const BTr = /*#__PURE__*/ extend({
-  name: NAME_TR,
-  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
-  provide() {
-    return {
-      getBvTableTr: () => this
-    }
-  },
-  inject: {
-    getBvTableRowGroup: {
-      default: /* istanbul ignore next */ () => () => ({})
-    }
-  },
-  inheritAttrs: false,
-  props,
-  computed: {
-    bvTableRowGroup() {
-      return this.getBvTableRowGroup()
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    inTbody() {
-      return this.bvTableRowGroup.isTbody
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    inThead() {
-      return this.bvTableRowGroup.isThead
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    inTfoot() {
-      return this.bvTableRowGroup.isTfoot
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    isDark() {
-      return this.bvTableRowGroup.isDark
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    isStacked() {
-      return this.bvTableRowGroup.isStacked
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    isResponsive() {
-      return this.bvTableRowGroup.isResponsive
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    // Sticky headers are only supported in thead
-    isStickyHeader() {
-      return this.bvTableRowGroup.isStickyHeader
-    },
-    // Sniffed by <b-tr> / `<b-td>` / `<b-th>`
-    // Needed to handle header background classes, due to lack of
-    // background color inheritance with Bootstrap v4 table CSS
-    hasStickyHeader() {
-      return !this.isStacked && this.bvTableRowGroup.hasStickyHeader
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    tableVariant() {
-      return this.bvTableRowGroup.tableVariant
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    headVariant() {
-      return this.inThead ? this.bvTableRowGroup.headVariant : null
-    },
-    // Sniffed by `<b-td>` / `<b-th>`
-    footVariant() {
-      return this.inTfoot ? this.bvTableRowGroup.footVariant : null
-    },
-    isRowDark() {
-      return this.headVariant === LIGHT || this.footVariant === LIGHT
-        ? /* istanbul ignore next */ false
-        : this.headVariant === DARK || this.footVariant === DARK
-          ? /* istanbul ignore next */ true
-          : this.isDark
-    },
-    trClasses() {
-      const { variant } = this
-      return [variant ? `${this.isRowDark ? 'bg' : 'table'}-${variant}` : null]
-    },
-    trAttrs() {
-      return { role: 'row', ...this.bvAttrs }
-    }
-  },
-  render(h) {
-    return h(
-      'tr',
-      {
-        class: this.trClasses,
-        attrs: this.trAttrs,
-        // Pass native listeners to child
-        on: this.bvListeners
-      },
-      this.normalizeSlot()
-    )
-  }
-})