@gitlab/ui 84.2.0 → 85.0.0

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

@@ -0,0 +1,78 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_LIST_GROUP_ITEM } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../constants/props';
+import { arrayIncludes } from '../../utils/array';
+import { isTag } from '../../utils/dom';
+import { omit, sortKeys } from '../../utils/object';
+import { makePropsConfigurable, makeProp, pluckProps } from '../../utils/props';
+import { isLink } from '../../utils/router';
+import { props as props$1, BLink } from '../link/link';
+
+// --- Constants ---
+
+const actionTags = ['a', 'router-link', 'button', 'b-link'];
+
+// --- Props ---
+
+const linkProps = omit(props$1, ['event', 'routerTag']);
+delete linkProps.href.default;
+delete linkProps.to.default;
+const props = makePropsConfigurable(sortKeys({
+  ...linkProps,
+  action: makeProp(PROP_TYPE_BOOLEAN, false),
+  button: makeProp(PROP_TYPE_BOOLEAN, false),
+  tag: makeProp(PROP_TYPE_STRING, 'div'),
+  variant: makeProp(PROP_TYPE_STRING)
+}), NAME_LIST_GROUP_ITEM);
+
+// --- Main component ---
+
+// @vue/component
+const BListGroupItem = /*#__PURE__*/extend({
+  name: NAME_LIST_GROUP_ITEM,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      button,
+      variant,
+      active,
+      disabled
+    } = props;
+    const link = isLink(props);
+    const tag = button ? 'button' : !link ? props.tag : BLink;
+    const action = !!(props.action || link || button || arrayIncludes(actionTags, props.tag));
+    const attrs = {};
+    let itemProps = {};
+    if (isTag(tag, 'button')) {
+      if (!data.attrs || !data.attrs.type) {
+        // Add a type for button is one not provided in passed attributes
+        attrs.type = 'button';
+      }
+      if (props.disabled) {
+        // Set disabled attribute if button and disabled
+        attrs.disabled = true;
+      }
+    } else {
+      itemProps = pluckProps(linkProps, props);
+    }
+    return h(tag, mergeData(data, {
+      attrs,
+      props: itemProps,
+      staticClass: 'list-group-item',
+      class: {
+        [`list-group-item-${variant}`]: variant,
+        'list-group-item-action': action,
+        active,
+        disabled
+      }
+    }), children);
+  }
+});
+
+export { BListGroupItem, props };

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

@@ -0,0 +1,42 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_LIST_GROUP } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_BOOLEAN_STRING, PROP_TYPE_STRING } from '../../constants/props';
+import { isString } from '../../utils/inspect';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  flush: makeProp(PROP_TYPE_BOOLEAN, false),
+  horizontal: makeProp(PROP_TYPE_BOOLEAN_STRING, false),
+  tag: makeProp(PROP_TYPE_STRING, 'div')
+}, NAME_LIST_GROUP);
+
+// --- Main component ---
+
+// @vue/component
+const BListGroup = /*#__PURE__*/extend({
+  name: NAME_LIST_GROUP,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    let horizontal = props.horizontal === '' ? true : props.horizontal;
+    horizontal = props.flush ? false : horizontal;
+    const componentData = {
+      staticClass: 'list-group',
+      class: {
+        'list-group-flush': props.flush,
+        'list-group-horizontal': horizontal === true,
+        [`list-group-horizontal-${horizontal}`]: isString(horizontal)
+      }
+    };
+    return h(props.tag, mergeData(data, componentData), children);
+  }
+});
+
+export { BListGroup, props };

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

@@ -0,0 +1,17 @@
+import { BMedia } from './media';
+export { BMedia } from './media';
+import { BMediaAside } from './media-aside';
+export { BMediaAside } from './media-aside';
+import { BMediaBody } from './media-body';
+export { BMediaBody } from './media-body';
+import { pluginFactory } from '../../utils/plugins';
+
+const MediaPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BMedia,
+    BMediaAside,
+    BMediaBody
+  }
+});
+
+export { MediaPlugin };

package/dist/vendor/bootstrap-vue/src/components/media/media-aside.js

