@gitlab/ui 131.2.0 → 131.3.1

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

@@ -1,217 +0,0 @@
-import { extend } from '../../vue';
-import { NAME_FORM_TEXTAREA } from '../../constants/components';
-import { PROP_TYPE_NUMBER_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../constants/props';
-import { requestAF, isVisible, getCS, getStyle, setStyle } from '../../utils/dom';
-import { isNull } from '../../utils/inspect';
-import { mathMax, mathMin, mathCeil } from '../../utils/math';
-import { toInteger, toFloat } from '../../utils/number';
-import { sortKeys } from '../../utils/object';
-import { makeProp } from '../../utils/props';
-import { props as props$2, formControlMixin } from '../../mixins/form-control';
-import { formSelectionMixin } from '../../mixins/form-selection';
-import { props as props$3, formSizeMixin } from '../../mixins/form-size';
-import { props as props$4, formStateMixin } from '../../mixins/form-state';
-import { props as props$5, formTextMixin } from '../../mixins/form-text';
-import { formValidityMixin } from '../../mixins/form-validity';
-import { props as props$1, idMixin } from '../../mixins/id';
-import { listenOnRootMixin } from '../../mixins/listen-on-root';
-import { listenersMixin } from '../../mixins/listeners';
-import { VBVisible } from '../../directives/visible/visible';
-
-// --- Props ---
-
-const props = sortKeys({
-  ...props$1,
-  ...props$2,
-  ...props$3,
-  ...props$4,
-  ...props$5,
-  maxRows: makeProp(PROP_TYPE_NUMBER_STRING),
-  // When in auto resize mode, disable shrinking to content height
-  noAutoShrink: makeProp(PROP_TYPE_BOOLEAN, false),
-  // Disable the resize handle of textarea
-  noResize: makeProp(PROP_TYPE_BOOLEAN, false),
-  rows: makeProp(PROP_TYPE_NUMBER_STRING, 2),
-  // 'soft', 'hard' or 'off'
-  // Browser default is 'soft'
-  wrap: makeProp(PROP_TYPE_STRING, 'soft')
-});
-
-// --- Main component ---
-
-// @vue/component
-const BFormTextarea = /*#__PURE__*/extend({
-  name: NAME_FORM_TEXTAREA,
-  directives: {
-    'b-visible': VBVisible
-  },
-  // Mixin order is important!
-  mixins: [listenersMixin, idMixin, listenOnRootMixin, formControlMixin, formSizeMixin, formStateMixin, formTextMixin, formSelectionMixin, formValidityMixin],
-  props,
-  data() {
-    return {
-      heightInPx: null
-    };
-  },
-  computed: {
-    type() {
-      return null;
-    },
-    computedStyle() {
-      const styles = {
-        // Setting `noResize` to true will disable the ability for the user to
-        // manually resize the textarea. We also disable when in auto height mode
-        resize: !this.computedRows || this.noResize ? 'none' : null
-      };
-      if (!this.computedRows) {
-        // Conditionally set the computed CSS height when auto rows/height is enabled
-        // We avoid setting the style to `null`, which can override user manual resize handle
-        styles.height = this.heightInPx;
-        // We always add a vertical scrollbar to the textarea when auto-height is
-        // enabled so that the computed height calculation returns a stable value
-        styles.overflowY = 'scroll';
-      }
-      return styles;
-    },
-    computedMinRows() {
-      // Ensure rows is at least 2 and positive (2 is the native textarea value)
-      // A value of 1 can cause issues in some browsers, and most browsers
-      // only support 2 as the smallest value
-      return mathMax(toInteger(this.rows, 2), 2);
-    },
-    computedMaxRows() {
-      return mathMax(this.computedMinRows, toInteger(this.maxRows, 0));
-    },
-    computedRows() {
-      // This is used to set the attribute 'rows' on the textarea
-      // If auto-height is enabled, then we return `null` as we use CSS to control height
-      return this.computedMinRows === this.computedMaxRows ? this.computedMinRows : null;
-    },
-    computedAttrs() {
-      const {
-        disabled,
-        required
-      } = this;
-      return {
-        id: this.safeId(),
-        name: this.name || null,
-        form: this.form || null,
-        disabled,
-        placeholder: this.placeholder || null,
-        required,
-        autocomplete: this.autocomplete || null,
-        readonly: this.readonly || this.plaintext,
-        rows: this.computedRows,
-        wrap: this.wrap || null,
-        'aria-required': this.required ? 'true' : null,
-        'aria-invalid': this.computedAriaInvalid
-      };
-    },
-    computedListeners() {
-      return {
-        ...this.bvListeners,
-        input: this.onInput,
-        change: this.onChange,
-        blur: this.onBlur
-      };
-    }
-  },
-  watch: {
-    localValue() {
-      this.setHeight();
-    }
-  },
-  mounted() {
-    this.setHeight();
-  },
-  methods: {
-    // Called by intersection observer directive
-    /* istanbul ignore next */
-    visibleCallback(visible) {
-      if (visible) {
-        // We use a `$nextTick()` here just to make sure any
-        // transitions or portalling have completed
-        this.$nextTick(this.setHeight);
-      }
-    },
-    setHeight() {
-      this.$nextTick(() => {
-        requestAF(() => {
-          this.heightInPx = this.computeHeight();
-        });
-      });
-    },
-    /* istanbul ignore next: can't test getComputedStyle in JSDOM */
-    computeHeight() {
-      if (this.$isServer || !isNull(this.computedRows)) {
-        return null;
-      }
-      const el = this.$el;
-
-      // Element must be visible (not hidden) and in document
-      // Must be checked after above checks
-      if (!isVisible(el)) {
-        return null;
-      }
-
-      // Get current computed styles
-      const computedStyle = getCS(el);
-      // Height of one line of text in px
-      const lineHeight = toFloat(computedStyle.lineHeight, 1);
-      // Calculate height of border and padding
-      const border = toFloat(computedStyle.borderTopWidth, 0) + toFloat(computedStyle.borderBottomWidth, 0);
-      const padding = toFloat(computedStyle.paddingTop, 0) + toFloat(computedStyle.paddingBottom, 0);
-      // Calculate offset
-      const offset = border + padding;
-      // Minimum height for min rows (which must be 2 rows or greater for cross-browser support)
-      const minHeight = lineHeight * this.computedMinRows + offset;
-
-      // Get the current style height (with `px` units)
-      const oldHeight = getStyle(el, 'height') || computedStyle.height;
-      // Probe scrollHeight by temporarily changing the height to `auto`
-      setStyle(el, 'height', 'auto');
-      const scrollHeight = el.scrollHeight;
-      // Place the original old height back on the element, just in case `computedProp`
-      // returns the same value as before
-      setStyle(el, 'height', oldHeight);
-
-      // Calculate content height in 'rows' (scrollHeight includes padding but not border)
-      const contentRows = mathMax((scrollHeight - padding) / lineHeight, 2);
-      // Calculate number of rows to display (limited within min/max rows)
-      const rows = mathMin(mathMax(contentRows, this.computedMinRows), this.computedMaxRows);
-      // Calculate the required height of the textarea including border and padding (in pixels)
-      const height = mathMax(mathCeil(rows * lineHeight + offset), minHeight);
-
-      // Computed height remains the larger of `oldHeight` and new `height`,
-      // when height is in `sticky` mode (prop `no-auto-shrink` is true)
-      if (this.noAutoShrink && toFloat(oldHeight, 0) > height) {
-        return oldHeight;
-      }
-
-      // Return the new computed CSS height in px units
-      return `${height}px`;
-    }
-  },
-  render(h) {
-    return h('textarea', {
-      class: this.computedClass,
-      style: this.computedStyle,
-      directives: [{
-        name: 'b-visible',
-        value: this.visibleCallback,
-        // If textarea is within 640px of viewport, consider it visible
-        modifiers: {
-          '640': true
-        }
-      }],
-      attrs: this.computedAttrs,
-      domProps: {
-        value: this.localValue
-      },
-      on: this.computedListeners,
-      ref: 'input'
-    });
-  }
-});
-
-export { BFormTextarea, props };

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

@@ -1 +0,0 @@
-export { BFormTextarea } from './form-textarea';

package/dist/vendor/bootstrap-vue/src/components/layout/col.js

@@ -1,156 +0,0 @@
-import { mergeData } from '../../vue';
-import { NAME_COL } from '../../constants/components';
-import { PROP_TYPE_BOOLEAN_NUMBER_STRING, PROP_TYPE_NUMBER_STRING, PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
-import { RX_COL_CLASS } from '../../constants/regex';
-import { arrayIncludes } from '../../utils/array';
-import { getBreakpointsUpCached } from '../../utils/config';
-import { identity } from '../../utils/identity';
-import { isUndefinedOrNull } from '../../utils/inspect';
-import { memoize } from '../../utils/memoize';
-import { create, assign, keys, sortKeys } from '../../utils/object';
-import { makeProp, suffixPropName } from '../../utils/props';
-import { lowerCase } from '../../utils/string';
-
-// --- Constants ---
-
-const ALIGN_SELF_VALUES = ['auto', 'start', 'end', 'center', 'baseline', 'stretch'];
-
-// --- Helper methods ---
-
-// Compute a breakpoint class name
-const computeBreakpoint = (type, breakpoint, value) => {
-  let className = type;
-  if (isUndefinedOrNull(value) || value === false) {
-    return undefined;
-  }
-  if (breakpoint) {
-    className += `-${breakpoint}`;
-  }
-  // Handling the boolean style prop when accepting `[Boolean, String, Number]`
-  // means Vue will not convert `<b-col sm></b-col>` to `sm: true` for us
-  // Since the default is `false`, '' indicates the prop's presence
-  if (type === 'col' && (value === '' || value === true)) {
-    // .col-md
-    return lowerCase(className);
-  }
-  // .order-md-6
-  className += `-${value}`;
-  return lowerCase(className);
-};
-
-// Memoized function for better performance on generating class names
-const computeBreakpointClass = memoize(computeBreakpoint);
-
-// Cached copy of the breakpoint prop names
-let breakpointPropMap = create(null);
-
-// --- Props ---
-
-// Prop generator for lazy generation of props
-const generateProps = () => {
-  // Grab the breakpoints from the cached config (exclude the '' (xs) breakpoint)
-  const breakpoints = getBreakpointsUpCached().filter(identity);
-
-  // i.e. 'col-sm', 'col-md-6', 'col-lg-auto', ...
-  const breakpointCol = breakpoints.reduce((props, breakpoint) => {
-    props[breakpoint] = makeProp(PROP_TYPE_BOOLEAN_NUMBER_STRING);
-    return props;
-  }, create(null));
-
-  // i.e. 'offset-md-1', 'offset-lg-12', ...
-  const breakpointOffset = breakpoints.reduce((props, breakpoint) => {
-    props[suffixPropName(breakpoint, 'offset')] = makeProp(PROP_TYPE_NUMBER_STRING);
-    return props;
-  }, create(null));
-
-  // i.e. 'order-md-1', 'order-lg-12', ...
-  const breakpointOrder = breakpoints.reduce((props, breakpoint) => {
-    props[suffixPropName(breakpoint, 'order')] = makeProp(PROP_TYPE_NUMBER_STRING);
-    return props;
-  }, create(null));
-
-  // For loop doesn't need to check `.hasOwnProperty()`
-  // when using an object created from `null`
-  breakpointPropMap = assign(create(null), {
-    col: keys(breakpointCol),
-    offset: keys(breakpointOffset),
-    order: keys(breakpointOrder)
-  });
-
-  // Return the generated props
-  return sortKeys({
-    ...breakpointCol,
-    ...breakpointOffset,
-    ...breakpointOrder,
-    // Flex alignment
-    alignSelf: makeProp(PROP_TYPE_STRING, null, value => {
-      return arrayIncludes(ALIGN_SELF_VALUES, value);
-    }),
-    // Generic flexbox 'col' (xs)
-    col: makeProp(PROP_TYPE_BOOLEAN, false),
-    // i.e. 'col-1', 'col-2', 'col-auto', ...
-    cols: makeProp(PROP_TYPE_NUMBER_STRING),
-    offset: makeProp(PROP_TYPE_NUMBER_STRING),
-    order: makeProp(PROP_TYPE_NUMBER_STRING),
-    tag: makeProp(PROP_TYPE_STRING, 'div')
-  });
-};
-
-// --- 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 BCol = {
-  name: NAME_COL,
-  functional: true,
-  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();
-  },
-  render(h, _ref) {
-    let {
-      props,
-      data,
-      children
-    } = _ref;
-    const {
-      cols,
-      offset,
-      order,
-      alignSelf
-    } = props;
-    const classList = [];
-    // Loop through `col`, `offset`, `order` breakpoint props
-    for (const type in breakpointPropMap) {
-      // Returns colSm, offset, offsetSm, orderMd, etc.
-      const keys = breakpointPropMap[type];
-      for (let i = 0; i < keys.length; i++) {
-        // computeBreakpoint(col, colSm => Sm, value=[String, Number, Boolean])
-        const c = computeBreakpointClass(type, keys[i].replace(type, ''), props[keys[i]]);
-        // If a class is returned, push it onto the array.
-        if (c) {
-          classList.push(c);
-        }
-      }
-    }
-    const hasColClasses = classList.some(className => RX_COL_CLASS.test(className));
-    classList.push({
-      // Default to .col if no other col-{bp}-* classes generated nor `cols` specified.
-      col: props.col || !hasColClasses && !cols,
-      [`col-${cols}`]: cols,
-      [`offset-${offset}`]: offset,
-      [`order-${order}`]: order,
-      [`align-self-${alignSelf}`]: alignSelf
-    });
-    return h(props.tag, mergeData(data, {
-      class: classList
-    }), children);
-  }
-};
-
-export { BCol, generateProps };

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

