@gitlab/ui 84.2.0 → 85.0.0

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

@@ -0,0 +1,156 @@
+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, makePropsConfigurable } 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 makePropsConfigurable(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')
+  }), NAME_COL);
+};
+
+// --- 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/container.js

@@ -0,0 +1,41 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_CONTAINER } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN_STRING, PROP_TYPE_STRING } from '../../constants/props';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  // String breakpoint name new in Bootstrap v4.4.x
+  fluid: makeProp(PROP_TYPE_BOOLEAN_STRING, false),
+  tag: makeProp(PROP_TYPE_STRING, 'div')
+}, NAME_CONTAINER);
+
+// --- Main component ---
+
+// @vue/component
+const BContainer = /*#__PURE__*/extend({
+  name: NAME_CONTAINER,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      fluid
+    } = props;
+    return h(props.tag, mergeData(data, {
+      class: {
+        container: !(fluid || fluid === ''),
+        'container-fluid': fluid === true || fluid === '',
+        // Bootstrap v4.4+ responsive containers
+        [`container-${fluid}`]: fluid && fluid !== true
+      }
+    }), children);
+  }
+});
+
+export { BContainer, props };

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

@@ -0,0 +1,31 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_FORM_ROW } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  tag: makeProp(PROP_TYPE_STRING, 'div')
+}, NAME_FORM_ROW);
+
+// --- 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

@@ -0,0 +1,20 @@
+import { BContainer } from './container';
+export { BContainer } from './container';
+import { BRow } from './row';
+export { BRow } from './row';
+import { BCol } from './col';
+export { BCol } from './col';
+import { BFormRow } from './form-row';
+export { BFormRow } from './form-row';
+import { pluginFactory } from '../../utils/plugins';
+
+const LayoutPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BContainer,
+    BRow,
+    BCol,
+    BFormRow
+  }
+});
+
+export { LayoutPlugin };

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

@@ -0,0 +1,113 @@
+import { mergeData } from '../../vue';
+import { NAME_ROW } from '../../constants/components';
+import { PROP_TYPE_NUMBER_STRING, PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';
+import { arrayIncludes, concat } from '../../utils/array';
+import { getBreakpointsUpCached } from '../../utils/config';
+import { identity } from '../../utils/identity';
+import { memoize } from '../../utils/memoize';
+import { create, keys, sortKeys } from '../../utils/object';
+import { suffixPropName, makeProp, makePropsConfigurable } from '../../utils/props';
+import { trim, toString, lowerCase } from '../../utils/string';
+
+// --- Constants ---
+
+const COMMON_ALIGNMENT = ['start', 'end', 'center'];
+
+// --- Helper methods ---
+
+// Compute a `row-cols-{breakpoint}-{cols}` class name
+// Memoized function for better performance on generating class names
+const computeRowColsClass = memoize((breakpoint, cols) => {
+  cols = trim(toString(cols));
+  return cols ? lowerCase(['row-cols', breakpoint, cols].filter(identity).join('-')) : null;
+});
+
+// Get the breakpoint name from the `rowCols` prop name
+// Memoized function for better performance on extracting breakpoint names
+const computeRowColsBreakpoint = memoize(prop => lowerCase(prop.replace('cols', '')));
+
+// Cached copy of the `row-cols` breakpoint prop names
+// Will be populated when the props are generated
+let rowColsPropList = [];
+
+// --- Props ---
+
+// Prop generator for lazy generation of props
+const generateProps = () => {
+  // i.e. 'row-cols-2', 'row-cols-md-4', 'row-cols-xl-6', ...
+  const rowColsProps = getBreakpointsUpCached().reduce((props, breakpoint) => {
+    props[suffixPropName(breakpoint, 'cols')] = makeProp(PROP_TYPE_NUMBER_STRING);
+    return props;
+  }, create(null));
+
+  // Cache the row-cols prop names
+  rowColsPropList = keys(rowColsProps);
+
+  // Return the generated props
+  return makePropsConfigurable(sortKeys({
+    ...rowColsProps,
+    alignContent: makeProp(PROP_TYPE_STRING, null, value => {
+      return arrayIncludes(concat(COMMON_ALIGNMENT, 'between', 'around', 'stretch'), value);
+    }),
+    alignH: makeProp(PROP_TYPE_STRING, null, value => {
+      return arrayIncludes(concat(COMMON_ALIGNMENT, 'between', 'around'), value);
+    }),
+    alignV: makeProp(PROP_TYPE_STRING, null, value => {
+      return arrayIncludes(concat(COMMON_ALIGNMENT, 'baseline', 'stretch'), value);
+    }),
+    noGutters: makeProp(PROP_TYPE_BOOLEAN, false),
+    tag: makeProp(PROP_TYPE_STRING, 'div')
+  }), NAME_ROW);
+};
+
+// --- 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 BRow = {
+  name: NAME_ROW,
+  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;
+    this.props = generateProps();
+    return this.props;
+  },
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      alignV,
+      alignH,
+      alignContent
+    } = props;
+
+    // Loop through row-cols breakpoint props and generate the classes
+    const classList = [];
+    rowColsPropList.forEach(prop => {
+      const c = computeRowColsClass(computeRowColsBreakpoint(prop), props[prop]);
+      // If a class is returned, push it onto the array
+      if (c) {
+        classList.push(c);
+      }
+    });
+    classList.push({
+      'no-gutters': props.noGutters,
+      [`align-items-${alignV}`]: alignV,
+      [`justify-content-${alignH}`]: alignH,
+      [`align-content-${alignContent}`]: alignContent
+    });
+    return h(props.tag, mergeData(data, {
+      staticClass: 'row',
+      class: classList
+    }), children);
+  }
+};
+
+export { BRow, generateProps };

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

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

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

