@gitlab/ui 84.1.0 → 85.0.0

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

@@ -0,0 +1,49 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_SKELETON } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  animation: makeProp(PROP_TYPE_STRING, 'wave'),
+  height: makeProp(PROP_TYPE_STRING),
+  size: makeProp(PROP_TYPE_STRING),
+  type: makeProp(PROP_TYPE_STRING, 'text'),
+  variant: makeProp(PROP_TYPE_STRING),
+  width: makeProp(PROP_TYPE_STRING)
+}, NAME_SKELETON);
+
+// --- Main component ---
+
+// @vue/component
+const BSkeleton = /*#__PURE__*/extend({
+  name: NAME_SKELETON,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      data,
+      props
+    } = _ref;
+    const {
+      size,
+      animation,
+      variant
+    } = props;
+    return h('div', mergeData(data, {
+      staticClass: 'b-skeleton',
+      style: {
+        width: size || props.width,
+        height: size || props.height
+      },
+      class: {
+        [`b-skeleton-${props.type}`]: true,
+        [`b-skeleton-animate-${animation}`]: animation,
+        [`bg-${variant}`]: variant
+      }
+    }));
+  }
+});
+
+export { BSkeleton, props };

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

@@ -0,0 +1,11 @@
+import { BSpinner } from './spinner';
+export { BSpinner } from './spinner';
+import { pluginFactory } from '../../utils/plugins';
+
+const SpinnerPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BSpinner
+  }
+});
+
+export { SpinnerPlugin };

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

@@ -0,0 +1,55 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_SPINNER } from '../../constants/components';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+import { SLOT_NAME_LABEL } from '../../constants/slots';
+import { normalizeSlot } from '../../utils/normalize-slot';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  label: makeProp(PROP_TYPE_STRING),
+  role: makeProp(PROP_TYPE_STRING, 'status'),
+  small: makeProp(PROP_TYPE_BOOLEAN, false),
+  tag: makeProp(PROP_TYPE_STRING, 'span'),
+  type: makeProp(PROP_TYPE_STRING, 'border'),
+  variant: makeProp(PROP_TYPE_STRING)
+}, NAME_SPINNER);
+
+// --- Main component ---
+
+// @vue/component
+const BSpinner = /*#__PURE__*/extend({
+  name: NAME_SPINNER,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      slots,
+      scopedSlots
+    } = _ref;
+    const $slots = slots();
+    const $scopedSlots = scopedSlots || {};
+    let $label = normalizeSlot(SLOT_NAME_LABEL, {}, $scopedSlots, $slots) || props.label;
+    if ($label) {
+      $label = h('span', {
+        staticClass: 'sr-only'
+      }, $label);
+    }
+    return h(props.tag, mergeData(data, {
+      attrs: {
+        role: $label ? props.role || 'status' : null,
+        'aria-hidden': $label ? null : 'true'
+      },
+      class: {
+        [`spinner-${props.type}`]: props.type,
+        [`spinner-${props.type}-sm`]: props.small,
+        [`text-${props.variant}`]: props.variant
+      }
+    }), [$label || h()]);
+  }
+});
+
+export { BSpinner, props };

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

@@ -0,0 +1,22 @@
+// Constants used by table helpers
+
+const FIELD_KEY_CELL_VARIANT = '_cellVariants';
+const FIELD_KEY_ROW_VARIANT = '_rowVariant';
+const FIELD_KEY_SHOW_DETAILS = '_showDetails';
+
+// Object of item keys that should be ignored for headers and
+// stringification and filter events
+const IGNORED_FIELD_KEYS = [FIELD_KEY_CELL_VARIANT, FIELD_KEY_ROW_VARIANT, FIELD_KEY_SHOW_DETAILS].reduce((result, key) => ({
+  ...result,
+  [key]: true
+}), {});
+
+// Filter CSS selector for click/dblclick/etc. events
+// If any of these selectors match the clicked element, we ignore the event
+const EVENT_FILTER = ['a', 'a *',
+// Include content inside links
+'button', 'button *',
+// Include content inside buttons
+'input:not(.disabled):not([disabled])', 'select:not(.disabled):not([disabled])', 'textarea:not(.disabled):not([disabled])', '[role="link"]', '[role="link"] *', '[role="button"]', '[role="button"] *', '[tabindex]:not(.disabled):not([disabled])'].join(',');
+
+export { EVENT_FILTER, FIELD_KEY_CELL_VARIANT, FIELD_KEY_ROW_VARIANT, FIELD_KEY_SHOW_DETAILS, IGNORED_FIELD_KEYS };

