@gitlab/ui 132.0.1 → 132.0.2

package/dist/vendor/bootstrap-vue/src/components/form/form-text.js

@@ -0,0 +1,55 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_FORM_TEXT } from '../../constants/components';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+
+// --- Props ---
+
+const props = {
+  id: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  inline: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  tag: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'small'
+  },
+  textVariant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'muted'
+  }
+};
+
+// --- Main component ---
+
+// @vue/component
+const BFormText = /*#__PURE__*/extend({
+  name: NAME_FORM_TEXT,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    return h(props.tag, mergeData(data, {
+      class: {
+        'form-text': !props.inline,
+        [`text-${props.textVariant}`]: props.textVariant
+      },
+      attrs: {
+        id: props.id
+      }
+    }), children);
+  }
+});
+
+export { BFormText, props };

package/dist/vendor/bootstrap-vue/src/components/form/form-valid-feedback.js

@@ -0,0 +1,53 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_FORM_VALID_FEEDBACK } from '../../constants/components';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+import { makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = {
+  ariaLive: makeProp(PROP_TYPE_STRING),
+  forceShow: makeProp(PROP_TYPE_BOOLEAN, false),
+  id: makeProp(PROP_TYPE_STRING),
+  role: makeProp(PROP_TYPE_STRING),
+  // Tri-state prop: `true`, `false`, or `null`
+  state: makeProp(PROP_TYPE_BOOLEAN, null),
+  tag: makeProp(PROP_TYPE_STRING, 'div'),
+  tooltip: makeProp(PROP_TYPE_BOOLEAN, false)
+};
+
+// --- Main component ---
+
+// @vue/component
+const BFormValidFeedback = /*#__PURE__*/extend({
+  name: NAME_FORM_VALID_FEEDBACK,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      tooltip,
+      ariaLive
+    } = props;
+    const show = props.forceShow === true || props.state === true;
+    return h(props.tag, mergeData(data, {
+      class: {
+        '!gl-block': show,
+        'valid-feedback': !tooltip,
+        'valid-tooltip': tooltip
+      },
+      attrs: {
+        id: props.id || null,
+        role: props.role || null,
+        'aria-live': ariaLive || null,
+        'aria-atomic': ariaLive ? 'true' : null
+      }
+    }), children);
+  }
+});
+
+export { BFormValidFeedback, props };

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

@@ -0,0 +1,56 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_FORM } from '../../constants/components';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+
+// --- Props ---
+
+const props = {
+  id: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  inline: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  novalidate: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  validated: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  }
+};
+
+// --- Main component ---
+
+// @vue/component
+const BForm = /*#__PURE__*/extend({
+  name: NAME_FORM,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    return h('form', mergeData(data, {
+      class: {
+        'form-inline': props.inline,
+        'was-validated': props.validated
+      },
+      attrs: {
+        id: props.id,
+        novalidate: props.novalidate
+      }
+    }), children);
+  }
+});
+
+export { BForm, props };

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

@@ -0,0 +1,4 @@
+export { BForm } from './form';
+export { BFormText } from './form-text';
+export { BFormInvalidFeedback } from './form-invalid-feedback';
+export { BFormValidFeedback } from './form-valid-feedback';

package/dist/vendor/bootstrap-vue/src/components/form-group/form-group.js

