@gitlab/ui 132.0.0 → 132.0.2

package/dist/vendor/bootstrap-vue/src/components/table/thead.js

@@ -0,0 +1,99 @@
+import { extend } from '../../vue';
+import { NAME_THEAD } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { attrsMixin } from '../../mixins/attrs';
+import { listenersMixin } from '../../mixins/listeners';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+
+// --- Props ---
+
+const props = {
+  // Also sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+  // Supported values: 'lite', 'dark', or `null`
+  headVariant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  }
+};
+
+// --- Main component ---
+
+// TODO:
+//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
+//   to the child elements, so this can be converted to a functional component
+// @vue/component
+const BThead = /*#__PURE__*/extend({
+  name: NAME_THEAD,
+  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
+  provide() {
+    return {
+      getBvTableRowGroup: () => this
+    };
+  },
+  inject: {
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    getBvTable: {
+      default: /* istanbul ignore next */() => () => ({})
+    }
+  },
+  inheritAttrs: false,
+  props,
+  computed: {
+    bvTable() {
+      return this.getBvTable();
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    isThead() {
+      return true;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    isDark() {
+      return this.bvTable.dark;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    isStacked() {
+      return this.bvTable.isStacked;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    isResponsive() {
+      return this.bvTable.isResponsive;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    // Needed to handle header background classes, due to lack of
+    // background color inheritance with Bootstrap v4 table CSS
+    // Sticky headers only apply to cells in table `thead`
+    isStickyHeader() {
+      return !this.isStacked && this.bvTable.stickyHeader;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    // Needed to handle header background classes, due to lack of
+    // background color inheritance with Bootstrap v4 table CSS
+    hasStickyHeader() {
+      return !this.isStacked && this.bvTable.stickyHeader;
+    },
+    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`
+    tableVariant() {
+      return this.bvTable.tableVariant;
+    },
+    theadClasses() {
+      return [this.headVariant ? `thead-${this.headVariant}` : null];
+    },
+    theadAttrs() {
+      return {
+        role: 'rowgroup',
+        ...this.bvAttrs
+      };
+    }
+  },
+  render(h) {
+    return h('thead', {
+      class: this.theadClasses,
+      attrs: this.theadAttrs,
+      // Pass down any native listeners
+      on: this.bvListeners
+    }, this.normalizeSlot());
+  }
+});
+
+export { BThead, props };

package/dist/vendor/bootstrap-vue/src/components/table/tr.js

@@ -0,0 +1,121 @@
+import { extend } from '../../vue';
+import { NAME_TR } from '../../constants/components';
+import { PROP_TYPE_STRING } from '../../constants/props';
+import { attrsMixin } from '../../mixins/attrs';
+import { listenersMixin } from '../../mixins/listeners';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+
+// --- Constants ---
+
+const LIGHT = 'light';
+const DARK = 'dark';
+
+// --- Props ---
+
+const props = {
+  variant: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  }
+};
+
+// --- Main component ---
+
+// TODO:
+//   In Bootstrap v5, we won't need "sniffing" as table element variants properly inherit
+//   to the child elements, so this can be converted to a functional component
+// @vue/component
+const BTr = /*#__PURE__*/extend({
+  name: NAME_TR,
+  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],
+  provide() {
+    return {
+      getBvTableTr: () => this
+    };
+  },
+  inject: {
+    getBvTableRowGroup: {
+      default: /* istanbul ignore next */() => () => ({})
+    }
+  },
+  inheritAttrs: false,
+  props,
+  computed: {
+    bvTableRowGroup() {
+      return this.getBvTableRowGroup();
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    inTbody() {
+      return this.bvTableRowGroup.isTbody;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    inThead() {
+      return this.bvTableRowGroup.isThead;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    inTfoot() {
+      return this.bvTableRowGroup.isTfoot;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    isDark() {
+      return this.bvTableRowGroup.isDark;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    isStacked() {
+      return this.bvTableRowGroup.isStacked;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    isResponsive() {
+      return this.bvTableRowGroup.isResponsive;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    // Sticky headers are only supported in thead
+    isStickyHeader() {
+      return this.bvTableRowGroup.isStickyHeader;
+    },
+    // Sniffed by <b-tr> / `<b-td>` / `<b-th>`
+    // Needed to handle header background classes, due to lack of
+    // background color inheritance with Bootstrap v4 table CSS
+    hasStickyHeader() {
+      return !this.isStacked && this.bvTableRowGroup.hasStickyHeader;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    tableVariant() {
+      return this.bvTableRowGroup.tableVariant;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    headVariant() {
+      return this.inThead ? this.bvTableRowGroup.headVariant : null;
+    },
+    // Sniffed by `<b-td>` / `<b-th>`
+    footVariant() {
+      return this.inTfoot ? this.bvTableRowGroup.footVariant : null;
+    },
+    isRowDark() {
+      return this.headVariant === LIGHT || this.footVariant === LIGHT ? /* istanbul ignore next */false : this.headVariant === DARK || this.footVariant === DARK ? /* istanbul ignore next */true : this.isDark;
+    },
+    trClasses() {
+      const {
+        variant
+      } = this;
+      return [variant ? `${this.isRowDark ? 'bg' : 'table'}-${variant}` : null];
+    },
+    trAttrs() {
+      return {
+        role: 'row',
+        ...this.bvAttrs
+      };
+    }
+  },
+  render(h) {
+    return h('tr', {
+      class: this.trClasses,
+      attrs: this.trAttrs,
+      // Pass native listeners to child
+      on: this.bvListeners
+    }, this.normalizeSlot());
+  }
+});
+
+export { BTr, props };

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

@@ -0,0 +1,2 @@
+export { BTabs } from './tabs';
+export { BTab } from './tab';

package/dist/vendor/bootstrap-vue/src/components/tabs/tab.js

@@ -0,0 +1,238 @@
+import { extend } from '../../vue';
+import { NAME_TAB } from '../../constants/components';
+import { MODEL_EVENT_NAME_PREFIX } from '../../constants/events';
+import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING, PROP_TYPE_ARRAY, PROP_TYPE_OBJECT } from '../../constants/props';
+import { SLOT_NAME_TITLE } from '../../constants/slots';
+import { sortKeys } from '../../utils/object';
+import { props as props$1, idMixin } from '../../mixins/id';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { BVTransition } from '../transition/bv-transition';
+
+// --- Constants ---
+
+const MODEL_PROP_NAME_ACTIVE = 'active';
+const MODEL_EVENT_NAME_ACTIVE = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_ACTIVE;
+
+// --- Props ---
+
+const props = sortKeys({
+  ...props$1,
+  [MODEL_PROP_NAME_ACTIVE]: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  buttonId: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  disabled: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  lazy: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  noBody: {
+    type: PROP_TYPE_BOOLEAN,
+    required: false,
+    default: false
+  },
+  tag: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: 'div'
+  },
+  title: {
+    type: PROP_TYPE_STRING,
+    required: false,
+    default: undefined
+  },
+  // Sniffed by `<b-tabs>` and added to nav `li.nav-item`
+  titleItemClass: {
+    type: [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING],
+    required: false,
+    default: undefined
+  },
+  titleLinkAttributes: {
+    type: PROP_TYPE_OBJECT,
+    required: false,
+    default: undefined
+  },
+  // Sniffed by `<b-tabs>` and added to nav `a.nav-link`
+  titleLinkClass: {
+    type: [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING],
+    required: false,
+    default: undefined
+  }
+});
+
+// --- Main component ---
+
+// @vue/component
+const BTab = /*#__PURE__*/extend({
+  name: NAME_TAB,
+  mixins: [idMixin, normalizeSlotMixin],
+  inject: {
+    getBvTabs: {
+      default: () => () => ({})
+    }
+  },
+  props,
+  data() {
+    return {
+      localActive: this[MODEL_PROP_NAME_ACTIVE] && !this.disabled
+    };
+  },
+  computed: {
+    bvTabs() {
+      return this.getBvTabs();
+    },
+    // For parent sniffing of child
+    _isTab() {
+      return true;
+    },
+    tabClasses() {
+      const {
+        localActive: active,
+        disabled
+      } = this;
+      return [{
+        active,
+        disabled,
+        'card-body': this.bvTabs.card && !this.noBody
+      },
+      // Apply <b-tabs> `activeTabClass` styles when this tab is active
+      active ? this.bvTabs.activeTabClass : null];
+    },
+    controlledBy() {
+      return this.buttonId || this.safeId('__BV_tab_button__');
+    },
+    computedNoFade() {
+      return !(this.bvTabs.fade || false);
+    },
+    computedLazy() {
+      return this.bvTabs.lazy || this.lazy;
+    }
+  },
+  watch: {
+    [MODEL_PROP_NAME_ACTIVE](newValue, oldValue) {
+      if (newValue !== oldValue) {
+        if (newValue) {
+          // If activated post mount
+          this.activate();
+        } else {
+          /* istanbul ignore next */
+          if (!this.deactivate()) {
+            // Tab couldn't be deactivated, so we reset the synced active prop
+            // Deactivation will fail if no other tabs to activate
+            this.$emit(MODEL_EVENT_NAME_ACTIVE, this.localActive);
+          }
+        }
+      }
+    },
+    disabled(newValue, oldValue) {
+      if (newValue !== oldValue) {
+        const {
+          firstTab
+        } = this.bvTabs;
+        if (newValue && this.localActive && firstTab) {
+          this.localActive = false;
+          firstTab();
+        }
+      }
+    },
+    localActive(newValue) {
+      // Make `active` prop work with `.sync` modifier
+      this.$emit(MODEL_EVENT_NAME_ACTIVE, newValue);
+    }
+  },
+  mounted() {
+    // Inform `<b-tabs>` of our presence
+    this.registerTab();
+  },
+  updated() {
+    // Force the tab button content to update (since slots are not reactive)
+    // Only done if we have a title slot, as the title prop is reactive
+    const {
+      updateButton
+    } = this.bvTabs;
+    if (updateButton && this.hasNormalizedSlot(SLOT_NAME_TITLE)) {
+      updateButton(this);
+    }
+  },
+  beforeDestroy() {
+    // Inform `<b-tabs>` of our departure
+    this.unregisterTab();
+  },
+  methods: {
+    // Private methods
+    registerTab() {
+      // Inform `<b-tabs>` of our presence
+      const {
+        registerTab
+      } = this.bvTabs;
+      if (registerTab) {
+        registerTab(this);
+      }
+    },
+    unregisterTab() {
+      // Inform `<b-tabs>` of our departure
+      const {
+        unregisterTab
+      } = this.bvTabs;
+      if (unregisterTab) {
+        unregisterTab(this);
+      }
+    },
+    // Public methods
+    activate() {
+      // Not inside a `<b-tabs>` component or tab is disabled
+      const {
+        activateTab
+      } = this.bvTabs;
+      return activateTab && !this.disabled ? activateTab(this) : false;
+    },
+    deactivate() {
+      // Not inside a `<b-tabs>` component or not active to begin with
+      const {
+        deactivateTab
+      } = this.bvTabs;
+      return deactivateTab && this.localActive ? deactivateTab(this) : false;
+    }
+  },
+  render(h) {
+    const {
+      localActive
+    } = this;
+    const $content = h(this.tag, {
+      staticClass: 'tab-pane',
+      class: this.tabClasses,
+      directives: [{
+        name: 'show',
+        value: localActive
+      }],
+      attrs: {
+        role: 'tabpanel',
+        id: this.safeId(),
+        'aria-hidden': localActive ? 'false' : 'true',
+        'aria-labelledby': this.controlledBy || null
+      },
+      ref: 'panel'
+    },
+    // Render content lazily if requested
+    [localActive || !this.computedLazy ? this.normalizeSlot() : h()]);
+    return h(BVTransition, {
+      props: {
+        mode: 'out-in',
+        noFade: this.computedNoFade
+      }
+    }, [$content]);
+  }
+});
+
+export { BTab, props };