package/dist/vendor/bootstrap-vue/src/components/table/helpers/default-sort-compare.js

@@ -0,0 +1,64 @@
+import { get } from '../../../utils/get';
+import { isFunction, isDate, isNumber, isUndefinedOrNull, isNumeric } from '../../../utils/inspect';
+import { toFloat } from '../../../utils/number';
+import { stringifyObjectValues } from '../../../utils/stringify-object-values';
+
+const normalizeValue = value => {
+  if (isUndefinedOrNull(value)) {
+    return '';
+  }
+  if (isNumeric(value)) {
+    return toFloat(value, value);
+  }
+  return value;
+};
+
+// Default sort compare routine
+//
+// TODO:
+//   Add option to sort by multiple columns (tri-state per column,
+//   plus order of columns in sort) where `sortBy` could be an array
+//   of objects `[ {key: 'foo', sortDir: 'asc'}, {key:'bar', sortDir: 'desc'} ...]`
+//   or an array of arrays `[ ['foo','asc'], ['bar','desc'] ]`
+//   Multisort will most likely be handled in `mixin-sort.js` by
+//   calling this method for each sortBy
+const defaultSortCompare = function (a, b) {
+  let {
+    sortBy = null,
+    formatter = null,
+    locale = undefined,
+    localeOptions = {},
+    nullLast = false
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  // Get the value by `sortBy`
+  let aa = get(a, sortBy, null);
+  let bb = get(b, sortBy, null);
+
+  // Apply user-provided formatter
+  if (isFunction(formatter)) {
+    aa = formatter(aa, sortBy, a);
+    bb = formatter(bb, sortBy, b);
+  }
+
+  // Internally normalize value
+  // `null` / `undefined` => ''
+  // `'0'` => `0`
+  aa = normalizeValue(aa);
+  bb = normalizeValue(bb);
+  if (isDate(aa) && isDate(bb) || isNumber(aa) && isNumber(bb)) {
+    // Special case for comparing dates and numbers
+    // Internally dates are compared via their epoch number values
+    return aa < bb ? -1 : aa > bb ? 1 : 0;
+  } else if (nullLast && aa === '' && bb !== '') {
+    // Special case when sorting `null` / `undefined` / '' last
+    return 1;
+  } else if (nullLast && aa !== '' && bb === '') {
+    // Special case when sorting `null` / `undefined` / '' last
+    return -1;
+  }
+
+  // Do localized string comparison
+  return stringifyObjectValues(aa).localeCompare(stringifyObjectValues(bb), locale, localeOptions);
+};
+
+export { defaultSortCompare };

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

@@ -0,0 +1,40 @@
+import { closest, getAttr, getById, select, matches } from '../../../utils/dom';
+import { EVENT_FILTER } from './constants';
+
+const TABLE_TAG_NAMES = ['TD', 'TH', 'TR'];
+
+// Returns `true` if we should ignore the click/double-click/keypress event
+// Avoids having the user need to use `@click.stop` on the form control
+const filterEvent = event => {
+  // Exit early when we don't have a target element
+  if (!event || !event.target) {
+    /* istanbul ignore next */
+    return false;
+  }
+  const el = event.target;
+  // Exit early when element is disabled or a table element
+  if (el.disabled || TABLE_TAG_NAMES.indexOf(el.tagName) !== -1) {
+    return false;
+  }
+  // Ignore the click when it was inside a dropdown menu
+  if (closest('.dropdown-menu', el)) {
+    return true;
+  }
+  const label = el.tagName === 'LABEL' ? el : closest('label', el);
+  // If the label's form control is not disabled then we don't propagate event
+  // Modern browsers have `label.control` that references the associated input, but IE 11
+  // does not have this property on the label element, so we resort to DOM lookups
+  if (label) {
+    const labelFor = getAttr(label, 'for');
+    const input = labelFor ? getById(labelFor) : select('input, select, textarea', label);
+    if (input && !input.disabled) {
+      return true;
+    }
+  }
+  // Otherwise check if the event target matches one of the selectors in the
+  // event filter (i.e. anchors, non disabled inputs, etc.)
+  // Return `true` if we should ignore the event
+  return matches(el, EVENT_FILTER);
+};
+
+export { filterEvent };

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

@@ -0,0 +1,43 @@
+import { extend } from '../../../vue';
+import { SLOT_NAME_BOTTOM_ROW } from '../../../constants/slots';
+import { isFunction } from '../../../utils/inspect';
+import { BTr } from '../tr';
+
+// --- Props ---
+
+const props = {};
+
+// --- Mixin ---
+
+// @vue/component
+const bottomRowMixin = extend({
+  props,
+  methods: {
+    renderBottomRow() {
+      const {
+        computedFields: fields,
+        stacked,
+        tbodyTrClass,
+        tbodyTrAttr
+      } = this;
+      const h = this.$createElement;
+
+      // Static bottom 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_BOTTOM_ROW) || stacked === true || stacked === '') {
+        return h();
+      }
+      return h(BTr, {
+        staticClass: 'b-table-bottom-row',
+        class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, 'row-bottom') : tbodyTrClass],
+        attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, 'row-bottom') : tbodyTrAttr,
+        key: 'b-bottom-row'
+      }, this.normalizeSlot(SLOT_NAME_BOTTOM_ROW, {
+        columns: fields.length,
+        fields
+      }));
+    }
+  }
+});
+
+export { bottomRowMixin, props };

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