@@ -0,0 +1,347 @@
+import { NAME_FORM_GROUP } from '../../constants/components';
+import { IS_BROWSER } from '../../constants/env';
+import { PROP_TYPE_BOOLEAN_NUMBER_STRING, PROP_TYPE_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_ARRAY_OBJECT_STRING } from '../../constants/props';
+import { RX_SPACE_SPLIT } from '../../constants/regex';
+import { SLOT_NAME_LABEL, SLOT_NAME_INVALID_FEEDBACK, SLOT_NAME_VALID_FEEDBACK, SLOT_NAME_DESCRIPTION, SLOT_NAME_DEFAULT } from '../../constants/slots';
+import { getBreakpointsUpCached } from '../../utils/config';
+import { cssEscape } from '../../utils/css-escape';
+import { select, getAttr, setAttr, removeAttr, selectAll, isVisible, attemptFocus } from '../../utils/dom';
+import { identity } from '../../utils/identity';
+import { isBoolean } from '../../utils/inspect';
+import { toInteger } from '../../utils/number';
+import { sortKeys, create, keys } from '../../utils/object';
+import { suffixPropName, makeProp } from '../../utils/props';
+import { props as props$1, formStateMixin } from '../../mixins/form-state';
+import { props, idMixin } from '../../mixins/id';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { BCol } from '../layout/col';
+import { BFormRow } from '../layout/form-row';
+import { BFormText } from '../form/form-text';
+import { BFormInvalidFeedback } from '../form/form-invalid-feedback';
+import { BFormValidFeedback } from '../form/form-valid-feedback';
+
+// --- Constants ---
+
+const INPUTS = ['input', 'select', 'textarea'];
+
+// Selector for finding first input in the form group
+const INPUT_SELECTOR = INPUTS.map(v => `${v}:not([disabled])`).join();
+
+// A list of interactive elements (tag names) inside `<b-form-group>`'s legend
+const LEGEND_INTERACTIVE_ELEMENTS = [...INPUTS, 'a', 'button', 'label'];
+
+// --- Props ---
+
+// Prop generator for lazy generation of props
+const generateProps = () => sortKeys({
+  ...props,
+  ...props$1,
+  ...getBreakpointsUpCached().reduce((props, breakpoint) => {
+    // i.e. 'content-cols', 'content-cols-sm', 'content-cols-md', ...
+    props[suffixPropName(breakpoint, 'contentCols')] = makeProp(PROP_TYPE_BOOLEAN_NUMBER_STRING);
+    // i.e. 'label-align', 'label-align-sm', 'label-align-md', ...
+    props[suffixPropName(breakpoint, 'labelAlign')] = makeProp(PROP_TYPE_STRING);
+    // i.e. 'label-cols', 'label-cols-sm', 'label-cols-md', ...
+    props[suffixPropName(breakpoint, 'labelCols')] = makeProp(PROP_TYPE_BOOLEAN_NUMBER_STRING);
+    return props;
+  }, create(null)),
+  description: makeProp(PROP_TYPE_STRING),
+  disabled: makeProp(PROP_TYPE_BOOLEAN, false),
+  feedbackAriaLive: makeProp(PROP_TYPE_STRING, 'assertive'),
+  invalidFeedback: makeProp(PROP_TYPE_STRING),
+  label: makeProp(PROP_TYPE_STRING),
+  labelClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),
+  labelFor: makeProp(PROP_TYPE_STRING),
+  labelId: makeProp(PROP_TYPE_STRING),
+  labelSize: makeProp(PROP_TYPE_STRING),
+  labelSrOnly: makeProp(PROP_TYPE_BOOLEAN, false),
+  tooltip: makeProp(PROP_TYPE_BOOLEAN, false),
+  validFeedback: makeProp(PROP_TYPE_STRING),
+  validated: makeProp(PROP_TYPE_BOOLEAN, false)
+});
+
+// --- Main component ---
+
+// We do not use `extend()` here as that would evaluate the props
+// immediately, which we do not want to happen
+// @vue/component
+const BFormGroup = {
+  name: NAME_FORM_GROUP,
+  mixins: [idMixin, formStateMixin, normalizeSlotMixin],
+  get props() {
+    // Allow props to be lazy evaled on first access and
+    // then they become a non-getter afterwards
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#Smart_self-overwriting_lazy_getters
+    delete this.props;
+    // eslint-disable-next-line no-return-assign
+    return this.props = generateProps();
+  },
+  data() {
+    return {
+      ariaDescribedby: null
+    };
+  },
+  computed: {
+    contentColProps() {
+      return this.getColProps(this.$props, 'content');
+    },
+    labelAlignClasses() {
+      return this.getAlignClasses(this.$props, 'label');
+    },
+    labelColProps() {
+      return this.getColProps(this.$props, 'label');
+    },
+    isHorizontal() {
+      // Determine if the form group will be rendered horizontal
+      // based on the existence of 'content-col' or 'label-col' props
+      return keys(this.contentColProps).length > 0 || keys(this.labelColProps).length > 0;
+    }
+  },
+  watch: {
+    ariaDescribedby(newValue, oldValue) {
+      if (newValue !== oldValue) {
+        this.updateAriaDescribedby(newValue, oldValue);
+      }
+    }
+  },
+  mounted() {
+    this.$nextTick(() => {
+      // Set `aria-describedby` on the input specified by `labelFor`
+      // We do this in a `$nextTick()` to ensure the children have finished rendering
+      this.updateAriaDescribedby(this.ariaDescribedby);
+    });
+  },
+  methods: {
+    getAlignClasses(props, prefix) {
+      return getBreakpointsUpCached().reduce((result, breakpoint) => {
+        const propValue = props[suffixPropName(breakpoint, `${prefix}Align`)] || null;
+        if (propValue) {
+          result.push(['text', breakpoint, propValue].filter(identity).join('-'));
+        }
+        return result;
+      }, []);
+    },
+    getColProps(props, prefix) {
+      return getBreakpointsUpCached().reduce((result, breakpoint) => {
+        let propValue = props[suffixPropName(breakpoint, `${prefix}Cols`)];
+
+        // Handle case where the prop's value is an empty string,
+        // which represents `true`
+        propValue = propValue === '' ? true : propValue || false;
+        if (!isBoolean(propValue) && propValue !== 'auto') {
+          // Convert to column size to number
+          propValue = toInteger(propValue, 0);
+          // Ensure column size is greater than `0`
+          propValue = propValue > 0 ? propValue : false;
+        }
+
+        // Add the prop to the list of props to give to `<b-col>`
+        // If breakpoint is '' (`${prefix}Cols` is `true`), then we use
+        // the 'col' prop to make equal width at 'xs'
+        if (propValue) {
+          result[breakpoint || (isBoolean(propValue) ? 'col' : 'cols')] = propValue;
+        }
+        return result;
+      }, {});
+    },
+    // Sets the `aria-describedby` attribute on the input if `labelFor` is set
+    // Optionally accepts a string of IDs to remove as the second parameter
+    // Preserves any `aria-describedby` value(s) user may have on input
+    updateAriaDescribedby(newValue, oldValue) {
+      const {
+        labelFor
+      } = this;
+      if (IS_BROWSER && labelFor) {
+        // We need to escape `labelFor` since it can be user-provided
+        const $input = select(`#${cssEscape(labelFor)}`, this.$refs.content);
+        if ($input) {
+          const attr = 'aria-describedby';
+          const newIds = (newValue || '').split(RX_SPACE_SPLIT);
+          const oldIds = (oldValue || '').split(RX_SPACE_SPLIT);
+
+          // Update ID list, preserving any original IDs
+          // and ensuring the ID's are unique
+          const ids = (getAttr($input, attr) || '').split(RX_SPACE_SPLIT).filter(id => !oldIds.includes(id)).concat(newIds).filter((id, index, ids) => ids.indexOf(id) === index).filter(identity).join(' ').trim();
+          if (ids) {
+            setAttr($input, attr, ids);
+          } else {
+            removeAttr($input, attr);
+          }
+        }
+      }
+    },
+    onLegendClick(event) {
+      // Don't do anything if `labelFor` is set
+      /* istanbul ignore next: clicking a label will focus the input, so no need to test */
+      if (this.labelFor) {
+        return;
+      }
+      const {
+        target
+      } = event;
+      const tagName = target ? target.tagName : '';
+
+      // If clicked an interactive element inside legend,
+      // we just let the default happen
+      /* istanbul ignore next */
+      if (LEGEND_INTERACTIVE_ELEMENTS.indexOf(tagName) !== -1) {
+        return;
+      }
+
+      // If only a single input, focus it, emulating label behaviour
+      const inputs = selectAll(INPUT_SELECTOR, this.$refs.content).filter(isVisible);
+      if (inputs.length === 1) {
+        attemptFocus(inputs[0]);
+      }
+    }
+  },
+  render(h) {
+    const {
+      computedState: state,
+      feedbackAriaLive,
+      isHorizontal,
+      labelFor,
+      normalizeSlot,
+      safeId,
+      tooltip
+    } = this;
+    const id = safeId();
+    const isFieldset = !labelFor;
+    let $label = h();
+    const labelContent = normalizeSlot(SLOT_NAME_LABEL) || this.label;
+    const labelId = labelContent ? this.labelId || safeId('_BV_label_') : null;
+    if (labelContent || isHorizontal) {
+      const {
+        labelSize,
+        labelColProps
+      } = this;
+      const labelTag = isFieldset ? 'legend' : 'label';
+      if (this.labelSrOnly) {
+        if (labelContent) {
+          $label = h(labelTag, {
+            class: 'gl-sr-only',
+            attrs: {
+              id: labelId,
+              for: labelFor || null
+            }
+          }, [labelContent]);
+        }
+        $label = h(isHorizontal ? BCol : 'div', {
+          props: isHorizontal ? labelColProps : {}
+        }, [$label]);
+      } else {
+        $label = h(isHorizontal ? BCol : labelTag, {
+          on: isFieldset ? {
+            click: this.onLegendClick
+          } : {},
+          props: isHorizontal ? {
+            ...labelColProps,
+            tag: labelTag
+          } : {},
+          attrs: {
+            id: labelId,
+            for: labelFor || null,
+            // We add a `tabindex` to legend so that screen readers
+            // will properly read the `aria-labelledby` in IE
+            tabindex: isFieldset ? '-1' : null
+          },
+          class: [
+          // Hide the focus ring on the legend
+          isFieldset ? 'bv-no-focus-ring' : '',
+          // When horizontal or if a legend is rendered, add 'col-form-label' class
+          // for correct sizing as Bootstrap has inconsistent font styling for
+          // legend in non-horizontal form groups
+          // See: https://github.com/twbs/bootstrap/issues/27805
+          isHorizontal || isFieldset ? 'col-form-label' : '',
+          // Emulate label padding top of `0` on legend when not horizontal
+          !isHorizontal && isFieldset ? '!gl-pt-0' : '',
+          // If not horizontal and not a legend, we add '!gl-block' class to label
+          // so that label-align works
+          !isHorizontal && !isFieldset ? '!gl-block' : '', labelSize ? `col-form-label-${labelSize}` : '', this.labelAlignClasses, this.labelClass]
+        }, [labelContent]);
+      }
+    }
+    let $invalidFeedback = h();
+    const invalidFeedbackContent = normalizeSlot(SLOT_NAME_INVALID_FEEDBACK) || this.invalidFeedback;
+    const invalidFeedbackId = invalidFeedbackContent ? safeId('_BV_feedback_invalid_') : null;
+    if (invalidFeedbackContent) {
+      $invalidFeedback = h(BFormInvalidFeedback, {
+        props: {
+          ariaLive: feedbackAriaLive,
+          id: invalidFeedbackId,
+          // If state is explicitly `false`, always show the feedback
+          state,
+          tooltip
+        },
+        attrs: {
+          tabindex: invalidFeedbackContent ? '-1' : null
+        }
+      }, [invalidFeedbackContent]);
+    }
+    let $validFeedback = h();
+    const validFeedbackContent = normalizeSlot(SLOT_NAME_VALID_FEEDBACK) || this.validFeedback;
+    const validFeedbackId = validFeedbackContent ? safeId('_BV_feedback_valid_') : null;
+    if (validFeedbackContent) {
+      $validFeedback = h(BFormValidFeedback, {
+        props: {
+          ariaLive: feedbackAriaLive,
+          id: validFeedbackId,
+          // If state is explicitly `true`, always show the feedback
+          state,
+          tooltip
+        },
+        attrs: {
+          tabindex: validFeedbackContent ? '-1' : null
+        }
+      }, [validFeedbackContent]);
+    }
+    let $description = h();
+    const descriptionContent = normalizeSlot(SLOT_NAME_DESCRIPTION) || this.description;
+    const descriptionId = descriptionContent ? safeId('_BV_description_') : null;
+    if (descriptionContent) {
+      $description = h(BFormText, {
+        attrs: {
+          id: descriptionId,
+          tabindex: '-1'
+        }
+      }, [descriptionContent]);
+    }
+
+    // Update `ariaDescribedby`
+    // Screen readers will read out any content linked to by `aria-describedby`
+    // even if the content is hidden with `display: none;`, hence we only include
+    // feedback IDs if the form group's state is explicitly valid or invalid
+    const ariaDescribedby = this.ariaDescribedby = [descriptionId, state === false ? invalidFeedbackId : null, state === true ? validFeedbackId : null].filter(identity).join(' ') || null;
+    const $content = h(isHorizontal ? BCol : 'div', {
+      props: isHorizontal ? this.contentColProps : {},
+      ref: 'content'
+    }, [normalizeSlot(SLOT_NAME_DEFAULT, {
+      ariaDescribedby,
+      descriptionId,
+      id,
+      labelId
+    }) || h(), $invalidFeedback, $validFeedback, $description]);
+
+    // Return it wrapped in a form group
+    // Note: Fieldsets do not support adding `row` or `form-row` directly
+    // to them due to browser specific render issues, so we move the `form-row`
+    // to an inner wrapper div when horizontal and using a fieldset
+    return h(isFieldset ? 'fieldset' : isHorizontal ? BFormRow : 'div', {
+      staticClass: 'form-group',
+      class: [{
+        'was-validated': this.validated
+      }, this.stateClass],
+      attrs: {
+        id,
+        disabled: isFieldset ? this.disabled : null,
+        role: isFieldset ? null : 'group',
+        'aria-invalid': this.computedAriaInvalid,
+        // Only apply `aria-labelledby` if we are a horizontal fieldset
+        // as the legend is no longer a direct child of fieldset
+        'aria-labelledby': isFieldset && isHorizontal ? labelId : null
+      }
+    }, isHorizontal && isFieldset ? [h(BFormRow, [$label, $content])] : [$label, $content]);
+  }
+};
+
+export { BFormGroup, generateProps };

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

