@gitlab/ui 132.0.0 → 132.0.2

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

@@ -0,0 +1,14 @@
+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
+const textSelectionActive = function () {
+  let el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
+  const sel = getSel();
+  return sel && sel.toString().trim() !== '' && sel.containsNode && isElement(el) ? /* istanbul ignore next */sel.containsNode(el, true) : false;
+};
+
+export { textSelectionActive };

package/dist/vendor/bootstrap-vue/src/components/table/index.js

@@ -0,0 +1,9 @@
+export { BTable } from './table';
+export { BTableLite } from './table-lite';
+export { BTableSimple } from './table-simple';
+export { BTbody } from './tbody';
+export { BThead } from './thead';
+export { BTfoot } from './tfoot';
+export { BTr } from './tr';
+export { BTd } from './td';
+export { BTh } from './th';

package/dist/vendor/bootstrap-vue/src/components/table/table-lite.js

@@ -0,0 +1,51 @@
+import { extend } from '../../vue';
+import { NAME_TABLE_LITE } from '../../constants/components';
+import { sortKeys } from '../../utils/object';
+import { attrsMixin } from '../../mixins/attrs';
+import { hasListenerMixin } from '../../mixins/has-listener';
+import { props as props$1, idMixin } from '../../mixins/id';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { props as props$2, captionMixin } from './helpers/mixin-caption';
+import { props as props$3, colgroupMixin } from './helpers/mixin-colgroup';
+import { props as props$4, itemsMixin } from './helpers/mixin-items';
+import { props as props$5, stackedMixin } from './helpers/mixin-stacked';
+import { props as props$6, tableRendererMixin } from './helpers/mixin-table-renderer';
+import { props as props$7, tbodyMixin } from './helpers/mixin-tbody';
+import { props as props$8, tfootMixin } from './helpers/mixin-tfoot';
+import { props as props$9, theadMixin } from './helpers/mixin-thead';
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  ...props$2,
+  ...props$3,
+  ...props$4,
+  ...props$5,
+  ...props$6,
+  ...props$7,
+  ...props$8,
+  ...props$9
+});
+
+// --- Main component ---
+
+// @vue/component
+const BTableLite = /*#__PURE__*/extend({
+  name: NAME_TABLE_LITE,
+  // Order of mixins is important!
+  // They are merged from first to last, followed by this component
+  mixins: [
+  // General mixins
+  attrsMixin, hasListenerMixin, idMixin, normalizeSlotMixin,
+  // Required table mixins
+  itemsMixin, tableRendererMixin, stackedMixin, theadMixin, tfootMixin, tbodyMixin,
+  // Table features mixins
+  // These are pretty lightweight, and are useful for lightweight tables
+  captionMixin, colgroupMixin],
+  props
+
+  // Render function is provided by `tableRendererMixin`
+});
+
+export { BTableLite, props };

package/dist/vendor/bootstrap-vue/src/components/table/table-simple.js

@@ -0,0 +1,44 @@
+import { extend } from '../../vue';
+import { NAME_TABLE_SIMPLE } from '../../constants/components';
+import { sortKeys } from '../../utils/object';
+import { attrsMixin } from '../../mixins/attrs';
+import { hasListenerMixin } from '../../mixins/has-listener';
+import { props as props$1, idMixin } from '../../mixins/id';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { props as props$2, stackedMixin } from './helpers/mixin-stacked';
+import { props as props$3, tableRendererMixin } from './helpers/mixin-table-renderer';
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  ...props$2,
+  ...props$3
+});
+
+// --- Main component ---
+
+// @vue/component
+const BTableSimple = /*#__PURE__*/extend({
+  name: NAME_TABLE_SIMPLE,
+  // Order of mixins is important!
+  // They are merged from first to last, followed by this component
+  mixins: [
+  // General mixins
+  attrsMixin, hasListenerMixin, idMixin, normalizeSlotMixin,
+  // Required table mixins
+  tableRendererMixin,
+  // Table features mixins
+  // Stacked requires extra handling by users via
+  // the table cell `stacked-heading` prop
+  stackedMixin],
+  props,
+  computed: {
+    isTableSimple() {
+      return true;
+    }
+  }
+  // Render function is provided by `tableRendererMixin`
+});
+
+export { BTableSimple, props };

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