@@ -0,0 +1,83 @@
+import { extend } from '../../../vue';
+import { MODEL_EVENT_NAME_PREFIX } from '../../../constants/events';
+import { PROP_TYPE_BOOLEAN } from '../../../constants/props';
+import { SLOT_NAME_TABLE_BUSY } from '../../../constants/slots';
+import { stopEvent } from '../../../utils/events';
+import { isFunction } from '../../../utils/inspect';
+import { makeProp } from '../../../utils/props';
+import { BTr } from '../tr';
+import { BTd } from '../td';
+
+// --- Constants ---
+
+const MODEL_PROP_NAME_BUSY = 'busy';
+const MODEL_EVENT_NAME_BUSY = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_BUSY;
+
+// --- Props ---
+
+const props = {
+  [MODEL_PROP_NAME_BUSY]: makeProp(PROP_TYPE_BOOLEAN, false)
+};
+
+// --- Mixin ---
+
+// @vue/component
+const busyMixin = extend({
+  props,
+  data() {
+    return {
+      localBusy: false
+    };
+  },
+  computed: {
+    computedBusy() {
+      return this[MODEL_PROP_NAME_BUSY] || this.localBusy;
+    }
+  },
+  watch: {
+    localBusy(newValue, oldValue) {
+      if (newValue !== oldValue) {
+        this.$emit(MODEL_EVENT_NAME_BUSY, newValue);
+      }
+    }
+  },
+  methods: {
+    // Event handler helper
+    stopIfBusy(event) {
+      // If table is busy (via provider) then don't propagate
+      if (this.computedBusy) {
+        stopEvent(event);
+        return true;
+      }
+      return false;
+    },
+    // Render the busy indicator or return `null` if not busy
+    renderBusy() {
+      const {
+        tbodyTrClass,
+        tbodyTrAttr
+      } = this;
+      const h = this.$createElement;
+
+      // Return a busy indicator row, or `null` if not busy
+      if (this.computedBusy && this.hasNormalizedSlot(SLOT_NAME_TABLE_BUSY)) {
+        return h(BTr, {
+          staticClass: 'b-table-busy-slot',
+          class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, SLOT_NAME_TABLE_BUSY) : tbodyTrClass],
+          attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, SLOT_NAME_TABLE_BUSY) : tbodyTrAttr,
+          key: 'table-busy-slot'
+        }, [h(BTd, {
+          props: {
+            colspan: this.computedFields.length || null
+          }
+        }, [this.normalizeSlot(SLOT_NAME_TABLE_BUSY)])]);
+      }
+
+      // We return `null` here so that we can determine if we need to
+      // render the table items rows or not
+      return null;
+    }
+  }
+});
+
+export { busyMixin, props };

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

@@ -0,0 +1,50 @@
+import { extend } from '../../../vue';
+import { PROP_TYPE_STRING } from '../../../constants/props';
+import { SLOT_NAME_TABLE_CAPTION } from '../../../constants/slots';
+import { htmlOrText } from '../../../utils/html';
+import { makeProp } from '../../../utils/props';
+
+// --- Props ---
+
+const props = {
+  caption: makeProp(PROP_TYPE_STRING),
+  captionHtml: makeProp(PROP_TYPE_STRING)
+  // `caption-top` is part of table-render mixin (styling)
+  // captionTop: makeProp(PROP_TYPE_BOOLEAN, false)
+};
+
+// --- Mixin ---
+
+// @vue/component
+const captionMixin = extend({
+  props,
+  computed: {
+    captionId() {
+      return this.isStacked ? this.safeId('_caption_') : null;
+    }
+  },
+  methods: {
+    renderCaption() {
+      const {
+        caption,
+        captionHtml
+      } = this;
+      const h = this.$createElement;
+      let $caption = h();
+      const hasCaptionSlot = this.hasNormalizedSlot(SLOT_NAME_TABLE_CAPTION);
+      if (hasCaptionSlot || caption || captionHtml) {
+        $caption = h('caption', {
+          attrs: {
+            id: this.captionId
+          },
+          domProps: hasCaptionSlot ? {} : htmlOrText(captionHtml, caption),
+          key: 'caption',
+          ref: 'caption'
+        }, this.normalizeSlot(SLOT_NAME_TABLE_CAPTION));
+      }
+      return $caption;
+    }
+  }
+});
+
+export { captionMixin, props };

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