@@ -0,0 +1 @@
+export { BFormGroup } from './form-group';

package/dist/vendor/bootstrap-vue/src/components/form-select/form-select-option-group.js

@@ -0,0 +1,54 @@
+import { extend } from '../../vue';
+import { NAME_FORM_SELECT_OPTION_GROUP } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { SLOT_NAME_FIRST } from '../../constants/slots';
+import { htmlOrText } from '../../utils/html';
+import { sortKeys } from '../../utils/object';
+import { makeProp } from '../../utils/props';
+import { props as props$1, formOptionsMixin } from '../../mixins/form-options';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { BFormSelectOption } from './form-select-option';
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  label: makeProp(PROP_TYPE_STRING, undefined, true) // Required
+});
+
+// --- Main component ---
+
+// @vue/component
+const BFormSelectOptionGroup = /*#__PURE__*/extend({
+  name: NAME_FORM_SELECT_OPTION_GROUP,
+  mixins: [normalizeSlotMixin, formOptionsMixin],
+  props,
+  render(h) {
+    const {
+      label
+    } = this;
+    const $options = this.formOptions.map((option, index) => {
+      const {
+        value,
+        text,
+        html,
+        disabled
+      } = option;
+      return h(BFormSelectOption, {
+        attrs: {
+          value,
+          disabled
+        },
+        domProps: htmlOrText(html, text),
+        key: `option_${index}`
+      });
+    });
+    return h('optgroup', {
+      attrs: {
+        label
+      }
+    }, [this.normalizeSlot(SLOT_NAME_FIRST), $options, this.normalizeSlot()]);
+  }
+});
+
+export { BFormSelectOptionGroup, props };

package/dist/vendor/bootstrap-vue/src/components/form-select/form-select-option.js

@@ -0,0 +1,41 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_FORM_SELECT_OPTION } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_ANY } from '../../constants/props';
+import { makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = {
+  disabled: makeProp(PROP_TYPE_BOOLEAN, false),
+  value: makeProp(PROP_TYPE_ANY, undefined, true) // Required
+};
+
+// --- Main component ---
+
+// @vue/component
+const BFormSelectOption = /*#__PURE__*/extend({
+  name: NAME_FORM_SELECT_OPTION,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      value,
+      disabled
+    } = props;
+    return h('option', mergeData(data, {
+      attrs: {
+        disabled
+      },
+      domProps: {
+        value
+      }
+    }), children);
+  }
+});
+
+export { BFormSelectOption, props };