@@ -0,0 +1,41 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_MEDIA_ASIDE } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../constants/props';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  right: makeProp(PROP_TYPE_BOOLEAN, false),
+  tag: makeProp(PROP_TYPE_STRING, 'div'),
+  verticalAlign: makeProp(PROP_TYPE_STRING, 'top')
+}, NAME_MEDIA_ASIDE);
+
+// --- Main component ---
+
+// @vue/component
+const BMediaAside = /*#__PURE__*/extend({
+  name: NAME_MEDIA_ASIDE,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    const {
+      verticalAlign
+    } = props;
+    const align = verticalAlign === 'top' ? 'start' : verticalAlign === 'bottom' ? 'end' : /* istanbul ignore next */verticalAlign;
+    return h(props.tag, mergeData(data, {
+      staticClass: 'media-aside',
+      class: {
+        'media-aside-right': props.right,
+        [`align-self-${align}`]: align
+      }
+    }), children);
+  }
+});
+
+export { BMediaAside, props };

package/dist/vendor/bootstrap-vue/src/components/media/media-body.js

@@ -0,0 +1,31 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_MEDIA_BODY } 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_MEDIA_BODY);
+
+// --- Main component ---
+
+// @vue/component
+const BMediaBody = /*#__PURE__*/extend({
+  name: NAME_MEDIA_BODY,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      children
+    } = _ref;
+    return h(props.tag, mergeData(data, {
+      staticClass: 'media-body'
+    }), children);
+  }
+});
+
+export { BMediaBody, props };

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

@@ -0,0 +1,61 @@
+import { extend, mergeData } from '../../vue';
+import { NAME_MEDIA } from '../../constants/components';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../constants/props';
+import { SLOT_NAME_DEFAULT, SLOT_NAME_ASIDE } from '../../constants/slots';
+import { normalizeSlot } from '../../utils/normalize-slot';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+import { BMediaAside } from './media-aside';
+import { BMediaBody } from './media-body';
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  noBody: makeProp(PROP_TYPE_BOOLEAN, false),
+  rightAlign: makeProp(PROP_TYPE_BOOLEAN, false),
+  tag: makeProp(PROP_TYPE_STRING, 'div'),
+  verticalAlign: makeProp(PROP_TYPE_STRING, 'top')
+}, NAME_MEDIA);
+
+// --- Main component ---
+
+// @vue/component
+const BMedia = /*#__PURE__*/extend({
+  name: NAME_MEDIA,
+  functional: true,
+  props,
+  render(h, _ref) {
+    let {
+      props,
+      data,
+      slots,
+      scopedSlots,
+      children
+    } = _ref;
+    const {
+      noBody,
+      rightAlign,
+      verticalAlign
+    } = props;
+    const $children = noBody ? children : [];
+    if (!noBody) {
+      const slotScope = {};
+      const $slots = slots();
+      const $scopedSlots = scopedSlots || {};
+      $children.push(h(BMediaBody, normalizeSlot(SLOT_NAME_DEFAULT, slotScope, $scopedSlots, $slots)));
+      const $aside = normalizeSlot(SLOT_NAME_ASIDE, slotScope, $scopedSlots, $slots);
+      if ($aside) {
+        $children[rightAlign ? 'push' : 'unshift'](h(BMediaAside, {
+          props: {
+            right: rightAlign,
+            verticalAlign
+          }
+        }, $aside));
+      }
+    }
+    return h(props.tag, mergeData(data, {
+      staticClass: 'media'
+    }), $children);
+  }
+});
+
+export { BMedia, props };

package/dist/vendor/bootstrap-vue/src/components/modal/helpers/bv-modal-event.class.js

@@ -0,0 +1,21 @@
+import { BvEvent } from '../../../utils/bv-event.class';
+import { defineProperties, readonlyDescriptor } from '../../../utils/object';
+
+class BvModalEvent extends BvEvent {
+  constructor(type) {
+    let eventInit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(type, eventInit);
+    // Freeze our new props as readonly, but leave them enumerable
+    defineProperties(this, {
+      trigger: readonlyDescriptor()
+    });
+  }
+  static get Defaults() {
+    return {
+      ...super.Defaults,
+      trigger: null
+    };
+  }
+}
+
+export { BvModalEvent };

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

