{"version":3,"sources":["webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-bottom-row.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-busy.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-empty.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/utils/stringify-object-values.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/sanitize-row.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-filtering.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/stringify-record-values.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-pagination.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-provider.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-selectable.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/default-sort-compare.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-sorting.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-top-row.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/table.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/table/constants.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/table/table.js"],"names":["bottomRowMixin","props","methods","computedFields","fields","stacked","tbodyTrClass","tbodyTrAttr","this","h","$createElement","hasNormalizedSlot","staticClass","class","attrs","key","normalizeSlot","columns","length","MODEL_EVENT_NAME_BUSY","busyMixin","data","localBusy","computed","watch","newValue","oldValue","$emit","event","computedBusy","colspan","emptyFilteredHtml","emptyFilteredText","emptyHtml","emptyText","showEmpty","emptyMixin","computedItems","items","$empty","isFiltered","domProps","html","role","stringifyObjectValues","value","sort","map","k","filter","v","join","sanitizeRow","row","ignoreFields","includeFields","fieldsObj","arguments","undefined","formattedRow","reduce","result","field","filterByFormatted","formatter","allowedKeys","array","filterDebounce","test","String","filterFunction","filterIgnoredFields","filterIncludedFields","filteringMixin","localFilter","filterSanitize","identity","ms","warn","hasProvider","noProviderFiltering","filteredItems","localItems","criteria","filterFn","localFiltering","filterFnFactory","localFilterFn","defaultFilterFnFactory","$_filterTimer","clearFilterTimer","deep","newCriteria","timeout","computedFilterDebounce","setTimeout","_ref","$nextTick","Boolean","clearTimeout","item","regExp","pattern","replace","RegExp","lastIndex","computedFilterIgnored","computedFilterIncluded","computedFieldsObj","currentPage","perPage","paginationMixin","noProviderPaging","sortedItems","math","localPaging","slice","ROOT_EVENT_NAME_REFRESHED","ROOT_ACTION_EVENT_NAME_REFRESH","apiUrl","noProviderSorting","providerMixin","mixins","ctx","sortBy","sortDesc","localSortBy","localSortDesc","_providerUpdate","listenOnRoot","id","refresh","$off","$on","clearSelected","emitOnRoot","context","_providerSetLocal","then","e","name","message","SELECT_MODES","noSelectOnClick","selectMode","selectable","selectedVariant","selectableMixin","selectedRows","selectedLastRow","isSelectable","supportsSelectableRows","some","selectableHasSelection","hasSelectableRowClick","bvAttrs","selectableIsMultiSelect","equal","i","setSelectionHandlers","forEach","idx","push","index","isRowSelected","selectedLastClicked","variant","dark","on","method","selectionHandler","selected","shiftKey","ctrlKey","metaKey","normalizeValue","MODEL_EVENT_NAME_SORT_BY","MODEL_EVENT_NAME_SORT_DESC","SORT_DIRECTIONS","labelSortAsc","labelSortClear","labelSortDesc","noFooterSorting","noLocalSorting","noSortReset","sortCompare","sortCompareLocale","sortCompareOptions","numeric","sortDirection","sortIconLeft","sortNullLast","sortingMixin","f","sortable","locale","nullLast","localSorting","localeOptions","usage","sortByFormatted","getFieldFormatter","a","b","aa","get","bb","localeCompare","defaultSortCompare","isSortable","handleSort","isFoot","sortChanged","toggleLocalSortDesc","sortKey","_field$sortKey","labelSorting","topRowMixin","BTable","tableFullSlots","tableFullProps","tableClass","options","__vue_script__","components","inheritAttrs","type","Array","required","default","stickyHeader","stickyHeaderClass","Object","keys","$scopedSlots","slotName","startsWith","_this$fields","thAlignRight","thClass","rest","computedThClass","isArray","split","$attrs","prop","slot","shouldUseFullTable","$el","_ref2","_ref3","_ref4","activeSortingColumn","__vue_component__","render","_vm","_h","_c","_self","_g","_b","localTableClass","$event","scopedSlots","_u","_l","fn","scope","_t","headSlotName","_v","_s","label","getSortingIcon","_e","$listeners","staticRenderFns"],"mappings":"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","file":"68.9d853268.chunk.js","sourcesContent":["import { extend } from '../../../vue';\nimport { SLOT_NAME_BOTTOM_ROW } from '../../../constants/slots';\nimport { isFunction } from '../../../utils/inspect';\nimport { BTr } from '../tr';\n\n// --- Props ---\n\nconst props = {};\n\n// --- Mixin ---\n\n// @vue/component\nconst bottomRowMixin = extend({\n  props,\n  methods: {\n    renderBottomRow() {\n      const {\n        computedFields: fields,\n        stacked,\n        tbodyTrClass,\n        tbodyTrAttr\n      } = this;\n      const h = this.$createElement;\n\n      // Static bottom row slot (hidden in visibly stacked mode as we can't control the data-label)\n      // If in *always* stacked mode, we don't bother rendering the row\n      if (!this.hasNormalizedSlot(SLOT_NAME_BOTTOM_ROW) || stacked === true || stacked === '') {\n        return h();\n      }\n      return h(BTr, {\n        staticClass: 'b-table-bottom-row',\n        class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, 'row-bottom') : tbodyTrClass],\n        attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, 'row-bottom') : tbodyTrAttr,\n        key: 'b-bottom-row'\n      }, this.normalizeSlot(SLOT_NAME_BOTTOM_ROW, {\n        columns: fields.length,\n        fields\n      }));\n    }\n  }\n});\n\nexport { bottomRowMixin, props };\n","import { extend } from '../../../vue';\nimport { MODEL_EVENT_NAME_PREFIX } from '../../../constants/events';\nimport { PROP_TYPE_BOOLEAN } from '../../../constants/props';\nimport { SLOT_NAME_TABLE_BUSY } from '../../../constants/slots';\nimport { stopEvent } from '../../../utils/events';\nimport { isFunction } from '../../../utils/inspect';\nimport { makeProp } from '../../../utils/props';\nimport { BTr } from '../tr';\nimport { BTd } from '../td';\n\n// --- Constants ---\n\nconst MODEL_PROP_NAME_BUSY = 'busy';\nconst MODEL_EVENT_NAME_BUSY = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_BUSY;\n\n// --- Props ---\n\nconst props = {\n  [MODEL_PROP_NAME_BUSY]: makeProp(PROP_TYPE_BOOLEAN, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst busyMixin = extend({\n  props,\n  data() {\n    return {\n      localBusy: false\n    };\n  },\n  computed: {\n    computedBusy() {\n      return this[MODEL_PROP_NAME_BUSY] || this.localBusy;\n    }\n  },\n  watch: {\n    localBusy(newValue, oldValue) {\n      if (newValue !== oldValue) {\n        this.$emit(MODEL_EVENT_NAME_BUSY, newValue);\n      }\n    }\n  },\n  methods: {\n    // Event handler helper\n    stopIfBusy(event) {\n      // If table is busy (via provider) then don't propagate\n      if (this.computedBusy) {\n        stopEvent(event);\n        return true;\n      }\n      return false;\n    },\n    // Render the busy indicator or return `null` if not busy\n    renderBusy() {\n      const {\n        tbodyTrClass,\n        tbodyTrAttr\n      } = this;\n      const h = this.$createElement;\n\n      // Return a busy indicator row, or `null` if not busy\n      if (this.computedBusy && this.hasNormalizedSlot(SLOT_NAME_TABLE_BUSY)) {\n        return h(BTr, {\n          staticClass: 'b-table-busy-slot',\n          class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, SLOT_NAME_TABLE_BUSY) : tbodyTrClass],\n          attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, SLOT_NAME_TABLE_BUSY) : tbodyTrAttr,\n          key: 'table-busy-slot'\n        }, [h(BTd, {\n          props: {\n            colspan: this.computedFields.length || null\n          }\n        }, [this.normalizeSlot(SLOT_NAME_TABLE_BUSY)])]);\n      }\n\n      // We return `null` here so that we can determine if we need to\n      // render the table items rows or not\n      return null;\n    }\n  }\n});\n\nexport { busyMixin, props };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../../constants/props';\nimport { SLOT_NAME_TABLE_BUSY, SLOT_NAME_EMPTYFILTERED, SLOT_NAME_EMPTY } from '../../../constants/slots';\nimport { htmlOrText } from '../../../utils/html';\nimport { isFunction } from '../../../utils/inspect';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { BTr } from '../tr';\nimport { BTd } from '../td';\n\n// --- Props ---\n\nconst props = {\n  emptyFilteredHtml: makeProp(PROP_TYPE_STRING),\n  emptyFilteredText: makeProp(PROP_TYPE_STRING, 'There are no records matching your request'),\n  emptyHtml: makeProp(PROP_TYPE_STRING),\n  emptyText: makeProp(PROP_TYPE_STRING, 'There are no records to show'),\n  showEmpty: makeProp(PROP_TYPE_BOOLEAN, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst emptyMixin = extend({\n  props,\n  methods: {\n    renderEmpty() {\n      const {\n        computedItems: items,\n        computedBusy\n      } = safeVueInstance(this);\n      const h = this.$createElement;\n      let $empty = h();\n      if (this.showEmpty && (!items || items.length === 0) && !(computedBusy && this.hasNormalizedSlot(SLOT_NAME_TABLE_BUSY))) {\n        const {\n          computedFields: fields,\n          isFiltered,\n          emptyText,\n          emptyHtml,\n          emptyFilteredText,\n          emptyFilteredHtml,\n          tbodyTrClass,\n          tbodyTrAttr\n        } = this;\n        $empty = this.normalizeSlot(isFiltered ? SLOT_NAME_EMPTYFILTERED : SLOT_NAME_EMPTY, {\n          emptyFilteredHtml,\n          emptyFilteredText,\n          emptyHtml,\n          emptyText,\n          fields,\n          // Not sure why this is included, as it will always be an empty array\n          items\n        });\n        if (!$empty) {\n          $empty = h('div', {\n            class: ['gl-text-center', 'gl-my-3'],\n            domProps: isFiltered ? htmlOrText(emptyFilteredHtml, emptyFilteredText) : htmlOrText(emptyHtml, emptyText)\n          });\n        }\n        $empty = h(BTd, {\n          props: {\n            colspan: fields.length || null\n          }\n        }, [h('div', {\n          attrs: {\n            role: 'alert',\n            'aria-live': 'polite'\n          }\n        }, [$empty])]);\n        $empty = h(BTr, {\n          staticClass: 'b-table-empty-row',\n          class: [isFunction(tbodyTrClass) ? /* istanbul ignore next */tbodyTrClass(null, 'row-empty') : tbodyTrClass],\n          attrs: isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(null, 'row-empty') : tbodyTrAttr,\n          key: isFiltered ? 'b-empty-filtered-row' : 'b-empty-row'\n        }, [$empty]);\n      }\n      return $empty;\n    }\n  }\n});\n\nexport { emptyMixin, props };\n","import { isUndefinedOrNull, isObject, isDate } from './inspect';\nimport { keys } from './object';\nimport { toString } from './string';\n\n// Recursively stringifies the values of an object, space separated, in an\n// SSR safe deterministic way (keys are sorted before stringification)\n//\n//   ex:\n//     { b: 3, c: { z: 'zzz', d: null, e: 2 }, d: [10, 12, 11], a: 'one' }\n//   becomes\n//     'one 3 2 zzz 10 12 11'\n//\n// Strings are returned as-is\n// Numbers get converted to string\n// `null` and `undefined` values are filtered out\n// Dates are converted to their native string format\nconst stringifyObjectValues = value => {\n  if (isUndefinedOrNull(value)) {\n    return '';\n  }\n  // Arrays are also object, and keys just returns the array indexes\n  // Date objects we convert to strings\n  if (isObject(value) && !isDate(value)) {\n    return keys(value).sort() // Sort to prevent SSR issues on pre-rendered sorted tables\n    .map(k => stringifyObjectValues(value[k])).filter(v => !!v) // Ignore empty strings\n    .join(' ');\n  }\n  return toString(value);\n};\n\nexport { stringifyObjectValues };\n","import { arrayIncludes } from '../../../utils/array';\nimport { isFunction, isArray } from '../../../utils/inspect';\nimport { keys, clone, pick } from '../../../utils/object';\nimport { IGNORED_FIELD_KEYS } from './constants';\n\n// Return a copy of a row after all reserved fields have been filtered out\nconst sanitizeRow = function (row, ignoreFields, includeFields) {\n  let fieldsObj = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  // We first need to format the row based on the field configurations\n  // This ensures that we add formatted values for keys that may not\n  // exist in the row itself\n  const formattedRow = keys(fieldsObj).reduce((result, key) => {\n    const field = fieldsObj[key];\n    const {\n      filterByFormatted\n    } = field;\n    const formatter = isFunction(filterByFormatted) ? /* istanbul ignore next */filterByFormatted : filterByFormatted ? /* istanbul ignore next */field.formatter : null;\n    if (isFunction(formatter)) {\n      result[key] = formatter(row[key], key, row);\n    }\n    return result;\n  }, clone(row));\n\n  // Determine the allowed keys:\n  //   - Ignore special fields that start with `_`\n  //   - Ignore fields in the `ignoreFields` array\n  //   - Include only fields in the `includeFields` array\n  const allowedKeys = keys(formattedRow).filter(key => !IGNORED_FIELD_KEYS[key] && !(isArray(ignoreFields) && ignoreFields.length > 0 && arrayIncludes(ignoreFields, key)) && !(isArray(includeFields) && includeFields.length > 0 && !arrayIncludes(includeFields, key)));\n  return pick(formattedRow, allowedKeys);\n};\n\nexport { sanitizeRow };\n","import { extend } from '../../../vue';\nimport { NAME_TABLE } from '../../../constants/components';\nimport { EVENT_NAME_FILTERED } from '../../../constants/events';\nimport { PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_REG_EXP, PROP_TYPE_NUMBER_STRING, PROP_TYPE_FUNCTION, PROP_TYPE_ARRAY } from '../../../constants/props';\nimport { RX_DIGITS, RX_SPACES } from '../../../constants/regex';\nimport { concat } from '../../../utils/array';\nimport { cloneDeep } from '../../../utils/clone-deep';\nimport { identity } from '../../../utils/identity';\nimport { isString, isRegExp, isFunction } from '../../../utils/inspect';\nimport { looseEqual } from '../../../utils/loose-equal';\nimport { toInteger } from '../../../utils/number';\nimport { makeProp, hasPropFunction } from '../../../utils/props';\nimport { escapeRegExp } from '../../../utils/string';\nimport { warn } from '../../../utils/warn';\nimport { stringifyRecordValues } from './stringify-record-values';\n\n// --- Constants ---\n\nconst DEBOUNCE_DEPRECATED_MSG = 'Prop \"filter-debounce\" is deprecated. Use the debounce feature of \"<b-form-input>\" instead.';\n\n// --- Props ---\n\nconst props = {\n  filter: makeProp([...PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_REG_EXP]),\n  filterDebounce: makeProp(PROP_TYPE_NUMBER_STRING, 0, value => {\n    return RX_DIGITS.test(String(value));\n  }),\n  filterFunction: makeProp(PROP_TYPE_FUNCTION),\n  filterIgnoredFields: makeProp(PROP_TYPE_ARRAY, []),\n  filterIncludedFields: makeProp(PROP_TYPE_ARRAY, [])\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst filteringMixin = extend({\n  props,\n  data() {\n    return {\n      // Flag for displaying which empty slot to show and some event triggering\n      isFiltered: false,\n      // Where we store the copy of the filter criteria after debouncing\n      // We pre-set it with the sanitized filter value\n      localFilter: this.filterSanitize(this.filter)\n    };\n  },\n  computed: {\n    computedFilterIgnored() {\n      return concat(this.filterIgnoredFields || []).filter(identity);\n    },\n    computedFilterIncluded() {\n      return concat(this.filterIncludedFields || []).filter(identity);\n    },\n    computedFilterDebounce() {\n      const ms = toInteger(this.filterDebounce, 0);\n      /* istanbul ignore next */\n      if (ms > 0) {\n        warn(DEBOUNCE_DEPRECATED_MSG, NAME_TABLE);\n      }\n      return ms;\n    },\n    localFiltering() {\n      return this.hasProvider ? !!this.noProviderFiltering : true;\n    },\n    // For watching changes to `filteredItems` vs `localItems`\n    filteredCheck() {\n      const {\n        filteredItems,\n        localItems,\n        localFilter\n      } = this;\n      return {\n        filteredItems,\n        localItems,\n        localFilter\n      };\n    },\n    // Sanitized/normalize filter-function prop\n    localFilterFn() {\n      // Return `null` to signal to use internal filter function\n      const {\n        filterFunction\n      } = this;\n      return hasPropFunction(filterFunction) ? filterFunction : null;\n    },\n    // Returns the records in `localItems` that match the filter criteria\n    // Returns the original `localItems` array if not sorting\n    filteredItems() {\n      // Note the criteria is debounced and sanitized\n      const {\n        localItems: items,\n        localFilter: criteria\n      } = this;\n\n      // Resolve the filtering function, when requested\n      // We prefer the provided filtering function and fallback to the internal one\n      // When no filtering criteria is specified the filtering factories will return `null`\n      const filterFn = this.localFiltering ? this.filterFnFactory(this.localFilterFn, criteria) || this.defaultFilterFnFactory(criteria) : null;\n\n      // We only do local filtering when requested and there are records to filter\n      return filterFn && items.length > 0 ? items.filter(filterFn) : items;\n    }\n  },\n  watch: {\n    // Watch for debounce being set to 0\n    computedFilterDebounce(newValue) {\n      if (!newValue && this.$_filterTimer) {\n        this.clearFilterTimer();\n        this.localFilter = this.filterSanitize(this.filter);\n      }\n    },\n    // Watch for changes to the filter criteria, and debounce if necessary\n    filter: {\n      // We need a deep watcher in case the user passes\n      // an object when using `filter-function`\n      deep: true,\n      handler(newCriteria) {\n        const timeout = this.computedFilterDebounce;\n        this.clearFilterTimer();\n        if (timeout && timeout > 0) {\n          // If we have a debounce time, delay the update of `localFilter`\n          this.$_filterTimer = setTimeout(() => {\n            this.localFilter = this.filterSanitize(newCriteria);\n          }, timeout);\n        } else {\n          // Otherwise, immediately update `localFilter` with `newFilter` value\n          this.localFilter = this.filterSanitize(newCriteria);\n        }\n      }\n    },\n    // Watch for changes to the filter criteria and filtered items vs `localItems`\n    // Set visual state and emit events as required\n    filteredCheck(_ref) {\n      let {\n        filteredItems,\n        localFilter\n      } = _ref;\n      // Determine if the dataset is filtered or not\n      let isFiltered = false;\n      if (!localFilter) {\n        // If filter criteria is falsey\n        isFiltered = false;\n      } else if (looseEqual(localFilter, []) || looseEqual(localFilter, {})) {\n        // If filter criteria is an empty array or object\n        isFiltered = false;\n      } else if (localFilter) {\n        // If filter criteria is truthy\n        isFiltered = true;\n      }\n      if (isFiltered) {\n        this.$emit(EVENT_NAME_FILTERED, filteredItems, filteredItems.length);\n      }\n      this.isFiltered = isFiltered;\n    },\n    isFiltered(newValue, oldValue) {\n      if (newValue === false && oldValue === true) {\n        // We need to emit a filtered event if `isFiltered` transitions from `true` to\n        // `false` so that users can update their pagination controls\n        const {\n          localItems\n        } = this;\n        this.$emit(EVENT_NAME_FILTERED, localItems, localItems.length);\n      }\n    }\n  },\n  created() {\n    // Create private non-reactive props\n    this.$_filterTimer = null;\n    // If filter is \"pre-set\", set the criteria\n    // This will trigger any watchers/dependents\n    // this.localFilter = this.filterSanitize(this.filter)\n    // Set the initial filtered state in a `$nextTick()` so that\n    // we trigger a filtered event if needed\n    this.$nextTick(() => {\n      this.isFiltered = Boolean(this.localFilter);\n    });\n  },\n  beforeDestroy() {\n    this.clearFilterTimer();\n  },\n  methods: {\n    clearFilterTimer() {\n      clearTimeout(this.$_filterTimer);\n      this.$_filterTimer = null;\n    },\n    filterSanitize(criteria) {\n      // Sanitizes filter criteria based on internal or external filtering\n      if (this.localFiltering && !this.localFilterFn && !(isString(criteria) || isRegExp(criteria))) {\n        // If using internal filter function, which only accepts string or RegExp,\n        // return '' to signify no filter\n        return '';\n      }\n\n      // Could be a string, object or array, as needed by external filter function\n      // We use `cloneDeep` to ensure we have a new copy of an object or array\n      // without Vue's reactive observers\n      return cloneDeep(criteria);\n    },\n    // Filter Function factories\n    filterFnFactory(filterFn, criteria) {\n      // Wrapper factory for external filter functions\n      // Wrap the provided filter-function and return a new function\n      // Returns `null` if no filter-function defined or if criteria is falsey\n      // Rather than directly grabbing `this.computedLocalFilterFn` or `this.filterFunction`\n      // we have it passed, so that the caller computed prop will be reactive to changes\n      // in the original filter-function (as this routine is a method)\n      if (!filterFn || !isFunction(filterFn) || !criteria || looseEqual(criteria, []) || looseEqual(criteria, {})) {\n        return null;\n      }\n\n      // Build the wrapped filter test function, passing the criteria to the provided function\n      const fn = item => {\n        // Generated function returns true if the criteria matches part\n        // of the serialized data, otherwise false\n        return filterFn(item, criteria);\n      };\n\n      // Return the wrapped function\n      return fn;\n    },\n    defaultFilterFnFactory(criteria) {\n      // Generates the default filter function, using the given filter criteria\n      // Returns `null` if no criteria or criteria format not supported\n      if (!criteria || !(isString(criteria) || isRegExp(criteria))) {\n        // Built in filter can only support strings or RegExp criteria (at the moment)\n        return null;\n      }\n\n      // Build the RegExp needed for filtering\n      let regExp = criteria;\n      if (isString(regExp)) {\n        // Escape special RegExp characters in the string and convert contiguous\n        // whitespace to \\s+ matches\n        const pattern = escapeRegExp(criteria).replace(RX_SPACES, '\\\\s+');\n        // Build the RegExp (no need for global flag, as we only need\n        // to find the value once in the string)\n        regExp = new RegExp(`.*${pattern}.*`, 'i');\n      }\n\n      // Generate the wrapped filter test function to use\n      const fn = item => {\n        // This searches all row values (and sub property values) in the entire (excluding\n        // special `_` prefixed keys), because we convert the record to a space-separated\n        // string containing all the value properties (recursively), even ones that are\n        // not visible (not specified in this.fields)\n        // Users can ignore filtering on specific fields, or on only certain fields,\n        // and can optionall specify searching results of fields with formatter\n        //\n        // TODO: Enable searching on scoped slots (optional, as it will be SLOW)\n        //\n        // Generated function returns true if the criteria matches part of\n        // the serialized data, otherwise false\n        //\n        // We set `lastIndex = 0` on the `RegExp` in case someone specifies the `/g` global flag\n        regExp.lastIndex = 0;\n        return regExp.test(stringifyRecordValues(item, this.computedFilterIgnored, this.computedFilterIncluded, this.computedFieldsObj));\n      };\n\n      // Return the generated function\n      return fn;\n    }\n  }\n});\n\nexport { filteringMixin, props };\n","import { isObject } from '../../../utils/inspect';\nimport { stringifyObjectValues } from '../../../utils/stringify-object-values';\nimport { sanitizeRow } from './sanitize-row';\n\n// Stringifies the values of a record, ignoring any special top level field keys\n// TODO: Add option to stringify `scopedSlot` items\nconst stringifyRecordValues = (row, ignoreFields, includeFields, fieldsObj) => {\n  return isObject(row) ? stringifyObjectValues(sanitizeRow(row, ignoreFields, includeFields, fieldsObj)) : /* istanbul ignore next */'';\n};\n\nexport { stringifyRecordValues };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_NUMBER_STRING } from '../../../constants/props';\nimport { mathMax } from '../../../utils/math';\nimport { toInteger } from '../../../utils/number';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\n\n// --- Props ---\n\nconst props = {\n  currentPage: makeProp(PROP_TYPE_NUMBER_STRING, 1),\n  perPage: makeProp(PROP_TYPE_NUMBER_STRING, 0)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst paginationMixin = extend({\n  props,\n  computed: {\n    localPaging() {\n      return this.hasProvider ? !!this.noProviderPaging : true;\n    },\n    paginatedItems() {\n      const {\n        sortedItems,\n        filteredItems,\n        localItems\n      } = safeVueInstance(this);\n      let items = sortedItems || filteredItems || localItems || [];\n      const currentPage = mathMax(toInteger(this.currentPage, 1), 1);\n      const perPage = mathMax(toInteger(this.perPage, 0), 0);\n      // Apply local pagination\n      if (this.localPaging && perPage) {\n        // Grab the current page of data (which may be past filtered items limit)\n        items = items.slice((currentPage - 1) * perPage, currentPage * perPage);\n      }\n      // Return the items to display in the table\n      return items;\n    }\n  }\n});\n\nexport { paginationMixin, props };\n","import { extend } from '../../../vue';\nimport { NAME_TABLE } from '../../../constants/components';\nimport { EVENT_NAME_REFRESHED, EVENT_NAME_REFRESH } from '../../../constants/events';\nimport { PROP_TYPE_STRING, PROP_TYPE_ARRAY_FUNCTION, PROP_TYPE_BOOLEAN } from '../../../constants/props';\nimport { getRootEventName, getRootActionEventName } from '../../../utils/events';\nimport { isFunction, isArray, isPromise } from '../../../utils/inspect';\nimport { looseEqual } from '../../../utils/loose-equal';\nimport { clone } from '../../../utils/object';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { warn } from '../../../utils/warn';\nimport { listenOnRootMixin } from '../../../mixins/listen-on-root';\n\n// --- Constants ---\n\nconst ROOT_EVENT_NAME_REFRESHED = getRootEventName(NAME_TABLE, EVENT_NAME_REFRESHED);\nconst ROOT_ACTION_EVENT_NAME_REFRESH = getRootActionEventName(NAME_TABLE, EVENT_NAME_REFRESH);\n\n// --- Props ---\n\nconst props = {\n  // Passed to the context object\n  // Not used by `<b-table>` directly\n  apiUrl: makeProp(PROP_TYPE_STRING),\n  // Adds in 'Function' support\n  items: makeProp(PROP_TYPE_ARRAY_FUNCTION, []),\n  noProviderFiltering: makeProp(PROP_TYPE_BOOLEAN, false),\n  noProviderPaging: makeProp(PROP_TYPE_BOOLEAN, false),\n  noProviderSorting: makeProp(PROP_TYPE_BOOLEAN, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst providerMixin = extend({\n  mixins: [listenOnRootMixin],\n  props,\n  computed: {\n    hasProvider() {\n      return isFunction(this.items);\n    },\n    providerTriggerContext() {\n      // Used to trigger the provider function via a watcher. Only the fields that\n      // are needed for triggering a provider update are included. Note that the\n      // regular this.context is sent to the provider during fetches though, as they\n      // may need all the prop info.\n      const ctx = {\n        apiUrl: this.apiUrl,\n        filter: null,\n        sortBy: null,\n        sortDesc: null,\n        perPage: null,\n        currentPage: null\n      };\n      if (!this.noProviderFiltering) {\n        // Either a string, or could be an object or array.\n        ctx.filter = this.localFilter;\n      }\n      if (!this.noProviderSorting) {\n        ctx.sortBy = this.localSortBy;\n        ctx.sortDesc = this.localSortDesc;\n      }\n      if (!this.noProviderPaging) {\n        ctx.perPage = this.perPage;\n        ctx.currentPage = this.currentPage;\n      }\n      return clone(ctx);\n    }\n  },\n  watch: {\n    // Provider update triggering\n    items(newValue) {\n      // If a new provider has been specified, trigger an update\n      if (this.hasProvider || isFunction(newValue)) {\n        this.$nextTick(this._providerUpdate);\n      }\n    },\n    providerTriggerContext(newValue, oldValue) {\n      // Trigger the provider to update as the relevant context values have changed.\n      if (!looseEqual(newValue, oldValue)) {\n        this.$nextTick(this._providerUpdate);\n      }\n    }\n  },\n  mounted() {\n    // Call the items provider if necessary\n    if (this.hasProvider && (!this.localItems || this.localItems.length === 0)) {\n      // Fetch on mount if localItems is empty\n      this._providerUpdate();\n    }\n    // Listen for global messages to tell us to force refresh the table\n    this.listenOnRoot(ROOT_ACTION_EVENT_NAME_REFRESH, id => {\n      if (id === this.id || id === this) {\n        this.refresh();\n      }\n    });\n  },\n  methods: {\n    refresh() {\n      const {\n        items,\n        refresh,\n        computedBusy\n      } = safeVueInstance(this);\n\n      // Public Method: Force a refresh of the provider function\n      this.$off(EVENT_NAME_REFRESHED, refresh);\n      if (computedBusy) {\n        // Can't force an update when forced busy by user (busy prop === true)\n        if (this.localBusy && this.hasProvider) {\n          // But if provider running (localBusy), re-schedule refresh once `refreshed` emitted\n          this.$on(EVENT_NAME_REFRESHED, refresh);\n        }\n      } else {\n        this.clearSelected();\n        if (this.hasProvider) {\n          this.$nextTick(this._providerUpdate);\n        } else {\n          /* istanbul ignore next */\n          this.localItems = isArray(items) ? items.slice() : [];\n        }\n      }\n    },\n    // Provider related methods\n    _providerSetLocal(items) {\n      this.localItems = isArray(items) ? items.slice() : [];\n      this.localBusy = false;\n      this.$emit(EVENT_NAME_REFRESHED);\n      // New root emit\n      if (this.id) {\n        this.emitOnRoot(ROOT_EVENT_NAME_REFRESHED, this.id);\n      }\n    },\n    _providerUpdate() {\n      // Refresh the provider function items.\n      if (!this.hasProvider) {\n        // Do nothing if no provider\n        return;\n      }\n      // If table is busy, wait until refreshed before calling again\n      if (safeVueInstance(this).computedBusy) {\n        // Schedule a new refresh once `refreshed` is emitted\n        this.$nextTick(this.refresh);\n        return;\n      }\n\n      // Set internal busy state\n      this.localBusy = true;\n\n      // Call provider function with context and optional callback after DOM is fully updated\n      this.$nextTick(() => {\n        try {\n          // Call provider function passing it the context and optional callback\n          const data = this.items(this.context, this._providerSetLocal);\n          if (isPromise(data)) {\n            // Provider returned Promise\n            data.then(items => {\n              // Provider resolved with items\n              this._providerSetLocal(items);\n            });\n          } else if (isArray(data)) {\n            // Provider returned Array data\n            this._providerSetLocal(data);\n          } else {\n            /* istanbul ignore if */\n            if (this.items.length !== 2) {\n              // Check number of arguments provider function requested\n              // Provider not using callback (didn't request second argument), so we clear\n              // busy state as most likely there was an error in the provider function\n              /* istanbul ignore next */\n              warn(\"Provider function didn't request callback and did not return a promise or data.\", NAME_TABLE);\n              this.localBusy = false;\n            }\n          }\n        } catch (e) /* istanbul ignore next */{\n          // Provider function borked on us, so we spew out a warning\n          // and clear the busy state\n          warn(`Provider function error [${e.name}] ${e.message}.`, NAME_TABLE);\n          this.localBusy = false;\n          this.$off(EVENT_NAME_REFRESHED, this.refresh);\n        }\n      });\n    }\n  }\n});\n\nexport { props, providerMixin };\n","import { extend } from '../../../vue';\nimport { EVENT_NAME_ROW_SELECTED, EVENT_NAME_ROW_CLICKED, EVENT_NAME_FILTERED, EVENT_NAME_CONTEXT_CHANGED } from '../../../constants/events';\nimport { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../../constants/props';\nimport { arrayIncludes, createArray } from '../../../utils/array';\nimport { identity } from '../../../utils/identity';\nimport { isArray, isNumber } from '../../../utils/inspect';\nimport { looseEqual } from '../../../utils/loose-equal';\nimport { mathMin, mathMax } from '../../../utils/math';\nimport { makeProp } from '../../../utils/props';\nimport { toString } from '../../../utils/string';\nimport { sanitizeRow } from './sanitize-row';\n\n// --- Constants ---\n\nconst SELECT_MODES = ['range', 'multi', 'single'];\nconst ROLE_GRID = 'grid';\n\n// --- Props ---\n\nconst props = {\n  // Disable use of click handlers for row selection\n  noSelectOnClick: makeProp(PROP_TYPE_BOOLEAN, false),\n  selectMode: makeProp(PROP_TYPE_STRING, 'multi', value => {\n    return arrayIncludes(SELECT_MODES, value);\n  }),\n  selectable: makeProp(PROP_TYPE_BOOLEAN, false),\n  selectedVariant: makeProp(PROP_TYPE_STRING, 'active')\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst selectableMixin = extend({\n  props,\n  data() {\n    return {\n      selectedRows: [],\n      selectedLastRow: -1\n    };\n  },\n  computed: {\n    isSelectable() {\n      return this.selectable && this.selectMode;\n    },\n    hasSelectableRowClick() {\n      return this.isSelectable && !this.noSelectOnClick;\n    },\n    supportsSelectableRows() {\n      return true;\n    },\n    selectableHasSelection() {\n      const {\n        selectedRows\n      } = this;\n      return this.isSelectable && selectedRows && selectedRows.length > 0 && selectedRows.some(identity);\n    },\n    selectableIsMultiSelect() {\n      return this.isSelectable && arrayIncludes(['range', 'multi'], this.selectMode);\n    },\n    selectableTableClasses() {\n      const {\n        isSelectable\n      } = this;\n      return {\n        'b-table-selectable': isSelectable,\n        [`b-table-select-${this.selectMode}`]: isSelectable,\n        'b-table-selecting': this.selectableHasSelection,\n        'b-table-selectable-no-click': isSelectable && !this.hasSelectableRowClick\n      };\n    },\n    selectableTableAttrs() {\n      if (!this.isSelectable) {\n        return {};\n      }\n      const role = this.bvAttrs.role || ROLE_GRID;\n      return {\n        role,\n        // TODO:\n        //   Should this attribute not be included when `no-select-on-click` is set\n        //   since this attribute implies keyboard navigation?\n        'aria-multiselectable': role === ROLE_GRID ? toString(this.selectableIsMultiSelect) : null\n      };\n    }\n  },\n  watch: {\n    computedItems(newValue, oldValue) {\n      // Reset for selectable\n      let equal = false;\n      if (this.isSelectable && this.selectedRows.length > 0) {\n        // Quick check against array length\n        equal = isArray(newValue) && isArray(oldValue) && newValue.length === oldValue.length;\n        for (let i = 0; equal && i < newValue.length; i++) {\n          // Look for the first non-loosely equal row, after ignoring reserved fields\n          equal = looseEqual(sanitizeRow(newValue[i]), sanitizeRow(oldValue[i]));\n        }\n      }\n      if (!equal) {\n        this.clearSelected();\n      }\n    },\n    selectable(newValue) {\n      this.clearSelected();\n      this.setSelectionHandlers(newValue);\n    },\n    selectMode() {\n      this.clearSelected();\n    },\n    hasSelectableRowClick(newValue) {\n      this.clearSelected();\n      this.setSelectionHandlers(!newValue);\n    },\n    selectedRows(selectedRows, oldValue) {\n      if (this.isSelectable && !looseEqual(selectedRows, oldValue)) {\n        const items = [];\n        // `.forEach()` skips over non-existent indices (on sparse arrays)\n        selectedRows.forEach((v, idx) => {\n          if (v) {\n            items.push(this.computedItems[idx]);\n          }\n        });\n        this.$emit(EVENT_NAME_ROW_SELECTED, items);\n      }\n    }\n  },\n  beforeMount() {\n    // Set up handlers if needed\n    if (this.isSelectable) {\n      this.setSelectionHandlers(true);\n    }\n  },\n  methods: {\n    // Public methods\n    selectRow(index) {\n      // Select a particular row (indexed based on computedItems)\n      if (this.isSelectable && isNumber(index) && index >= 0 && index < this.computedItems.length && !this.isRowSelected(index)) {\n        const selectedRows = this.selectableIsMultiSelect ? this.selectedRows.slice() : [];\n        selectedRows[index] = true;\n        this.selectedLastClicked = -1;\n        this.selectedRows = selectedRows;\n      }\n    },\n    unselectRow(index) {\n      // Un-select a particular row (indexed based on `computedItems`)\n      if (this.isSelectable && isNumber(index) && this.isRowSelected(index)) {\n        const selectedRows = this.selectedRows.slice();\n        selectedRows[index] = false;\n        this.selectedLastClicked = -1;\n        this.selectedRows = selectedRows;\n      }\n    },\n    selectAllRows() {\n      const length = this.computedItems.length;\n      if (this.isSelectable && length > 0) {\n        this.selectedLastClicked = -1;\n        this.selectedRows = this.selectableIsMultiSelect ? createArray(length, true) : [true];\n      }\n    },\n    isRowSelected(index) {\n      // Determine if a row is selected (indexed based on `computedItems`)\n      return !!(isNumber(index) && this.selectedRows[index]);\n    },\n    clearSelected() {\n      // Clear any active selected row(s)\n      this.selectedLastClicked = -1;\n      this.selectedRows = [];\n    },\n    // Internal private methods\n    selectableRowClasses(index) {\n      if (this.isSelectable && this.isRowSelected(index)) {\n        const variant = this.selectedVariant;\n        return {\n          'b-table-row-selected': true,\n          [`${this.dark ? 'bg' : 'table'}-${variant}`]: variant\n        };\n      }\n      return {};\n    },\n    selectableRowAttrs(index) {\n      return {\n        'aria-selected': !this.isSelectable ? null : this.isRowSelected(index) ? 'true' : 'false'\n      };\n    },\n    setSelectionHandlers(on) {\n      const method = on && !this.noSelectOnClick ? '$on' : '$off';\n      // Handle row-clicked event\n      this[method](EVENT_NAME_ROW_CLICKED, this.selectionHandler);\n      // Clear selection on filter, pagination, and sort changes\n      this[method](EVENT_NAME_FILTERED, this.clearSelected);\n      this[method](EVENT_NAME_CONTEXT_CHANGED, this.clearSelected);\n    },\n    selectionHandler(item, index, event) {\n      /* istanbul ignore if: should never happen */\n      if (!this.isSelectable || this.noSelectOnClick) {\n        // Don't do anything if table is not in selectable mode\n        this.clearSelected();\n        return;\n      }\n      const {\n        selectMode,\n        selectedLastRow\n      } = this;\n      let selectedRows = this.selectedRows.slice();\n      let selected = !selectedRows[index];\n      // Note 'multi' mode needs no special event handling\n      if (selectMode === 'single') {\n        selectedRows = [];\n      } else if (selectMode === 'range') {\n        if (selectedLastRow > -1 && event.shiftKey) {\n          // range\n          for (let idx = mathMin(selectedLastRow, index); idx <= mathMax(selectedLastRow, index); idx++) {\n            selectedRows[idx] = true;\n          }\n          selected = true;\n        } else {\n          if (!(event.ctrlKey || event.metaKey)) {\n            // Clear range selection if any\n            selectedRows = [];\n            selected = true;\n          }\n          if (selected) this.selectedLastRow = index;\n        }\n      }\n      selectedRows[index] = selected;\n      this.selectedRows = selectedRows;\n    }\n  }\n});\n\nexport { props, selectableMixin };\n","import { get } from '../../../utils/get';\nimport { isFunction, isDate, isNumber, isUndefinedOrNull, isNumeric } from '../../../utils/inspect';\nimport { toFloat } from '../../../utils/number';\nimport { stringifyObjectValues } from '../../../utils/stringify-object-values';\n\nconst normalizeValue = value => {\n  if (isUndefinedOrNull(value)) {\n    return '';\n  }\n  if (isNumeric(value)) {\n    return toFloat(value, value);\n  }\n  return value;\n};\n\n// Default sort compare routine\n//\n// TODO:\n//   Add option to sort by multiple columns (tri-state per column,\n//   plus order of columns in sort) where `sortBy` could be an array\n//   of objects `[ {key: 'foo', sortDir: 'asc'}, {key:'bar', sortDir: 'desc'} ...]`\n//   or an array of arrays `[ ['foo','asc'], ['bar','desc'] ]`\n//   Multisort will most likely be handled in `mixin-sort.js` by\n//   calling this method for each sortBy\nconst defaultSortCompare = function (a, b) {\n  let {\n    sortBy = null,\n    formatter = null,\n    locale = undefined,\n    localeOptions = {},\n    nullLast = false\n  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  // Get the value by `sortBy`\n  let aa = get(a, sortBy, null);\n  let bb = get(b, sortBy, null);\n\n  // Apply user-provided formatter\n  if (isFunction(formatter)) {\n    aa = formatter(aa, sortBy, a);\n    bb = formatter(bb, sortBy, b);\n  }\n\n  // Internally normalize value\n  // `null` / `undefined` => ''\n  // `'0'` => `0`\n  aa = normalizeValue(aa);\n  bb = normalizeValue(bb);\n  if (isDate(aa) && isDate(bb) || isNumber(aa) && isNumber(bb)) {\n    // Special case for comparing dates and numbers\n    // Internally dates are compared via their epoch number values\n    return aa < bb ? -1 : aa > bb ? 1 : 0;\n  } else if (nullLast && aa === '' && bb !== '') {\n    // Special case when sorting `null` / `undefined` / '' last\n    return 1;\n  } else if (nullLast && aa !== '' && bb === '') {\n    // Special case when sorting `null` / `undefined` / '' last\n    return -1;\n  }\n\n  // Do localized string comparison\n  return stringifyObjectValues(aa).localeCompare(stringifyObjectValues(bb), locale, localeOptions);\n};\n\nexport { defaultSortCompare };\n","import { extend } from '../../../vue';\nimport { EVENT_NAME_HEAD_CLICKED, EVENT_NAME_SORT_CHANGED, MODEL_EVENT_NAME_PREFIX } from '../../../constants/events';\nimport { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_FUNCTION, PROP_TYPE_ARRAY_STRING, PROP_TYPE_OBJECT } from '../../../constants/props';\nimport { arrayIncludes } from '../../../utils/array';\nimport { isFunction, isUndefinedOrNull } from '../../../utils/inspect';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { stableSort } from '../../../utils/stable-sort';\nimport { trim } from '../../../utils/string';\nimport { defaultSortCompare } from './default-sort-compare';\n\n// --- Constants ---\n\nconst MODEL_PROP_NAME_SORT_BY = 'sortBy';\nconst MODEL_EVENT_NAME_SORT_BY = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_SORT_BY;\nconst MODEL_PROP_NAME_SORT_DESC = 'sortDesc';\nconst MODEL_EVENT_NAME_SORT_DESC = MODEL_EVENT_NAME_PREFIX + MODEL_PROP_NAME_SORT_DESC;\nconst SORT_DIRECTION_ASC = 'asc';\nconst SORT_DIRECTION_DESC = 'desc';\nconst SORT_DIRECTION_LAST = 'last';\nconst SORT_DIRECTIONS = [SORT_DIRECTION_ASC, SORT_DIRECTION_DESC, SORT_DIRECTION_LAST];\n\n// --- Props ---\n\nconst props = {\n  labelSortAsc: makeProp(PROP_TYPE_STRING, 'Click to sort ascending'),\n  labelSortClear: makeProp(PROP_TYPE_STRING, 'Click to clear sorting'),\n  labelSortDesc: makeProp(PROP_TYPE_STRING, 'Click to sort descending'),\n  noFooterSorting: makeProp(PROP_TYPE_BOOLEAN, false),\n  noLocalSorting: makeProp(PROP_TYPE_BOOLEAN, false),\n  // Another prop that should have had a better name\n  // It should be `noSortClear` (on non-sortable headers)\n  // We will need to make sure the documentation is clear on what\n  // this prop does (as well as in the code for future reference)\n  noSortReset: makeProp(PROP_TYPE_BOOLEAN, false),\n  [MODEL_PROP_NAME_SORT_BY]: makeProp(PROP_TYPE_STRING),\n  sortCompare: makeProp(PROP_TYPE_FUNCTION),\n  // String: locale code\n  // Array: array of Locale strings\n  sortCompareLocale: makeProp(PROP_TYPE_ARRAY_STRING),\n  // Supported localCompare options, see `options` section of:\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\n  sortCompareOptions: makeProp(PROP_TYPE_OBJECT, {\n    numeric: true\n  }),\n  // TODO: Make this tri-state: `true`, `false`, `null`\n  [MODEL_PROP_NAME_SORT_DESC]: makeProp(PROP_TYPE_BOOLEAN, false),\n  // This prop is named incorrectly\n  // It should be `initialSortDirection` as it is a bit misleading\n  // (not to mention it screws up the ARIA label on the headers)\n  sortDirection: makeProp(PROP_TYPE_STRING, SORT_DIRECTION_ASC, value => {\n    return arrayIncludes(SORT_DIRECTIONS, value);\n  }),\n  // Place the sorting icon on the left of the header cells\n  sortIconLeft: makeProp(PROP_TYPE_BOOLEAN, false),\n  // Sort null and undefined to appear last\n  sortNullLast: makeProp(PROP_TYPE_BOOLEAN, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst sortingMixin = extend({\n  props,\n  data() {\n    return {\n      localSortBy: this[MODEL_PROP_NAME_SORT_BY] || '',\n      localSortDesc: this[MODEL_PROP_NAME_SORT_DESC] || false\n    };\n  },\n  computed: {\n    localSorting() {\n      return this.hasProvider ? !!this.noProviderSorting : !this.noLocalSorting;\n    },\n    isSortable() {\n      return this.computedFields.some(f => f.sortable);\n    },\n    // Sorts the filtered items and returns a new array of the sorted items\n    // When not sorted, the original items array will be returned\n    sortedItems() {\n      const {\n        localSortBy: sortBy,\n        localSortDesc: sortDesc,\n        sortCompareLocale: locale,\n        sortNullLast: nullLast,\n        sortCompare,\n        localSorting,\n        filteredItems,\n        localItems\n      } = safeVueInstance(this);\n      const items = (filteredItems || localItems || []).slice();\n      const localeOptions = {\n        ...this.sortCompareOptions,\n        usage: 'sort'\n      };\n      if (sortBy && localSorting) {\n        const field = this.computedFieldsObj[sortBy] || {};\n        const sortByFormatted = field.sortByFormatted;\n        const formatter = isFunction(sortByFormatted) ? /* istanbul ignore next */sortByFormatted : sortByFormatted ? this.getFieldFormatter(sortBy) : undefined;\n\n        // `stableSort` returns a new array, and leaves the original array intact\n        return stableSort(items, (a, b) => {\n          let result = null;\n          // Call user provided `sortCompare` routine first\n          if (isFunction(sortCompare)) {\n            // TODO:\n            //   Change the `sortCompare` signature to the one of `defaultSortCompare`\n            //   with the next major version bump\n            result = sortCompare(a, b, sortBy, sortDesc, formatter, localeOptions, locale);\n          }\n          // Fallback to built-in `defaultSortCompare` if `sortCompare`\n          // is not defined or returns `null`/`false`\n          if (isUndefinedOrNull(result) || result === false) {\n            result = defaultSortCompare(a, b, {\n              sortBy,\n              formatter,\n              locale,\n              localeOptions,\n              nullLast\n            });\n          }\n          // Negate result if sorting in descending order\n          return (result || 0) * (sortDesc ? -1 : 1);\n        });\n      }\n      return items;\n    }\n  },\n  watch: {\n    /* istanbul ignore next: pain in the butt to test */\n    isSortable(newValue) {\n      if (newValue) {\n        if (this.isSortable) {\n          this.$on(EVENT_NAME_HEAD_CLICKED, this.handleSort);\n        }\n      } else {\n        this.$off(EVENT_NAME_HEAD_CLICKED, this.handleSort);\n      }\n    },\n    [MODEL_PROP_NAME_SORT_DESC](newValue) {\n      /* istanbul ignore next */\n      if (newValue === this.localSortDesc) {\n        return;\n      }\n      this.localSortDesc = newValue || false;\n    },\n    [MODEL_PROP_NAME_SORT_BY](newValue) {\n      /* istanbul ignore next */\n      if (newValue === this.localSortBy) {\n        return;\n      }\n      this.localSortBy = newValue || '';\n    },\n    // Update .sync props\n    localSortDesc(newValue, oldValue) {\n      // Emit update to sort-desc.sync\n      if (newValue !== oldValue) {\n        this.$emit(MODEL_EVENT_NAME_SORT_DESC, newValue);\n      }\n    },\n    localSortBy(newValue, oldValue) {\n      if (newValue !== oldValue) {\n        this.$emit(MODEL_EVENT_NAME_SORT_BY, newValue);\n      }\n    }\n  },\n  created() {\n    if (this.isSortable) {\n      this.$on(EVENT_NAME_HEAD_CLICKED, this.handleSort);\n    }\n  },\n  methods: {\n    // Handlers\n    // Need to move from thead-mixin\n    handleSort(key, field, event, isFoot) {\n      if (!this.isSortable) {\n        /* istanbul ignore next */\n        return;\n      }\n      if (isFoot && this.noFooterSorting) {\n        return;\n      }\n      // TODO: make this tri-state sorting\n      // cycle desc => asc => none => desc => ...\n      let sortChanged = false;\n      const toggleLocalSortDesc = () => {\n        const sortDirection = field.sortDirection || this.sortDirection;\n        if (sortDirection === SORT_DIRECTION_ASC) {\n          this.localSortDesc = false;\n        } else if (sortDirection === SORT_DIRECTION_DESC) {\n          this.localSortDesc = true;\n        } else ;\n      };\n      if (field.sortable) {\n        const sortKey = !this.localSorting && field.sortKey ? field.sortKey : key;\n        if (this.localSortBy === sortKey) {\n          // Change sorting direction on current column\n          this.localSortDesc = !this.localSortDesc;\n        } else {\n          // Start sorting this column ascending\n          this.localSortBy = sortKey;\n          // this.localSortDesc = false\n          toggleLocalSortDesc();\n        }\n        sortChanged = true;\n      } else if (this.localSortBy && !this.noSortReset) {\n        this.localSortBy = '';\n        toggleLocalSortDesc();\n        sortChanged = true;\n      }\n      if (sortChanged) {\n        // Sorting parameters changed\n        this.$emit(EVENT_NAME_SORT_CHANGED, this.context);\n      }\n    },\n    // methods to compute classes and attrs for thead>th cells\n    sortTheadThClasses(key, field, isFoot) {\n      return {\n        // If sortable and sortIconLeft are true, then place sort icon on the left\n        'b-table-sort-icon-left': field.sortable && this.sortIconLeft && !(isFoot && this.noFooterSorting)\n      };\n    },\n    sortTheadThAttrs(key, field, isFoot) {\n      var _field$sortKey;\n      const {\n        isSortable,\n        noFooterSorting,\n        localSortDesc,\n        localSortBy,\n        localSorting\n      } = this;\n      if (!isSortable || isFoot && noFooterSorting) {\n        // No attributes if not a sortable table\n        return {};\n      }\n      const sortable = field.sortable;\n      const sortKey = !localSorting ? (_field$sortKey = field.sortKey) !== null && _field$sortKey !== void 0 ? _field$sortKey : key : key;\n\n      // Assemble the aria-sort attribute value\n      const ariaSort = sortable && localSortBy === sortKey ? localSortDesc ? 'descending' : 'ascending' : sortable ? 'none' : null;\n      // Return the attribute\n      return {\n        'aria-sort': ariaSort\n      };\n    },\n    // A label to be placed in an `.gl-sr-only` element in the header cell\n    sortTheadThLabel(key, field, isFoot) {\n      // No label if not a sortable table\n      if (!this.isSortable || isFoot && this.noFooterSorting) {\n        return null;\n      }\n      const {\n        localSortBy,\n        localSortDesc,\n        labelSortAsc,\n        labelSortDesc\n      } = this;\n      const {\n        sortable\n      } = field;\n      // The correctness of these labels is very important for screen reader users\n      let labelSorting = '';\n      if (sortable) {\n        if (localSortBy === key) {\n          // Currently sorted sortable column\n          labelSorting = localSortDesc ? labelSortAsc : labelSortDesc;\n        } else {\n          // Not currently sorted sortable column\n          // Not using nested ternary's here for clarity/readability\n          // Default for `aria-label`\n          labelSorting = localSortDesc ? labelSortDesc : labelSortAsc;\n          // Handle `sortDirection` setting\n          const sortDirection = this.sortDirection || field.sortDirection;\n          if (sortDirection === SORT_DIRECTION_ASC) {\n            labelSorting = labelSortAsc;\n          } else if (sortDirection === SORT_DIRECTION_DESC) {\n            labelSorting = labelSortDesc;\n          }\n        }\n      } else if (!this.noSortReset) {\n        // Non sortable column\n        labelSorting = localSortBy ? this.labelSortClear : '';\n      }\n      // Return the `.gl-sr-only` sort label or `null` if no label\n      return trim(labelSorting) || null;\n    }\n  }\n});\n\nexport { props, sortingMixin };\n","import { extend } from '../../../vue';\nimport { SLOT_NAME_TOP_ROW } from '../../../constants/slots';\nimport { isFunction } from '../../../utils/inspect';\nimport { BTr } from '../tr';\n\n// --- Props ---\n\nconst props = {};\n\n// --- Mixin ---\n\n// @vue/component\nconst topRowMixin = extend({\n  methods: {\n    renderTopRow() {\n      const {\n        computedFields: fields,\n        stacked,\n        tbodyTrClass,\n        tbodyTrAttr\n      } = this;\n      const h = this.$createElement;\n\n      // Add static Top Row slot (hidden in visibly stacked mode as we can't control the data-label)\n      // If in *always* stacked mode, we don't bother rendering the row\n      if (!this.hasNormalizedSlot(SLOT_NAME_TOP_ROW) || stacked === true || stacked === '') {\n        return h();\n      }\n      return h(BTr, {\n        staticClass: 'b-table-top-row',\n        class: [isFunction(tbodyTrClass) ? tbodyTrClass(null, 'row-top') : tbodyTrClass],\n        attrs: isFunction(tbodyTrAttr) ? tbodyTrAttr(null, 'row-top') : tbodyTrAttr,\n        key: 'b-top-row'\n      }, [this.normalizeSlot(SLOT_NAME_TOP_ROW, {\n        columns: fields.length,\n        fields\n      })]);\n    }\n  }\n});\n\nexport { props, topRowMixin };\n","import { extend } from '../../vue';\nimport { NAME_TABLE } from '../../constants/components';\nimport { sortKeys } from '../../utils/object';\nimport { makePropsConfigurable } from '../../utils/props';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { hasListenerMixin } from '../../mixins/has-listener';\nimport { props as props$1, idMixin } from '../../mixins/id';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\nimport { props as props$2, bottomRowMixin } from './helpers/mixin-bottom-row';\nimport { props as props$3, busyMixin } from './helpers/mixin-busy';\nimport { props as props$4, captionMixin } from './helpers/mixin-caption';\nimport { props as props$5, colgroupMixin } from './helpers/mixin-colgroup';\nimport { props as props$6, emptyMixin } from './helpers/mixin-empty';\nimport { props as props$7, filteringMixin } from './helpers/mixin-filtering';\nimport { props as props$8, itemsMixin } from './helpers/mixin-items';\nimport { props as props$9, paginationMixin } from './helpers/mixin-pagination';\nimport { props as props$a, providerMixin } from './helpers/mixin-provider';\nimport { props as props$b, selectableMixin } from './helpers/mixin-selectable';\nimport { props as props$c, sortingMixin } from './helpers/mixin-sorting';\nimport { props as props$d, stackedMixin } from './helpers/mixin-stacked';\nimport { props as props$e, tableRendererMixin } from './helpers/mixin-table-renderer';\nimport { props as props$f, tbodyMixin } from './helpers/mixin-tbody';\nimport { props as props$g, tfootMixin } from './helpers/mixin-tfoot';\nimport { props as props$h, theadMixin } from './helpers/mixin-thead';\nimport { props as props$i, topRowMixin } from './helpers/mixin-top-row';\n\n// --- Props ---\n\nconst props = makePropsConfigurable(sortKeys({\n  ...props$1,\n  ...props$2,\n  ...props$3,\n  ...props$4,\n  ...props$5,\n  ...props$6,\n  ...props$7,\n  ...props$8,\n  ...props$9,\n  ...props$a,\n  ...props$b,\n  ...props$c,\n  ...props$d,\n  ...props$e,\n  ...props$f,\n  ...props$g,\n  ...props$h,\n  ...props$i\n}), NAME_TABLE);\n\n// --- Main component ---\n\n// @vue/component\nconst BTable = /*#__PURE__*/extend({\n  name: NAME_TABLE,\n  // Order of mixins is important!\n  // They are merged from first to last, followed by this component\n  mixins: [\n  // General mixins\n  attrsMixin, hasListenerMixin, idMixin, normalizeSlotMixin,\n  // Required table mixins\n  itemsMixin, tableRendererMixin, stackedMixin, theadMixin, tfootMixin, tbodyMixin,\n  // Table features mixins\n  stackedMixin, filteringMixin, sortingMixin, paginationMixin, captionMixin, colgroupMixin, selectableMixin, emptyMixin, topRowMixin, bottomRowMixin, busyMixin, providerMixin],\n  props\n  // Render function is provided by `tableRendererMixin`\n});\n\nexport { BTable, props };\n","const tableFullSlots = ['bottom-row', 'empty', 'emptyfiltered', 'table-busy', 'thead-top', 'top-row'];\nconst tableFullProps = ['api-url', 'busy', 'current-page', 'empty-filtered-html', 'empty-filtered-text', 'empty-html', 'empty-text', 'filter', 'filter-debounce', 'filter-function', 'filter-ignored-fields', 'filter-included-fields', 'label-sort-asc', 'label-sort-clear', 'label-sort-desc', 'no-footer-sorting', 'no-local-sorting', 'no-provider-filtering', 'no-provider-paging', 'no-provider-sorting', 'no-select-on-click', 'per-page', 'select-mode', 'selectable', 'selected-variant', 'show-empty', 'sort-by', 'sort-compare', 'sort-compare-locale', 'sort-compare-options', 'sort-desc', 'sort-direction', 'sort-icon-left', 'sort-null-last'];\nconst glTableLiteWarning = 'This GlTable could be a GlTableLite component, please consider using GlTableLite instead of GlTable to reduce the page bundlesize more about this here: https://gitlab-org.gitlab.io/gitlab-ui/?path=/docs/base-table-table-lite--default';\n\nexport { glTableLiteWarning, tableFullProps, tableFullSlots };\n","import { BTable } from '../../../vendor/bootstrap-vue/src/components/table/table';\nimport { isDev, logWarning } from '../../../utils/utils';\nimport { tableFullProps, tableFullSlots, glTableLiteWarning } from './constants';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\n//\nconst shouldUseFullTable = _ref => {\n  let {\n    $attrs,\n    $scopedSlots\n  } = _ref;\n  return tableFullProps.some(prop => $attrs[prop] !== undefined) || tableFullSlots.some(slot => $scopedSlots[slot] !== undefined);\n};\nconst {\n  tableClass\n} = BTable.options.props;\nvar script = {\n  name: 'GlTable',\n  components: {\n    BTable\n  },\n  inheritAttrs: false,\n  props: {\n    tableClass,\n    fields: {\n      type: Array,\n      required: false,\n      default: null\n    },\n    stickyHeader: {\n      type: Boolean,\n      default: false,\n      required: false\n    },\n    sortBy: {\n      type: String,\n      required: false,\n      default: undefined\n    },\n    sortDesc: {\n      type: Boolean,\n      required: false,\n      default: false\n    }\n  },\n  data() {\n    return {\n      localSortBy: this.sortBy,\n      localSortDesc: this.sortDesc\n    };\n  },\n  computed: {\n    stickyHeaderClass() {\n      return this.stickyHeader ? 'gl-table--sticky-header' : null;\n    },\n    localTableClass() {\n      return ['gl-table', this.tableClass, this.stickyHeaderClass];\n    },\n    headSlots() {\n      return ['head()', ...Object.keys(this.$scopedSlots).filter(slotName => slotName.startsWith('head('))];\n    },\n    computedFields() {\n      var _this$fields;\n      return (_this$fields = this.fields) === null || _this$fields === void 0 ? void 0 : _this$fields.map(field => {\n        if (typeof field === 'string') {\n          return field;\n        }\n        const {\n          thAlignRight,\n          thClass = '',\n          ...rest\n        } = field;\n        const computedThClass = Array.isArray(thClass) ? thClass : thClass.split(' ');\n        if (thAlignRight) {\n          computedThClass.push('gl-table-th-align-right');\n        }\n        return {\n          ...rest,\n          thClass: computedThClass\n        };\n      });\n    }\n  },\n  mounted() {\n    // logWarning will call isDev before logging any message\n    // this additional call to isDev is being made to exit the condition early when run in production\n    if (isDev() && !shouldUseFullTable(this)) {\n      logWarning(glTableLiteWarning, this.$el);\n    }\n  },\n  methods: {\n    isSortable(_ref2) {\n      let {\n        field\n      } = _ref2;\n      return field === null || field === void 0 ? void 0 : field.sortable;\n    },\n    activeSortingColumn(_ref3) {\n      let {\n        field\n      } = _ref3;\n      return this.localSortBy === (field === null || field === void 0 ? void 0 : field.key);\n    },\n    getSortingIcon(_ref4) {\n      let {\n        field\n      } = _ref4;\n      if (this.activeSortingColumn({\n        field\n      })) {\n        if (this.localSortDesc) {\n          return '↓';\n        }\n        return '↑';\n      }\n      if (this.$attrs['sort-direction'] === 'desc') {\n        return '↓';\n      }\n      return '↑';\n    }\n  }\n};\n\n/* script */\nconst __vue_script__ = script;\n\n/* template */\nvar __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('b-table',_vm._g(_vm._b({attrs:{\"table-class\":_vm.localTableClass,\"fields\":_vm.computedFields,\"sort-by\":_vm.localSortBy,\"sort-desc\":_vm.localSortDesc,\"no-sort-reset\":\"\"},on:{\"update:sortBy\":function($event){_vm.localSortBy=$event;},\"update:sort-by\":function($event){_vm.localSortBy=$event;},\"update:sortDesc\":function($event){_vm.localSortDesc=$event;},\"update:sort-desc\":function($event){_vm.localSortDesc=$event;}},scopedSlots:_vm._u([_vm._l((Object.keys(_vm.$scopedSlots)),function(slotName){return {key:slotName,fn:function(scope){return [_vm._t(slotName,null,null,scope)]}}}),_vm._l((_vm.headSlots),function(headSlotName){return {key:headSlotName,fn:function(scope){return [_c('div',{key:headSlotName,staticClass:\"gl-flex\"},[_vm._t(headSlotName,function(){return [_c('span',[_vm._v(_vm._s(scope.label))])]},null,scope),(_vm.isSortable(scope))?[_c('div',{staticClass:\"gl-table-th-sort-icon-wrapper gl-flex gl-w-5 gl-justify-center\"},[_c('span',{class:{ 'gl-hidden': !_vm.activeSortingColumn(scope) },attrs:{\"name\":\"sort-icon\",\"data-testid\":\"sort-icon\"}},[_vm._v(\"\\n            \"+_vm._s(_vm.getSortingIcon(scope))+\"\\n          \")])])]:_vm._e()],2)]}}})],null,true)},'b-table',_vm.$attrs,false),_vm.$listeners))};\nvar __vue_staticRenderFns__ = [];\n\n  /* style */\n  const __vue_inject_styles__ = undefined;\n  /* scoped */\n  const __vue_scope_id__ = undefined;\n  /* module identifier */\n  const __vue_module_identifier__ = undefined;\n  /* functional template */\n  const __vue_is_functional_template__ = false;\n  /* style inject */\n  \n  /* style inject SSR */\n  \n  /* style inject shadow dom */\n  \n\n  \n  const __vue_component__ = __vue_normalize__(\n    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },\n    __vue_inject_styles__,\n    __vue_script__,\n    __vue_scope_id__,\n    __vue_is_functional_template__,\n    __vue_module_identifier__,\n    false,\n    undefined,\n    undefined,\n    undefined\n  );\n\nexport default __vue_component__;\n"],"sourceRoot":""}