@@ -0,0 +1,32 @@
+import { extend } from '../../../vue';
+import { SLOT_NAME_TABLE_COLGROUP } from '../../../constants/slots';
+
+// --- Props ---
+
+const props = {};
+
+// --- Mixin ---
+
+// @vue/component
+const colgroupMixin = extend({
+  methods: {
+    renderColgroup() {
+      const {
+        computedFields: fields
+      } = this;
+      const h = this.$createElement;
+      let $colgroup = h();
+      if (this.hasNormalizedSlot(SLOT_NAME_TABLE_COLGROUP)) {
+        $colgroup = h('colgroup', {
+          key: 'colgroup'
+        }, [this.normalizeSlot(SLOT_NAME_TABLE_COLGROUP, {
+          columns: fields.length,
+          fields
+        })]);
+      }
+      return $colgroup;
+    }
+  }
+});
+
+export { colgroupMixin, props };

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

@@ -0,0 +1,82 @@
+import { extend } from '../../../vue';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../../constants/props';
+import { SLOT_NAME_TABLE_BUSY, SLOT_NAME_EMPTYFILTERED, SLOT_NAME_EMPTY } from '../../../constants/slots';
+import { htmlOrText } from '../../../utils/html';
+import { isFunction } from '../../../utils/inspect';
+import { makeProp } from '../../../utils/props';
+import { safeVueInstance } from '../../../utils/safe-vue-instance';
+import { BTr } from '../tr';
+import { BTd } from '../td';
+
+// --- Props ---
+
+const props = {
+  emptyFilteredHtml: makeProp(PROP_TYPE_STRING),
+  emptyFilteredText: makeProp(PROP_TYPE_STRING, 'There are no records matching your request'),
+  emptyHtml: makeProp(PROP_TYPE_STRING),
+  emptyText: makeProp(PROP_TYPE_STRING, 'There are no records to show'),
+  showEmpty: makeProp(PROP_TYPE_BOOLEAN, false)
+};
+
+// --- Mixin ---
+
+// @vue/component
+const emptyMixin = extend({
+  props,
+  methods: {
+    renderEmpty() {
+      const {
+        computedItems: items,
+        computedBusy
+      } = safeVueInstance(this);
+      const h = this.$createElement;
+      let $empty = h();
+      if (this.showEmpty && (!items || items.length === 0) && !(computedBusy && this.hasNormalizedSlot(SLOT_NAME_TABLE_BUSY))) {
+        const {
+          computedFields: fields,
+          isFiltered,
+          emptyText,
+          emptyHtml,
+          emptyFilteredText,
+          emptyFilteredHtml,
+          tbodyTrClass,
+          tbodyTrAttr
+        } = this;
+        $empty = this.normalizeSlot(isFiltered ? SLOT_NAME_EMPTYFILTERED : SLOT_NAME_EMPTY, {
+          emptyFilteredHtml,
+          emptyFilteredText,
+          emptyHtml,
+          emptyText,
+          fields,
+          // Not sure why this is included, as it will always be an empty array
+          items
+        });
+        if (!$empty) {
+          $empty = h('div', {
+            class: ['text-center', 'my-2'],
+            domProps: isFiltered ? htmlOrText(emptyFilteredHtml, emptyFilteredText) : htmlOrText(emptyHtml, emptyText)
+          });
+        }
+        $empty = h(BTd, {
+          props: {
+            colspan: fields.length || null
+          }
+        }, [h('div', {
+          attrs: {
+            role: 'alert',
+            'aria-live': 'polite'
+          }
+        }, [$empty])]);
+        $empty = h(BTr, {
+          staticClass: 'b-table-empty-row',
+          class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, 'row-empty') : tbodyTrClass],
+          attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, 'row-empty') : tbodyTrAttr,
+          key: isFiltered ? 'b-empty-filtered-row' : 'b-empty-row'
+        }, [$empty]);
+      }
+      return $empty;
+    }
+  }
+});
+
+export { emptyMixin, props };