@@ -0,0 +1,279 @@
+import { NAME_MSG_BOX, NAME_MODAL } from '../../../constants/components';
+import { HOOK_EVENT_NAME_DESTROYED, EVENT_NAME_HIDDEN, HOOK_EVENT_NAME_BEFORE_DESTROY, EVENT_NAME_HIDE } from '../../../constants/events';
+import { useParentMixin } from '../../../mixins/use-parent';
+import { concat } from '../../../utils/array';
+import { getComponentConfig } from '../../../utils/config';
+import { requestAF } from '../../../utils/dom';
+import { getRootActionEventName } from '../../../utils/events';
+import { isFunction, isUndefined } from '../../../utils/inspect';
+import { keys, omit, hasOwnProperty, defineProperty, assign, defineProperties, readonlyDescriptor } from '../../../utils/object';
+import { pluginFactory } from '../../../utils/plugins';
+import { warn, warnNoPromiseSupport, warnNotClient } from '../../../utils/warn';
+import { createNewChildComponent } from '../../../utils/create-new-child-component';
+import { getEventRoot } from '../../../utils/get-event-root';
+import { props, BModal } from '../modal';
+
+// Plugin for adding `$bvModal` property to all Vue instances
+
+// --- Constants ---
+
+const PROP_NAME = '$bvModal';
+const PROP_NAME_PRIV = '_bv__modal';
+
+// Base modal props that are allowed
+// Some may be ignored or overridden on some message boxes
+// Prop ID is allowed, but really only should be used for testing
+// We need to add it in explicitly as it comes from the `idMixin`
+const BASE_PROPS = ['id', ...keys(omit(props, ['busy', 'lazy', 'noStacking', 'static', 'visible']))];
+
+// Fallback event resolver (returns undefined)
+const defaultResolver = () => {};
+
+// Map prop names to modal slot names
+const propsToSlots = {
+  msgBoxContent: 'default',
+  title: 'modal-title',
+  okTitle: 'modal-ok',
+  cancelTitle: 'modal-cancel'
+};
+
+// --- Helper methods ---
+
+// Method to filter only recognized props that are not undefined
+const filterOptions = options => {
+  return BASE_PROPS.reduce((memo, key) => {
+    if (!isUndefined(options[key])) {
+      memo[key] = options[key];
+    }
+    return memo;
+  }, {});
+};
+
+// Method to install `$bvModal` VM injection
+const plugin = Vue => {
+  // Create a private sub-component that extends BModal
+  // which self-destructs after hidden
+  // @vue/component
+  const BMsgBox = Vue.extend({
+    name: NAME_MSG_BOX,
+    extends: BModal,
+    mixins: [useParentMixin],
+    destroyed() {
+      // Make sure we not in document any more
+      if (this.$el && this.$el.parentNode) {
+        this.$el.parentNode.removeChild(this.$el);
+      }
+    },
+    mounted() {
+      // Self destruct handler
+      const handleDestroy = () => {
+        this.$nextTick(() => {
+          // In a `requestAF()` to release control back to application
+          requestAF(() => {
+            this.$destroy();
+          });
+        });
+      };
+      // Self destruct if parent destroyed
+      this.bvParent.$once(HOOK_EVENT_NAME_DESTROYED, handleDestroy);
+      // Self destruct after hidden
+      this.$once(EVENT_NAME_HIDDEN, handleDestroy);
+      // Self destruct on route change
+      /* istanbul ignore if */
+      if (this.$router && this.$route) {
+        // Destroy ourselves if route changes
+        /* istanbul ignore next */
+        this.$once(HOOK_EVENT_NAME_BEFORE_DESTROY, this.$watch('$router', handleDestroy));
+      }
+      // Show the `BMsgBox`
+      this.show();
+    }
+  });
+
+  // Method to generate the on-demand modal message box
+  // Returns a promise that resolves to a value returned by the resolve
+  const asyncMsgBox = function (parent, props) {
+    let resolver = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultResolver;
+    if (warnNotClient(PROP_NAME) || warnNoPromiseSupport(PROP_NAME)) {
+      /* istanbul ignore next */
+      return;
+    }
+    // Create an instance of `BMsgBox` component
+    // We set parent as the local VM so these modals can emit events on
+    // the app `$root`, as needed by things like tooltips and popovers
+    // And it helps to ensure `BMsgBox` is destroyed when parent is destroyed
+    const msgBox = createNewChildComponent(parent, BMsgBox, {
+      // Preset the prop values
+      propsData: {
+        ...filterOptions(getComponentConfig(NAME_MODAL)),
+        // Defaults that user can override
+        hideHeaderClose: true,
+        hideHeader: !(props.title || props.titleHtml),
+        // Add in (filtered) user supplied props
+        ...omit(props, keys(propsToSlots)),
+        // Props that can't be overridden
+        lazy: false,
+        busy: false,
+        visible: false,
+        noStacking: false,
+        noEnforceFocus: false
+      }
+    });
+    // Convert certain props to scoped slots
+    keys(propsToSlots).forEach(prop => {
+      if (!isUndefined(props[prop])) {
+        // Can be a string, or array of VNodes.
+        // Alternatively, user can use HTML version of prop to pass an HTML string.
+        msgBox.$slots[propsToSlots[prop]] = concat(props[prop]);
+      }
+    });
+    // Return a promise that resolves when hidden, or rejects on destroyed
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      msgBox.$once(HOOK_EVENT_NAME_DESTROYED, () => {
+        if (!resolved) {
+          /* istanbul ignore next */
+          reject(new Error('BootstrapVue MsgBox destroyed before resolve'));
+        }
+      });
+      msgBox.$on(EVENT_NAME_HIDE, bvModalEvent => {
+        if (!bvModalEvent.defaultPrevented) {
+          const result = resolver(bvModalEvent);
+          // If resolver didn't cancel hide, we resolve
+          if (!bvModalEvent.defaultPrevented) {
+            resolved = true;
+            resolve(result);
+          }
+        }
+      });
+      // Create a mount point (a DIV) and mount the msgBo which will trigger it to show
+      const div = document.createElement('div');
+      document.body.appendChild(div);
+      msgBox.$mount(div);
+    });
+  };
+
+  // Private utility method to open a user defined message box and returns a promise.
+  // Not to be used directly by consumers, as this method may change calling syntax
+  const makeMsgBox = function (parent, content) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let resolver = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    if (!content || warnNoPromiseSupport(PROP_NAME) || warnNotClient(PROP_NAME) || !isFunction(resolver)) {
+      /* istanbul ignore next */
+      return;
+    }
+    return asyncMsgBox(parent, {
+      ...filterOptions(options),
+      msgBoxContent: content
+    }, resolver);
+  };
+
+  // BvModal instance class
+  class BvModal {
+    constructor(vm) {
+      // Assign the new properties to this instance
+      assign(this, {
+        _vm: vm,
+        _root: getEventRoot(vm)
+      });
+      // Set these properties as read-only and non-enumerable
+      defineProperties(this, {
+        _vm: readonlyDescriptor(),
+        _root: readonlyDescriptor()
+      });
+    }
+
+    // --- Instance methods ---
+
+    // Show modal with the specified ID args are for future use
+    show(id) {
+      if (id && this._root) {
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        this._root.$emit(getRootActionEventName(NAME_MODAL, 'show'), id, ...args);
+      }
+    }
+
+    // Hide modal with the specified ID args are for future use
+    hide(id) {
+      if (id && this._root) {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        this._root.$emit(getRootActionEventName(NAME_MODAL, 'hide'), id, ...args);
+      }
+    }
+
+    // The following methods require Promise support!
+    // IE 11 and others do not support Promise natively, so users
+    // should have a Polyfill loaded (which they need anyways for IE 11 support)
+
+    // Open a message box with OK button only and returns a promise
+    msgBoxOk(message) {
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // Pick the modal props we support from options
+      const props = {
+        ...options,
+        // Add in overrides and our content prop
+        okOnly: true,
+        okDisabled: false,
+        hideFooter: false,
+        msgBoxContent: message
+      };
+      return makeMsgBox(this._vm, message, props, () => {
+        // Always resolve to true for OK
+        return true;
+      });
+    }
+
+    // Open a message box modal with OK and CANCEL buttons
+    // and returns a promise
+    msgBoxConfirm(message) {
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // Set the modal props we support from options
+      const props = {
+        ...options,
+        // Add in overrides and our content prop
+        okOnly: false,
+        okDisabled: false,
+        cancelDisabled: false,
+        hideFooter: false
+      };
+      return makeMsgBox(this._vm, message, props, bvModalEvent => {
+        const trigger = bvModalEvent.trigger;
+        return trigger === 'ok' ? true : trigger === 'cancel' ? false : null;
+      });
+    }
+  }
+
+  // Add our instance mixin
+  Vue.mixin({
+    beforeCreate() {
+      // Because we need access to `$root` for `$emits`, and VM for parenting,
+      // we have to create a fresh instance of `BvModal` for each VM
+      this[PROP_NAME_PRIV] = new BvModal(this);
+    }
+  });
+
+  // Define our read-only `$bvModal` instance property
+  // Placed in an if just in case in HMR mode
+  if (!hasOwnProperty(Vue.prototype, PROP_NAME)) {
+    defineProperty(Vue.prototype, PROP_NAME, {
+      get() {
+        /* istanbul ignore next */
+        if (!this || !this[PROP_NAME_PRIV]) {
+          warn(`"${PROP_NAME}" must be accessed from a Vue instance "this" context.`, NAME_MODAL);
+        }
+        return this[PROP_NAME_PRIV];
+      }
+    });
+  }
+};
+const BVModalPlugin = /*#__PURE__*/pluginFactory({
+  plugins: {
+    plugin
+  }
+});
+
+export { BVModalPlugin };