@gitlab/ui 132.0.1 → 132.0.3

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

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

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

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

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

@@ -0,0 +1,283 @@
+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 };

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/modal-manager.js

@@ -0,0 +1,212 @@
+import { extend } from '../../../vue';
+import { IS_BROWSER } from '../../../constants/env';
+import { addClass, removeClass, setAttr, requestAF, setStyle, getCS, getBCR, selectAll, getStyle, hasAttr, getAttr, removeAttr } from '../../../utils/dom';
+import { isNull } from '../../../utils/inspect';
+import { toInteger, toFloat } from '../../../utils/number';
+
+/**
+ * Private ModalManager helper
+ * Handles controlling modal stacking zIndexes and body adjustments/classes
+ */
+
+
+// --- Constants ---
+
+// Default modal backdrop z-index
+const DEFAULT_ZINDEX = 1040;
+
+// Selectors for padding/margin adjustments
+const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
+const SELECTOR_STICKY_CONTENT = '.sticky-top';
+const SELECTOR_NAVBAR_TOGGLER = '.navbar-toggler';
+
+// --- Main component ---
+
+// @vue/component
+const ModalManager = /*#__PURE__*/extend({
+  data() {
+    return {
+      modals: [],
+      baseZIndex: null,
+      scrollbarWidth: null,
+      isBodyOverflowing: false
+    };
+  },
+  computed: {
+    modalCount() {
+      return this.modals.length;
+    },
+    modalsAreOpen() {
+      return this.modalCount > 0;
+    }
+  },
+  watch: {
+    modalCount(newCount, oldCount) {
+      if (IS_BROWSER) {
+        this.getScrollbarWidth();
+        if (newCount > 0 && oldCount === 0) {
+          // Transitioning to modal(s) open
+          this.checkScrollbar();
+          this.setScrollbar();
+          addClass(document.body, 'modal-open');
+        } else if (newCount === 0 && oldCount > 0) {
+          // Transitioning to modal(s) closed
+          this.resetScrollbar();
+          removeClass(document.body, 'modal-open');
+        }
+        setAttr(document.body, 'data-modal-open-count', String(newCount));
+      }
+    },
+    modals(newValue) {
+      this.checkScrollbar();
+      requestAF(() => {
+        this.updateModals(newValue || []);
+      });
+    }
+  },
+  methods: {
+    // Public methods
+    registerModal(modal) {
+      // Register the modal if not already registered
+      if (modal && this.modals.indexOf(modal) === -1) {
+        this.modals.push(modal);
+      }
+    },
+    unregisterModal(modal) {
+      const index = this.modals.indexOf(modal);
+      if (index > -1) {
+        // Remove modal from modals array
+        this.modals.splice(index, 1);
+        // Reset the modal's data
+        if (!modal._isBeingDestroyed && !modal._isDestroyed) {
+          this.resetModal(modal);
+        }
+      }
+    },
+    getBaseZIndex() {
+      if (IS_BROWSER && isNull(this.baseZIndex)) {
+        // Create a temporary `div.modal-backdrop` to get computed z-index
+        const div = document.createElement('div');
+        addClass(div, 'modal-backdrop');
+        addClass(div, 'gl-hidden');
+        setStyle(div, 'display', 'none');
+        document.body.appendChild(div);
+        this.baseZIndex = toInteger(getCS(div).zIndex, DEFAULT_ZINDEX);
+        document.body.removeChild(div);
+      }
+      return this.baseZIndex || DEFAULT_ZINDEX;
+    },
+    getScrollbarWidth() {
+      if (IS_BROWSER && isNull(this.scrollbarWidth)) {
+        // Create a temporary `div.measure-scrollbar` to get computed z-index
+        const div = document.createElement('div');
+        addClass(div, 'modal-scrollbar-measure');
+        document.body.appendChild(div);
+        this.scrollbarWidth = getBCR(div).width - div.clientWidth;
+        document.body.removeChild(div);
+      }
+      return this.scrollbarWidth || 0;
+    },
+    // Private methods
+    updateModals(modals) {
+      const baseZIndex = this.getBaseZIndex();
+      const scrollbarWidth = this.getScrollbarWidth();
+      modals.forEach((modal, index) => {
+        // We update data values on each modal
+        modal.zIndex = baseZIndex + index;
+        modal.scrollbarWidth = scrollbarWidth;
+        modal.isTop = index === this.modals.length - 1;
+        modal.isBodyOverflowing = this.isBodyOverflowing;
+      });
+    },
+    resetModal(modal) {
+      if (modal) {
+        modal.zIndex = this.getBaseZIndex();
+        modal.isTop = true;
+        modal.isBodyOverflowing = false;
+      }
+    },
+    checkScrollbar() {
+      // Determine if the body element is overflowing
+      const {
+        left,
+        right
+      } = getBCR(document.body);
+      this.isBodyOverflowing = left + right < window.innerWidth;
+    },
+    setScrollbar() {
+      const body = document.body;
+      // Storage place to cache changes to margins and padding
+      // Note: This assumes the following element types are not added to the
+      // document after the modal has opened.
+      body._paddingChangedForModal = body._paddingChangedForModal || [];
+      body._marginChangedForModal = body._marginChangedForModal || [];
+      if (this.isBodyOverflowing) {
+        const scrollbarWidth = this.scrollbarWidth;
+        // Adjust fixed content padding
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_FIXED_CONTENT).forEach(el => {
+          const actualPadding = getStyle(el, 'paddingRight') || '';
+          setAttr(el, 'data-padding-right', actualPadding);
+          setStyle(el, 'paddingRight', `${toFloat(getCS(el).paddingRight, 0) + scrollbarWidth}px`);
+          body._paddingChangedForModal.push(el);
+        });
+        // Adjust sticky content margin
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_STICKY_CONTENT).forEach(el => /* istanbul ignore next */{
+          const actualMargin = getStyle(el, 'marginRight') || '';
+          setAttr(el, 'data-margin-right', actualMargin);
+          setStyle(el, 'marginRight', `${toFloat(getCS(el).marginRight, 0) - scrollbarWidth}px`);
+          body._marginChangedForModal.push(el);
+        });
+        // Adjust .navbar-toggler margin
+        /* istanbul ignore next: difficult to test in JSDOM */
+        selectAll(SELECTOR_NAVBAR_TOGGLER).forEach(el => /* istanbul ignore next */{
+          const actualMargin = getStyle(el, 'marginRight') || '';
+          setAttr(el, 'data-margin-right', actualMargin);
+          setStyle(el, 'marginRight', `${toFloat(getCS(el).marginRight, 0) + scrollbarWidth}px`);
+          body._marginChangedForModal.push(el);
+        });
+        // Adjust body padding
+        const actualPadding = getStyle(body, 'paddingRight') || '';
+        setAttr(body, 'data-padding-right', actualPadding);
+        setStyle(body, 'paddingRight', `${toFloat(getCS(body).paddingRight, 0) + scrollbarWidth}px`);
+      }
+    },
+    resetScrollbar() {
+      const body = document.body;
+      if (body._paddingChangedForModal) {
+        // Restore fixed content padding
+        body._paddingChangedForModal.forEach(el => {
+          /* istanbul ignore next: difficult to test in JSDOM */
+          if (hasAttr(el, 'data-padding-right')) {
+            setStyle(el, 'paddingRight', getAttr(el, 'data-padding-right') || '');
+            removeAttr(el, 'data-padding-right');
+          }
+        });
+      }
+      if (body._marginChangedForModal) {
+        // Restore sticky content and navbar-toggler margin
+        body._marginChangedForModal.forEach(el => {
+          /* istanbul ignore next: difficult to test in JSDOM */
+          if (hasAttr(el, 'data-margin-right')) {
+            setStyle(el, 'marginRight', getAttr(el, 'data-margin-right') || '');
+            removeAttr(el, 'data-margin-right');
+          }
+        });
+      }
+      body._paddingChangedForModal = null;
+      body._marginChangedForModal = null;
+      // Restore body padding
+      if (hasAttr(body, 'data-padding-right')) {
+        setStyle(body, 'paddingRight', getAttr(body, 'data-padding-right') || '');
+        removeAttr(body, 'data-padding-right');
+      }
+    }
+  }
+});
+
+// Create and export our modal manager instance
+const modalManager = new ModalManager();
+
+export { modalManager };

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

@@ -0,0 +1 @@
+export { BModal } from './modal';