@@ -0,0 +1,67 @@
+import { extend } from '../../vue';
+import { NAME_TABLE } from '../../constants/components';
+import { sortKeys } from '../../utils/object';
+import { attrsMixin } from '../../mixins/attrs';
+import { hasListenerMixin } from '../../mixins/has-listener';
+import { props as props$1, idMixin } from '../../mixins/id';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { props as props$2, bottomRowMixin } from './helpers/mixin-bottom-row';
+import { props as props$3, busyMixin } from './helpers/mixin-busy';
+import { props as props$4, captionMixin } from './helpers/mixin-caption';
+import { props as props$5, colgroupMixin } from './helpers/mixin-colgroup';
+import { props as props$6, emptyMixin } from './helpers/mixin-empty';
+import { props as props$7, filteringMixin } from './helpers/mixin-filtering';
+import { props as props$8, itemsMixin } from './helpers/mixin-items';
+import { props as props$9, paginationMixin } from './helpers/mixin-pagination';
+import { props as props$a, providerMixin } from './helpers/mixin-provider';
+import { props as props$b, selectableMixin } from './helpers/mixin-selectable';
+import { props as props$c, sortingMixin } from './helpers/mixin-sorting';
+import { props as props$d, stackedMixin } from './helpers/mixin-stacked';
+import { props as props$e, tableRendererMixin } from './helpers/mixin-table-renderer';
+import { props as props$f, tbodyMixin } from './helpers/mixin-tbody';
+import { props as props$g, tfootMixin } from './helpers/mixin-tfoot';
+import { props as props$h, theadMixin } from './helpers/mixin-thead';
+import { props as props$i, topRowMixin } from './helpers/mixin-top-row';
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  ...props$2,
+  ...props$3,
+  ...props$4,
+  ...props$5,
+  ...props$6,
+  ...props$7,
+  ...props$8,
+  ...props$9,
+  ...props$a,
+  ...props$b,
+  ...props$c,
+  ...props$d,
+  ...props$e,
+  ...props$f,
+  ...props$g,
+  ...props$h,
+  ...props$i
+});
+
+// --- Main component ---
+
+// @vue/component
+const BTable = /*#__PURE__*/extend({
+  name: NAME_TABLE,
+  // Order of mixins is important!
+  // They are merged from first to last, followed by this component
+  mixins: [
+  // General mixins
+  attrsMixin, hasListenerMixin, idMixin, normalizeSlotMixin,
+  // Required table mixins
+  itemsMixin, tableRendererMixin, stackedMixin, theadMixin, tfootMixin, tbodyMixin,
+  // Table features mixins
+  stackedMixin, filteringMixin, sortingMixin, paginationMixin, captionMixin, colgroupMixin, selectableMixin, emptyMixin, topRowMixin, bottomRowMixin, busyMixin, providerMixin],
+  props
+  // Render function is provided by `tableRendererMixin`
+});
+
+export { BTable, props };

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

@@ -0,0 +1,116 @@
+import { extend } from '../../vue';
+import { NAME_TBODY } from '../../constants/components';
+import { PROP_TYPE_OBJECT } from '../../constants/props';
+import { attrsMixin } from '../../mixins/attrs';
+import { listenersMixin } from '../../mixins/listeners';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+
+// --- Props ---
+
+const props = {
+  tbodyTransitionHandlers: {
+    type: PROP_TYPE_OBJECT,
+    required: false,
+    default: undefined
+  },
+  tbodyTransitionProps: {
+    type: PROP_TYPE_OBJECT,
+    required: false,
+    default: undefined
+  }
+};
+
+// --- 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
+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());
+  }
+});
+
+export { BTbody, props };

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

@@ -0,0 +1,204 @@
+import { extend } from '../../vue';
+import { NAME_TABLE_CELL } from '../../constants/components';
+import { PROP_TYPE_NUMBER, PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+import { isTag } from '../../utils/dom';
+import { isUndefinedOrNull } from '../../utils/inspect';
+import { toInteger } from '../../utils/number';
+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 ---
+
+const props = {
+  colspan: {
+    type: [PROP_TYPE_NUMBER, PROP_TYPE_STRING],
+    required: false,
+    default: null,
+    validator: spanValidator
+  },
+  rowspan: {
+    type: [PROP_TYPE_NUMBER, PROP_TYPE_STRING],
+    required: false,
+    default: null,
+    validator: spanValidator
+  },
+  stackedHeading: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  stickyColumn: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  variant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  }
+};
+
+// --- 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
+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]);
+  }
+});
+
+export { BTd, props };

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

@@ -0,0 +1,96 @@
+import { extend } from '../../vue';
+import { NAME_TFOOT } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { attrsMixin } from '../../mixins/attrs';
+import { listenersMixin } from '../../mixins/listeners';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+
+// --- Props ---
+
+const props = {
+  // Supported values: 'lite', 'dark', or null
+  footVariant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  }
+};
+
+// --- 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
+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());
+  }
+});
+
+export { BTfoot, props };

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

@@ -0,0 +1,26 @@
+import { extend } from '../../vue';
+import { NAME_TH } from '../../constants/components';
+import { props as props$1, BTd } from './td';
+
+// --- Props ---
+
+const props = props$1;
+
+// --- 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
+const BTh = /*#__PURE__*/extend({
+  name: NAME_TH,
+  extends: BTd,
+  props,
+  computed: {
+    tag() {
+      return 'th';
+    }
+  }
+});
+
+export { BTh, props };