@gitlab/ui 132.0.1 → 132.0.3

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

@@ -0,0 +1,233 @@
+import { extend } from '../../../vue';
+import { EVENT_NAME_HEAD_CLICKED } from '../../../constants/events';
+import { CODE_ENTER, CODE_SPACE } from '../../../constants/key-codes';
+import { PROP_TYPE_STRING, PROP_TYPE_ARRAY, PROP_TYPE_OBJECT } 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 { 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 ---
+
+const props = {
+  // Any Bootstrap theme variant (or custom)
+  headRowVariant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  // 'light', 'dark' or `null` (or custom)
+  headVariant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  theadClass: {
+    type: [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING],
+    required: false,
+    default: undefined
+  },
+  theadTrClass: {
+    type: [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING],
+    required: false,
+    default: undefined
+  }
+};
+
+// --- Mixin ---
+
+// @vue/component
+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);
+      // Call handleSort directly if sortable (defined in mixin-sorting.js)
+      if (this.isSortable) {
+        this.handleSort(field.key, field, event, isFoot);
+      }
+    },
+    renderThead() {
+      let isFoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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 `.gl-sr-only` sort label to work around overflow issues
+            'gl-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: 'gl-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);
+    }
+  }
+});
+
+export { props, theadMixin };

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

@@ -0,0 +1,42 @@
+import { extend } from '../../../vue';
+import { SLOT_NAME_TOP_ROW } from '../../../constants/slots';
+import { isFunction } from '../../../utils/inspect';
+import { BTr } from '../tr';
+
+// --- Props ---
+
+const props = {};
+
+// --- Mixin ---
+
+// @vue/component
+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
+      })]);
+    }
+  }
+});
+
+export { props, topRowMixin };

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

@@ -0,0 +1,86 @@
+import { identity } from '../../../utils/identity';
+import { isArray, isString, isObject, isFunction } 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:..., ...}, {...}, ..., {..}]
+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;
+  });
+};
+
+export { normalizeFields };

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

@@ -0,0 +1,31 @@
+import { isFunction, isArray } from '../../../utils/inspect';
+import { keys, clone, pick } from '../../../utils/object';
+import { IGNORED_FIELD_KEYS } from './constants';
+
+// Return a copy of a row after all reserved fields have been filtered out
+const sanitizeRow = function (row, ignoreFields, includeFields) {
+  let fieldsObj = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // 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 && ignoreFields.includes(key)) && !(isArray(includeFields) && includeFields.length > 0 && !includeFields.includes(key)));
+  return pick(formattedRow, allowedKeys);
+};
+
+export { sanitizeRow };

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

@@ -0,0 +1,11 @@
+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
+const stringifyRecordValues = (row, ignoreFields, includeFields, fieldsObj) => {
+  return isObject(row) ? stringifyObjectValues(sanitizeRow(row, ignoreFields, includeFields, fieldsObj)) : /* istanbul ignore next */'';
+};
+
+export { stringifyRecordValues };

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 };