@gitlab/ui 132.0.1 → 132.0.3

package/dist/vendor/bootstrap-vue/src/components/popover/helpers/bv-popover-template.js

@@ -0,0 +1,55 @@
+import { extend } from '../../../vue';
+import { NAME_POPOVER_TEMPLATE } from '../../../constants/components';
+import { isFunction, isUndefinedOrNull } from '../../../utils/inspect';
+import { BVTooltipTemplate } from '../../tooltip/helpers/bv-tooltip-template';
+
+// @vue/component
+const BVPopoverTemplate = /*#__PURE__*/extend({
+  name: NAME_POPOVER_TEMPLATE,
+  extends: BVTooltipTemplate,
+  computed: {
+    templateType() {
+      return 'popover';
+    }
+  },
+  methods: {
+    renderTemplate(h) {
+      const {
+        title,
+        content
+      } = this;
+
+      // Title and content could be a scoped slot function
+      const $title = isFunction(title) ? title({}) : title;
+      const $content = isFunction(content) ? content({}) : content;
+
+      // Directive usage only
+      const titleDomProps = this.html && !isFunction(title) ? {
+        innerHTML: title
+      } : {};
+      const contentDomProps = this.html && !isFunction(content) ? {
+        innerHTML: content
+      } : {};
+      return h('div', {
+        staticClass: 'popover b-popover',
+        class: this.templateClasses,
+        attrs: this.templateAttributes,
+        on: this.templateListeners
+      }, [h('div', {
+        staticClass: 'arrow',
+        ref: 'arrow'
+      }), isUndefinedOrNull($title) || $title === '' ? /* istanbul ignore next */h() : h('h3', {
+        staticClass: 'popover-header',
+        domProps: titleDomProps,
+        attrs: {
+          role: 'presentation'
+        }
+      }, [$title]), isUndefinedOrNull($content) || $content === '' ? /* istanbul ignore next */h() : h('div', {
+        staticClass: 'popover-body',
+        domProps: contentDomProps
+      }, [$content])]);
+    }
+  }
+});
+
+export { BVPopoverTemplate };

package/dist/vendor/bootstrap-vue/src/components/popover/helpers/bv-popover.js

@@ -0,0 +1,31 @@
+import { extend } from '../../../vue';
+import { NAME_POPOVER_HELPER } from '../../../constants/components';
+import { BVTooltip } from '../../tooltip/helpers/bv-tooltip';
+import { BVPopoverTemplate } from './bv-popover-template';
+
+// Popover "Class" (Built as a renderless Vue instance)
+// Inherits from BVTooltip
+//
+// Handles trigger events, etc.
+// Instantiates template on demand
+
+
+// @vue/component
+const BVPopover = /*#__PURE__*/extend({
+  name: NAME_POPOVER_HELPER,
+  extends: BVTooltip,
+  computed: {
+    // Overwrites BVTooltip
+    templateType() {
+      return 'popover';
+    }
+  },
+  methods: {
+    getTemplate() {
+      // Overwrites BVTooltip
+      return BVPopoverTemplate;
+    }
+  }
+});
+
+export { BVPopover };

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

@@ -0,0 +1 @@
+export { BPopover } from './popover';

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

@@ -0,0 +1,64 @@
+import { extend } from '../../vue';
+import { NAME_POPOVER } from '../../constants/components';
+import { EVENT_NAME_CLICK } from '../../constants/events';
+import { PROP_TYPE_STRING, PROP_TYPE_NUMBER, PROP_TYPE_OBJECT, PROP_TYPE_ARRAY } from '../../constants/props';
+import { SLOT_NAME_TITLE } from '../../constants/slots';
+import { props as props$1, BTooltip } from '../tooltip/tooltip';
+import { BVPopover } from './helpers/bv-popover';
+import { sortKeys } from '../../utils/object';
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  content: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  delay: {
+    type: [PROP_TYPE_NUMBER, PROP_TYPE_OBJECT, PROP_TYPE_STRING],
+    required: false,
+    default: () => ({
+      show: 50,
+      hide: 150
+    })
+  },
+  placement: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'right'
+  },
+  triggers: {
+    type: [PROP_TYPE_ARRAY, PROP_TYPE_STRING],
+    required: false,
+    default: EVENT_NAME_CLICK
+  }
+});
+
+// --- Main component ---
+
+// @vue/component
+const BPopover = /*#__PURE__*/extend({
+  name: NAME_POPOVER,
+  extends: BTooltip,
+  inheritAttrs: false,
+  props,
+  methods: {
+    getComponent() {
+      // Overridden by BPopover
+      return BVPopover;
+    },
+    updateContent() {
+      // Tooltip: Default slot is `title`
+      // Popover: Default slot is `content`, `title` slot is title
+      // We pass a scoped slot function references by default (Vue v2.6x)
+      // And pass the title prop as a fallback
+      this.setContent(this.normalizeSlot() || this.content);
+      this.setTitle(this.normalizeSlot(SLOT_NAME_TITLE) || this.title);
+    }
+  }
+  // Render function provided by BTooltip
+});
+
+export { BPopover, 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,86 @@
+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 { 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]: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: 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,57 @@
+import { extend } from '../../../vue';
+import { PROP_TYPE_STRING } from '../../../constants/props';
+import { SLOT_NAME_TABLE_CAPTION } from '../../../constants/slots';
+import { htmlOrText } from '../../../utils/html';
+
+// --- Props ---
+
+const props = {
+  caption: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  captionHtml: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  }
+  // `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,101 @@
+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 { safeVueInstance } from '../../../utils/safe-vue-instance';
+import { BTr } from '../tr';
+import { BTd } from '../td';
+
+// --- Props ---
+
+const props = {
+  emptyFilteredHtml: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  emptyFilteredText: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'There are no records matching your request'
+  },
+  emptyHtml: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  emptyText: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'There are no records to show'
+  },
+  showEmpty: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: 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: ['gl-text-center', 'gl-my-3'],
+            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 };