@@ -0,0 +1,239 @@
+import { extend } from '../../vue';
+import { NAME_LINK } from '../../constants/components';
+import { EVENT_NAME_CLICK } from '../../constants/events';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_ARRAY_STRING, PROP_TYPE_OBJECT_STRING } from '../../constants/props';
+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 { sortKeys, omit } from '../../utils/object';
+import { makeProp, makePropsConfigurable, 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 ---
+
+// `<router-link>` specific props
+const routerLinkProps = {
+  activeClass: makeProp(PROP_TYPE_STRING),
+  append: makeProp(PROP_TYPE_BOOLEAN, false),
+  event: makeProp(PROP_TYPE_ARRAY_STRING),
+  exact: makeProp(PROP_TYPE_BOOLEAN, false),
+  exactActiveClass: makeProp(PROP_TYPE_STRING),
+  exactPath: makeProp(PROP_TYPE_BOOLEAN, false),
+  exactPathActiveClass: makeProp(PROP_TYPE_STRING),
+  replace: makeProp(PROP_TYPE_BOOLEAN, false),
+  routerTag: makeProp(PROP_TYPE_STRING),
+  to: makeProp(PROP_TYPE_OBJECT_STRING)
+};
+
+// `<nuxt-link>` specific props
+const nuxtLinkProps = {
+  noPrefetch: makeProp(PROP_TYPE_BOOLEAN, 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: makeProp(PROP_TYPE_BOOLEAN, null)
+};
+
+// All `<b-link>` props
+const props = makePropsConfigurable(sortKeys({
+  ...nuxtLinkProps,
+  ...routerLinkProps,
+  active: makeProp(PROP_TYPE_BOOLEAN, false),
+  disabled: makeProp(PROP_TYPE_BOOLEAN, false),
+  href: makeProp(PROP_TYPE_STRING),
+  // Must be `null` if no value provided
+  rel: makeProp(PROP_TYPE_STRING, 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: makeProp(PROP_TYPE_STRING),
+  target: makeProp(PROP_TYPE_STRING, '_self')
+}), NAME_LINK);
+
+// --- 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);
+    },
+    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() {
+      const {
+        event,
+        prefetch,
+        routerTag
+      } = this;
+      return this.isRouterLink ? {
+        ...pluckProps(omit({
+          ...routerLinkProps,
+          ...(this.computedTag === 'nuxt-link' ? nuxtLinkProps : {})
+        }, ['event', 'prefetch', 'routerTag']), 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, nuxtLinkProps, props, routerLinkProps };

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

@@ -0,0 +1,14 @@
+import { BListGroup } from './list-group';
+export { BListGroup } from './list-group';
+import { BListGroupItem } from './list-group-item';
+export { BListGroupItem } from './list-group-item';
+import { pluginFactory } from '../../utils/plugins';
+
+const ListGroupPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BListGroup,
+    BListGroupItem
+  }
+});
+
+export { ListGroupPlugin };