@gitlab/ui 132.0.3 → 132.2.0

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-busy.js

@@ -1,6 +1,5 @@
 import { extend } from '../../../vue';
 import { MODEL_EVENT_NAME_PREFIX } from '../../../constants/events';
-import { PROP_TYPE_BOOLEAN } from '../../../constants/props';
 import { SLOT_NAME_TABLE_BUSY } from '../../../constants/slots';
 import { stopEvent } from '../../../utils/events';
 import { isFunction } from '../../../utils/inspect';
@@ -16,7 +15,7 @@ const MODEL_EVENT_NAME_BUSY = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_BUSY;
 
 const props = {
   [MODEL_PROP_NAME_BUSY]: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   }
@@ -56,10 +55,8 @@ const busyMixin = extend({
     },
     // Render the busy indicator or return `null` if not busy
     renderBusy() {
-      const {
-        tbodyTrClass,
-        tbodyTrAttr
-      } = this;
+      const tbodyTrClass = this.tbodyTrClass,
+        tbodyTrAttr = this.tbodyTrAttr;
       const h = this.$createElement;
 
       // Return a busy indicator row, or `null` if not busy

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-caption.js

@@ -1,5 +1,4 @@
 import { extend } from '../../../vue';
-import { PROP_TYPE_STRING } from '../../../constants/props';
 import { SLOT_NAME_TABLE_CAPTION } from '../../../constants/slots';
 import { htmlOrText } from '../../../utils/html';
 
@@ -7,12 +6,12 @@ import { htmlOrText } from '../../../utils/html';
 
 const props = {
   caption: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   },
   captionHtml: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   }
@@ -32,10 +31,8 @@ const captionMixin = extend({
   },
   methods: {
     renderCaption() {
-      const {
-        caption,
-        captionHtml
-      } = this;
+      const caption = this.caption,
+        captionHtml = this.captionHtml;
       const h = this.$createElement;
       let $caption = h();
       const hasCaptionSlot = this.hasNormalizedSlot(SLOT_NAME_TABLE_CAPTION);

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-colgroup.js

@@ -11,9 +11,7 @@ const props = {};
 const colgroupMixin = extend({
   methods: {
     renderColgroup() {
-      const {
-        computedFields: fields
-      } = this;
+      const fields = this.computedFields;
       const h = this.$createElement;
       let $colgroup = h();
       if (this.hasNormalizedSlot(SLOT_NAME_TABLE_COLGROUP)) {

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-empty.js

@@ -1,5 +1,4 @@
 import { extend } from '../../../vue';
-import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../../constants/props';
 import { SLOT_NAME_TABLE_BUSY, SLOT_NAME_EMPTYFILTERED, SLOT_NAME_EMPTY } from '../../../constants/slots';
 import { htmlOrText } from '../../../utils/html';
 import { isFunction } from '../../../utils/inspect';
@@ -11,27 +10,27 @@ import { BTd } from '../td';
 
 const props = {
   emptyFilteredHtml: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   },
   emptyFilteredText: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: 'There are no records matching your request'
   },
   emptyHtml: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   },
   emptyText: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: 'There are no records to show'
   },
   showEmpty: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   }
@@ -44,23 +43,20 @@ const emptyMixin = extend({
   props,
   methods: {
     renderEmpty() {
-      const {
-        computedItems: items,
-        computedBusy
-      } = safeVueInstance(this);
+      const _safeVueInstance = safeVueInstance(this),
+        items = _safeVueInstance.computedItems,
+        computedBusy = _safeVueInstance.computedBusy;
       const h = this.$createElement;
       let $empty = h();
       if (this.showEmpty && (!items || items.length === 0) && !(computedBusy && this.hasNormalizedSlot(SLOT_NAME_TABLE_BUSY))) {
-        const {
-          computedFields: fields,
-          isFiltered,
-          emptyText,
-          emptyHtml,
-          emptyFilteredText,
-          emptyFilteredHtml,
-          tbodyTrClass,
-          tbodyTrAttr
-        } = this;
+        const fields = this.computedFields,
+          isFiltered = this.isFiltered,
+          emptyText = this.emptyText,
+          emptyHtml = this.emptyHtml,
+          emptyFilteredText = this.emptyFilteredText,
+          emptyFilteredHtml = this.emptyFilteredHtml,
+          tbodyTrClass = this.tbodyTrClass,
+          tbodyTrAttr = this.tbodyTrAttr;
         $empty = this.normalizeSlot(isFiltered ? SLOT_NAME_EMPTYFILTERED : SLOT_NAME_EMPTY, {
           emptyFilteredHtml,
           emptyFilteredText,

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-filtering.js

@@ -1,7 +1,6 @@
 import { extend } from '../../../vue';
 import { NAME_TABLE } from '../../../constants/components';
 import { EVENT_NAME_FILTERED } from '../../../constants/events';
-import { PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING, PROP_TYPE_REG_EXP, PROP_TYPE_NUMBER, PROP_TYPE_FUNCTION } from '../../../constants/props';
 import { RX_SPACES, RX_DIGITS } from '../../../constants/regex';
 import { concat } from '../../../utils/array';
 import { cloneDeep } from '../../../utils/clone-deep';
@@ -21,28 +20,28 @@ const DEBOUNCE_DEPRECATED_MSG = 'Prop "filter-debounce" is deprecated. Use the d
 
 const props = {
   filter: {
-    type: [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING, PROP_TYPE_REG_EXP],
+    type: [Array, Object, String, RegExp],
     required: false,
     default: undefined
   },
   filterDebounce: {
-    type: [PROP_TYPE_NUMBER, PROP_TYPE_STRING],
+    type: [Number, String],
     required: false,
     default: 0,
     validator: value => RX_DIGITS.test(String(value))
   },
   filterFunction: {
-    type: PROP_TYPE_FUNCTION,
+    type: Function,
     required: false,
     default: undefined
   },
   filterIgnoredFields: {
-    type: PROP_TYPE_ARRAY,
+    type: Array,
     required: false,
     default: () => []
   },
   filterIncludedFields: {
-    type: PROP_TYPE_ARRAY,
+    type: Array,
     required: false,
     default: () => []
   }
@@ -82,11 +81,9 @@ const filteringMixin = extend({
     },
     // For watching changes to `filteredItems` vs `localItems`
     filteredCheck() {
-      const {
-        filteredItems,
-        localItems,
-        localFilter
-      } = this;
+      const filteredItems = this.filteredItems,
+        localItems = this.localItems,
+        localFilter = this.localFilter;
       return {
         filteredItems,
         localItems,
@@ -96,9 +93,7 @@ const filteringMixin = extend({
     // Sanitized/normalize filter-function prop
     localFilterFn() {
       // Return `null` to signal to use internal filter function
-      const {
-        filterFunction
-      } = this;
+      const filterFunction = this.filterFunction;
       // `filterFunction` is an optional Function prop with no default
       return isFunction(filterFunction) ? filterFunction : null;
     },
@@ -106,10 +101,8 @@ const filteringMixin = extend({
     // Returns the original `localItems` array if not sorting
     filteredItems() {
       // Note the criteria is debounced and sanitized
-      const {
-        localItems: items,
-        localFilter: criteria
-      } = this;
+      const items = this.localItems,
+        criteria = this.localFilter;
 
       // Resolve the filtering function, when requested
       // We prefer the provided filtering function and fallback to the internal one
@@ -150,10 +143,8 @@ const filteringMixin = extend({
     // Watch for changes to the filter criteria and filtered items vs `localItems`
     // Set visual state and emit events as required
     filteredCheck(_ref) {
-      let {
-        filteredItems,
-        localFilter
-      } = _ref;
+      let filteredItems = _ref.filteredItems,
+        localFilter = _ref.localFilter;
       // Determine if the dataset is filtered or not
       let isFiltered = false;
       if (!localFilter) {
@@ -179,9 +170,7 @@ const filteringMixin = extend({
       if (newValue === false && oldValue === true) {
         // We need to emit a filtered event if `isFiltered` transitions from `true` to
         // `false` so that users can update their pagination controls
-        const {
-          localItems
-        } = this;
+        const localItems = this.localItems;
         this.$emit(EVENT_NAME_FILTERED, localItems, localItems.length);
         // Clear selection on filter change if selectable (defined in mixin-selectable.js)
         if (this.hasSelectableRowClick) {

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-items.js

@@ -1,11 +1,9 @@
 import { extend } from '../../../vue';
-import { EVENT_NAME_CONTEXT_CHANGED } from '../../../constants/events';
-import { PROP_TYPE_ARRAY, PROP_TYPE_STRING } from '../../../constants/props';
+import { EVENT_NAME_CONTEXT_CHANGED, EVENT_NAME_INPUT } from '../../../constants/events';
 import { useParentMixin } from '../../../mixins/use-parent';
 import { isArray, isString, isFunction } from '../../../utils/inspect';
 import { looseEqual } from '../../../utils/loose-equal';
 import { mathMax } from '../../../utils/math';
-import { makeModelMixin } from '../../../utils/model';
 import { toInteger } from '../../../utils/number';
 import { sortKeys, clone } from '../../../utils/object';
 import { safeVueInstance } from '../../../utils/safe-vue-instance';
@@ -13,41 +11,33 @@ import { normalizeFields } from './normalize-fields';
 
 // --- Constants ---
 
-const {
-  mixin: modelMixin,
-  props: modelProps,
-  prop: MODEL_PROP_NAME,
-  event: MODEL_EVENT_NAME
-} = makeModelMixin('value', {
-  type: PROP_TYPE_ARRAY,
-  defaultValue: []
-});
+const MODEL_PROP_NAME = 'value';
+const MODEL_EVENT_NAME = EVENT_NAME_INPUT;
 
 // --- Props ---
 
 const props = sortKeys({
-  ...modelProps,
   fields: {
-    type: PROP_TYPE_ARRAY,
+    type: Array,
     required: false,
     default: null
   },
   // Provider mixin adds in `Function` type
   items: {
-    type: PROP_TYPE_ARRAY,
+    type: Array,
     required: false,
     default: () => []
   },
   // Primary key for record
   // If provided the value in each row must be unique!
   primaryKey: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   },
   // `v-model` for retrieving the current displayed rows
   [MODEL_PROP_NAME]: {
-    type: PROP_TYPE_ARRAY,
+    type: Array,
     required: false,
     default: () => []
   }
@@ -57,12 +47,14 @@ const props = sortKeys({
 
 // @vue/component
 const itemsMixin = extend({
-  mixins: [modelMixin, useParentMixin],
+  mixins: [useParentMixin],
+  model: {
+    prop: MODEL_PROP_NAME,
+    event: MODEL_EVENT_NAME
+  },
   props,
   data() {
-    const {
-      items
-    } = this;
+    const items = this.items;
     return {
       // Our local copy of the items
       // Must be an array
@@ -80,9 +72,7 @@ const itemsMixin = extend({
       // Mainly for formatter lookup and use in `scopedSlots` for convenience
       // If the field has a formatter, it normalizes formatter to a
       // function ref or `undefined` if no formatter
-      const {
-        bvParent
-      } = this;
+      const bvParent = this.bvParent;
       return this.computedFields.reduce((obj, f) => {
         // We use object spread here so we don't mutate the original field object
         obj[f.key] = clone(f);
@@ -102,21 +92,19 @@ const itemsMixin = extend({
       }, {});
     },
     computedItems() {
-      const {
-        paginatedItems,
-        sortedItems,
-        filteredItems,
-        localItems
-      } = safeVueInstance(this);
+      const _safeVueInstance = safeVueInstance(this),
+        paginatedItems = _safeVueInstance.paginatedItems,
+        sortedItems = _safeVueInstance.sortedItems,
+        filteredItems = _safeVueInstance.filteredItems,
+        localItems = _safeVueInstance.localItems;
       // Fallback if various mixins not provided
       return (paginatedItems || sortedItems || filteredItems || localItems || /* istanbul ignore next */
       []).slice();
     },
     context() {
-      const {
-        perPage,
-        currentPage
-      } = safeVueInstance(this);
+      const _safeVueInstance2 = safeVueInstance(this),
+        perPage = _safeVueInstance2.perPage,
+        currentPage = _safeVueInstance2.currentPage;
       // Current state of sorting, filtering and pagination props/values
       return {
         filter: this.localFilter,
@@ -166,4 +154,4 @@ const itemsMixin = extend({
   }
 });
 
-export { MODEL_EVENT_NAME, MODEL_PROP_NAME, itemsMixin, props };
+export { itemsMixin, props };

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-pagination.js

@@ -1,5 +1,4 @@
 import { extend } from '../../../vue';
-import { PROP_TYPE_NUMBER, PROP_TYPE_STRING } from '../../../constants/props';
 import { mathMax } from '../../../utils/math';
 import { toInteger } from '../../../utils/number';
 import { safeVueInstance } from '../../../utils/safe-vue-instance';
@@ -8,12 +7,12 @@ import { safeVueInstance } from '../../../utils/safe-vue-instance';
 
 const props = {
   currentPage: {
-    type: [PROP_TYPE_NUMBER, PROP_TYPE_STRING],
+    type: [Number, String],
     required: false,
     default: 1
   },
   perPage: {
-    type: [PROP_TYPE_NUMBER, PROP_TYPE_STRING],
+    type: [Number, String],
     required: false,
     default: 0
   }
@@ -29,11 +28,10 @@ const paginationMixin = extend({
       return this.hasProvider ? !!this.noProviderPaging : true;
     },
     paginatedItems() {
-      const {
-        sortedItems,
-        filteredItems,
-        localItems
-      } = safeVueInstance(this);
+      const _safeVueInstance = safeVueInstance(this),
+        sortedItems = _safeVueInstance.sortedItems,
+        filteredItems = _safeVueInstance.filteredItems,
+        localItems = _safeVueInstance.localItems;
       let items = sortedItems || filteredItems || localItems || [];
       const currentPage = mathMax(toInteger(this.currentPage, 1), 1);
       const perPage = mathMax(toInteger(this.perPage, 0), 0);

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-provider.js

@@ -1,7 +1,6 @@
 import { extend } from '../../../vue';
 import { NAME_TABLE } from '../../../constants/components';
 import { EVENT_NAME_REFRESHED, EVENT_NAME_REFRESH } from '../../../constants/events';
-import { PROP_TYPE_STRING, PROP_TYPE_ARRAY, PROP_TYPE_FUNCTION, PROP_TYPE_BOOLEAN } from '../../../constants/props';
 import { getRootEventName, getRootActionEventName } from '../../../utils/events';
 import { isFunction, isArray, isPromise } from '../../../utils/inspect';
 import { looseEqual } from '../../../utils/loose-equal';
@@ -21,28 +20,28 @@ const props = {
   // Passed to the context object
   // Not used by `<b-table>` directly
   apiUrl: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: undefined
   },
   // Adds in 'Function' support
   items: {
-    type: [PROP_TYPE_ARRAY, PROP_TYPE_FUNCTION],
+    type: [Array, Function],
     required: false,
     default: () => []
   },
   noProviderFiltering: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   },
   noProviderPaging: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   },
   noProviderSorting: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   }
@@ -116,10 +115,9 @@ const providerMixin = extend({
   },
   methods: {
     refresh() {
-      const {
-        items,
-        computedBusy
-      } = safeVueInstance(this);
+      const _safeVueInstance = safeVueInstance(this),
+        items = _safeVueInstance.items,
+        computedBusy = _safeVueInstance.computedBusy;
 
       // Public Method: Force a refresh of the provider function
       this.$_pendingRefresh = false;

package/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-selectable.js

@@ -1,6 +1,5 @@
 import { extend } from '../../../vue';
 import { EVENT_NAME_ROW_SELECTED } from '../../../constants/events';
-import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../../constants/props';
 import { createArray } from '../../../utils/array';
 import { identity } from '../../../utils/identity';
 import { isArray, isNumber } from '../../../utils/inspect';
@@ -19,23 +18,23 @@ const ROLE_GRID = 'grid';
 const props = {
   // Disable use of click handlers for row selection
   noSelectOnClick: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   },
   selectMode: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: 'multi',
     validator: value => SELECT_MODES.includes(value)
   },
   selectable: {
-    type: PROP_TYPE_BOOLEAN,
+    type: Boolean,
     required: false,
     default: false
   },
   selectedVariant: {
-    type: PROP_TYPE_STRING,
+    type: String,
     required: false,
     default: 'active'
   }
@@ -63,18 +62,14 @@ const selectableMixin = extend({
       return true;
     },
     selectableHasSelection() {
-      const {
-        selectedRows
-      } = this;
+      const selectedRows = this.selectedRows;
       return this.isSelectable && selectedRows && selectedRows.length > 0 && selectedRows.some(identity);
     },
     selectableIsMultiSelect() {
       return this.isSelectable && ['range', 'multi'].includes(this.selectMode);
     },
     selectableTableClasses() {
-      const {
-        isSelectable
-      } = this;
+      const isSelectable = this.isSelectable;
       return {
         'b-table-selectable': isSelectable,
         [`b-table-select-${this.selectMode}`]: isSelectable,
@@ -193,10 +188,8 @@ const selectableMixin = extend({
         this.clearSelected();
         return;
       }
-      const {
-        selectMode,
-        selectedLastRow
-      } = this;
+      const selectMode = this.selectMode,
+        selectedLastRow = this.selectedLastRow;
       let selectedRows = this.selectedRows.slice();
       let selected = !selectedRows[index];
       // Note 'multi' mode needs no special event handling