@@ -1,31 +0,0 @@
-import { extend, mergeData } from '../../vue';
-import { NAME_FORM_ROW } from '../../constants/components';
-import { PROP_TYPE_STRING } from '../../constants/props';
-import { makeProp } from '../../utils/props';
-
-// --- Props ---
-
-const props = {
-  tag: makeProp(PROP_TYPE_STRING, 'div')
-};
-
-// --- Main component ---
-
-// @vue/component
-const BFormRow = /*#__PURE__*/extend({
-  name: NAME_FORM_ROW,
-  functional: true,
-  props,
-  render(h, _ref) {
-    let {
-      props,
-      data,
-      children
-    } = _ref;
-    return h(props.tag, mergeData(data, {
-      staticClass: 'form-row'
-    }), children);
-  }
-});
-
-export { BFormRow, props };

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

@@ -1,2 +0,0 @@
-export { BCol } from './col';
-export { BFormRow } from './form-row';

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

@@ -1 +0,0 @@
-export { BLink } from './link';

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

@@ -1,283 +0,0 @@
-import { extend } from '../../vue';
-import { NAME_LINK } from '../../constants/components';
-import { EVENT_NAME_CLICK } from '../../constants/events';
-import { concat } from '../../utils/array';
-import { isTag, attemptFocus, attemptBlur } from '../../utils/dom';
-import { getRootEventName, stopEvent } from '../../utils/events';
-import { isBoolean, isUndefined, isEvent, isFunction } from '../../utils/inspect';
-import { pluckProps } from '../../utils/props';
-import { computeTag, isRouterLink, computeRel, computeHref } from '../../utils/router';
-import { attrsMixin } from '../../mixins/attrs';
-import { listenOnRootMixin } from '../../mixins/listen-on-root';
-import { listenersMixin } from '../../mixins/listeners';
-import { normalizeSlotMixin } from '../../mixins/normalize-slot';
-
-// --- Constants ---
-
-const ROOT_EVENT_NAME_CLICKED = getRootEventName(NAME_LINK, 'clicked');
-
-// --- Props ---
-
-const props = {
-  active: {
-    type: Boolean,
-    default: false
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  },
-  href: {
-    type: String,
-    default: undefined
-  },
-  // Must be `null` if no value provided
-  rel: {
-    type: String,
-    default: null
-  },
-  // To support 3rd party router links based on `<router-link>` (i.e. `g-link` for Gridsome)
-  // Default is to auto choose between `<router-link>` and `<nuxt-link>`
-  // Gridsome doesn't provide a mechanism to auto detect and has caveats
-  // such as not supporting FQDN URLs or hash only URLs
-  routerComponentName: {
-    type: String,
-    default: undefined
-  },
-  target: {
-    type: String,
-    default: '_self'
-  },
-  activeClass: {
-    type: String,
-    default: undefined
-  },
-  append: {
-    type: Boolean,
-    default: false
-  },
-  event: {
-    type: [Array, String],
-    default: undefined
-  },
-  exact: {
-    type: Boolean,
-    default: false
-  },
-  exactActiveClass: {
-    type: String,
-    default: undefined
-  },
-  exactPath: {
-    type: Boolean,
-    default: false
-  },
-  exactPathActiveClass: {
-    type: String,
-    default: undefined
-  },
-  replace: {
-    type: Boolean,
-    default: false
-  },
-  routerTag: {
-    type: String,
-    default: undefined
-  },
-  to: {
-    type: [Object, String],
-    default: undefined
-  },
-  noPrefetch: {
-    type: Boolean,
-    default: false
-  },
-  // Must be `null` to fall back to the value defined in the
-  // `nuxt.config.js` configuration file for `router.prefetchLinks`
-  // We convert `null` to `undefined`, so that Nuxt.js will use the
-  // compiled default
-  // Vue treats `undefined` as default of `false` for Boolean props,
-  // so we must set it as `null` here to be a true tri-state prop
-  prefetch: {
-    type: Boolean,
-    default: null
-  }
-};
-
-// --- Main component ---
-
-// @vue/component
-const BLink = /*#__PURE__*/extend({
-  name: NAME_LINK,
-  // Mixin order is important!
-  mixins: [attrsMixin, listenersMixin, listenOnRootMixin, normalizeSlotMixin],
-  inheritAttrs: false,
-  props,
-  computed: {
-    computedTag() {
-      // We don't pass `this` as the first arg as we need reactivity of the props
-      const {
-        to,
-        disabled,
-        routerComponentName
-      } = this;
-      return computeTag({
-        to,
-        disabled,
-        routerComponentName
-      }, this);
-    },
-    isNuxtLink() {
-      return this.computedTag === 'nuxt-link';
-    },
-    isRouterLink() {
-      return isRouterLink(this.computedTag);
-    },
-    computedRel() {
-      // We don't pass `this` as the first arg as we need reactivity of the props
-      const {
-        target,
-        rel
-      } = this;
-      return computeRel({
-        target,
-        rel
-      });
-    },
-    computedHref() {
-      // We don't pass `this` as the first arg as we need reactivity of the props
-      const {
-        to,
-        href
-      } = this;
-      return computeHref({
-        to,
-        href
-      }, this.computedTag);
-    },
-    computedProps() {
-      if (!this.isRouterLink) return {};
-      const {
-        event,
-        prefetch,
-        routerTag
-      } = this;
-      const propsToPass = ['activeClass', 'append', 'exact', 'exactActiveClass', 'exactPath', 'exactPathActiveClass', 'replace', 'to'];
-      if (this.isNuxtLink) propsToPass.push('noPrefetch');
-      return {
-        ...pluckProps(propsToPass, this),
-        // Only add these props, when actually defined
-        ...(event ? {
-          event
-        } : {}),
-        ...(isBoolean(prefetch) ? {
-          prefetch
-        } : {}),
-        // Pass `router-tag` as `tag` prop
-        ...(routerTag ? {
-          tag: routerTag
-        } : {})
-      };
-    },
-    computedAttrs() {
-      const {
-        bvAttrs,
-        computedHref: href,
-        computedRel: rel,
-        disabled,
-        target,
-        routerTag,
-        isRouterLink
-      } = this;
-      return {
-        ...bvAttrs,
-        // If `href` attribute exists on `<router-link>` (even `undefined` or `null`)
-        // it fails working on SSR, so we explicitly add it here if needed
-        // (i.e. if `computedHref` is truthy)
-        ...(href ? {
-          href
-        } : {}),
-        // We don't render `rel` or `target` on non link tags when using `vue-router`
-        ...(isRouterLink && routerTag && !isTag(routerTag, 'a') ? {} : {
-          rel,
-          target
-        }),
-        tabindex: disabled ? '-1' : isUndefined(bvAttrs.tabindex) ? null : bvAttrs.tabindex,
-        'aria-disabled': disabled ? 'true' : null
-      };
-    },
-    computedListeners() {
-      return {
-        // Transfer all listeners (native) to the root element
-        ...this.bvListeners,
-        // We want to overwrite any click handler since our callback
-        // will invoke the user supplied handler(s) if `!this.disabled`
-        click: this.onClick
-      };
-    }
-  },
-  methods: {
-    onClick(event) {
-      const eventIsEvent = isEvent(event);
-      const isRouterLink = this.isRouterLink;
-      const suppliedHandler = this.bvListeners.click;
-      if (eventIsEvent && this.disabled) {
-        // Stop event from bubbling up
-        // Kill the event loop attached to this specific `EventTarget`
-        // Needed to prevent `vue-router` for doing its thing
-        stopEvent(event, {
-          immediatePropagation: true
-        });
-      } else {
-        // Router links do not emit instance `click` events, so we
-        // add in an `$emit('click', event)` on its Vue instance
-        //
-        // seems not to be required for Vue3 compat build
-        /* istanbul ignore next: difficult to test, but we know it works */
-        if (isRouterLink) {
-          var _event$currentTarget$;
-          (_event$currentTarget$ = event.currentTarget.__vue__) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.$emit(EVENT_NAME_CLICK, event);
-        }
-        // Call the suppliedHandler(s), if any provided
-        concat(suppliedHandler).filter(h => isFunction(h)).forEach(handler => {
-          handler(...arguments);
-        });
-        // Emit the global `$root` click event
-        this.emitOnRoot(ROOT_EVENT_NAME_CLICKED, event);
-        // TODO: Remove deprecated 'clicked::link' event with next major release
-        this.emitOnRoot('clicked::link', event);
-      }
-      // Stop scroll-to-top behavior or navigation on
-      // regular links when href is just '#'
-      if (eventIsEvent && !isRouterLink && this.computedHref === '#') {
-        stopEvent(event, {
-          propagation: false
-        });
-      }
-    },
-    focus() {
-      attemptFocus(this.$el);
-    },
-    blur() {
-      attemptBlur(this.$el);
-    }
-  },
-  render(h) {
-    const {
-      active,
-      disabled
-    } = this;
-    return h(this.computedTag, {
-      class: {
-        active,
-        disabled
-      },
-      attrs: this.computedAttrs,
-      props: this.computedProps,
-      // We must use `nativeOn` for `<router-link>`/`<nuxt-link>` instead of `on`
-      [this.isRouterLink ? 'nativeOn' : 'on']: this.computedListeners
-    }, this.normalizeSlot());
-  }
-});
-
-export { BLink, props };