@gitlab/duo-ui 3.0.0 → 3.0.1

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

@@ -1,146 +0,0 @@
-import { extend } from '../../../vue'
-import { EVENT_NAME_CONTEXT_CHANGED } from '../../../constants/events'
-import { PROP_TYPE_ARRAY, PROP_TYPE_STRING } from '../../../constants/props'
-import { useParentMixin } from '../../../mixins/use-parent'
-import { isArray, isFunction, isString } 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 { clone, sortKeys } from '../../../utils/object'
-import { makeProp } from '../../../utils/props'
-import { safeVueInstance } from '../../../utils/safe-vue-instance'
-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: []
-})
-
-export { MODEL_PROP_NAME, MODEL_EVENT_NAME }
-
-// --- Props ---
-
-export const props = sortKeys({
-  ...modelProps,
-  fields: makeProp(PROP_TYPE_ARRAY, null),
-  // Provider mixin adds in `Function` type
-  items: makeProp(PROP_TYPE_ARRAY, []),
-  // Primary key for record
-  // If provided the value in each row must be unique!
-  primaryKey: makeProp(PROP_TYPE_STRING),
-  // `v-model` for retrieving the current displayed rows
-  [MODEL_PROP_NAME]: makeProp(PROP_TYPE_ARRAY, [])
-})
-
-// --- Mixin ---
-
-// @vue/component
-export const itemsMixin = extend({
-  mixins: [modelMixin, useParentMixin],
-  props,
-  data() {
-    const { items } = this
-
-    return {
-      // Our local copy of the items
-      // Must be an array
-      localItems: isArray(items) ? items.slice() : []
-    }
-  },
-  computed: {
-    computedFields() {
-      // We normalize fields into an array of objects
-      // `[ { key:..., label:..., ...}, {...}, ..., {..}]`
-      return normalizeFields(this.fields, this.localItems)
-    },
-    computedFieldsObj() {
-      // Fields as a simple lookup hash object
-      // 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
-      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)
-        if (f.formatter) {
-          // Normalize formatter to a function ref or `undefined`
-          let formatter = f.formatter
-          if (isString(formatter) && isFunction(bvParent[formatter])) {
-            formatter = bvParent[formatter]
-          } else if (!isFunction(formatter)) {
-            /* istanbul ignore next */
-            formatter = undefined
-          }
-          // Return formatter function or `undefined` if none
-          obj[f.key].formatter = formatter
-        }
-        return obj
-      }, {})
-    },
-    computedItems() {
-      const { paginatedItems, sortedItems, filteredItems, localItems } = safeVueInstance(this)
-      // Fallback if various mixins not provided
-      return (
-        paginatedItems ||
-        sortedItems ||
-        filteredItems ||
-        localItems ||
-        /* istanbul ignore next */
-        []
-      ).slice()
-    },
-    context() {
-      const { perPage, currentPage } = safeVueInstance(this)
-      // Current state of sorting, filtering and pagination props/values
-      return {
-        filter: this.localFilter,
-        sortBy: this.localSortBy,
-        sortDesc: this.localSortDesc,
-        perPage: mathMax(toInteger(perPage, 0), 0),
-        currentPage: mathMax(toInteger(currentPage, 0), 1),
-        apiUrl: this.apiUrl
-      }
-    }
-  },
-  watch: {
-    items(newValue) {
-      // Set `localItems`/`filteredItems` to a copy of the provided array
-      this.localItems = isArray(newValue) ? newValue.slice() : []
-    },
-    // Watch for changes on `computedItems` and update the `v-model`
-    computedItems(newValue, oldValue) {
-      if (!looseEqual(newValue, oldValue)) {
-        this.$emit(MODEL_EVENT_NAME, newValue)
-      }
-    },
-    // Watch for context changes
-    context(newValue, oldValue) {
-      // Emit context information for external paging/filtering/sorting handling
-      if (!looseEqual(newValue, oldValue)) {
-        this.$emit(EVENT_NAME_CONTEXT_CHANGED, newValue)
-      }
-    }
-  },
-  mounted() {
-    // Initially update the `v-model` of displayed items
-    this.$emit(MODEL_EVENT_NAME, this.computedItems)
-  },
-  methods: {
-    // Method to get the formatter method for a given field key
-    getFieldFormatter(key) {
-      const field = this.computedFieldsObj[key]
-      // `this.computedFieldsObj` has pre-normalized the formatter to a
-      // function ref if present, otherwise `undefined`
-      return field ? field.formatter : undefined
-    }
-  }
-})

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

@@ -1,38 +0,0 @@
-import { extend } from '../../../vue'
-import { PROP_TYPE_NUMBER_STRING } from '../../../constants/props'
-import { mathMax } from '../../../utils/math'
-import { toInteger } from '../../../utils/number'
-import { makeProp } from '../../../utils/props'
-import { safeVueInstance } from '../../../utils/safe-vue-instance'
-
-// --- Props ---
-
-export const props = {
-  currentPage: makeProp(PROP_TYPE_NUMBER_STRING, 1),
-  perPage: makeProp(PROP_TYPE_NUMBER_STRING, 0)
-}
-
-// --- Mixin ---
-
-// @vue/component
-export const paginationMixin = extend({
-  props,
-  computed: {
-    localPaging() {
-      return this.hasProvider ? !!this.noProviderPaging : true
-    },
-    paginatedItems() {
-      const { sortedItems, filteredItems, localItems } = safeVueInstance(this)
-      let items = sortedItems || filteredItems || localItems || []
-      const currentPage = mathMax(toInteger(this.currentPage, 1), 1)
-      const perPage = mathMax(toInteger(this.perPage, 0), 0)
-      // Apply local pagination
-      if (this.localPaging && perPage) {
-        // Grab the current page of data (which may be past filtered items limit)
-        items = items.slice((currentPage - 1) * perPage, currentPage * perPage)
-      }
-      // Return the items to display in the table
-      return items
-    }
-  }
-})

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

@@ -1,188 +0,0 @@
-import { extend } from '../../../vue'
-import { NAME_TABLE } from '../../../constants/components'
-import { EVENT_NAME_REFRESH, EVENT_NAME_REFRESHED } from '../../../constants/events'
-import {
-  PROP_TYPE_ARRAY_FUNCTION,
-  PROP_TYPE_BOOLEAN,
-  PROP_TYPE_STRING
-} from '../../../constants/props'
-import { getRootActionEventName, getRootEventName } from '../../../utils/events'
-import { isArray, isFunction, isPromise } from '../../../utils/inspect'
-import { looseEqual } from '../../../utils/loose-equal'
-import { clone } from '../../../utils/object'
-import { makeProp } from '../../../utils/props'
-import { safeVueInstance } from '../../../utils/safe-vue-instance'
-import { warn } from '../../../utils/warn'
-import { listenOnRootMixin } from '../../../mixins/listen-on-root'
-
-// --- Constants ---
-
-const ROOT_EVENT_NAME_REFRESHED = getRootEventName(NAME_TABLE, EVENT_NAME_REFRESHED)
-const ROOT_ACTION_EVENT_NAME_REFRESH = getRootActionEventName(NAME_TABLE, EVENT_NAME_REFRESH)
-
-// --- Props ---
-
-export const props = {
-  // Passed to the context object
-  // Not used by `<b-table>` directly
-  apiUrl: makeProp(PROP_TYPE_STRING),
-  // Adds in 'Function' support
-  items: makeProp(PROP_TYPE_ARRAY_FUNCTION, []),
-  noProviderFiltering: makeProp(PROP_TYPE_BOOLEAN, false),
-  noProviderPaging: makeProp(PROP_TYPE_BOOLEAN, false),
-  noProviderSorting: makeProp(PROP_TYPE_BOOLEAN, false)
-}
-
-// --- Mixin ---
-
-// @vue/component
-export const providerMixin = extend({
-  mixins: [listenOnRootMixin],
-  props,
-  computed: {
-    hasProvider() {
-      return isFunction(this.items)
-    },
-    providerTriggerContext() {
-      // Used to trigger the provider function via a watcher. Only the fields that
-      // are needed for triggering a provider update are included. Note that the
-      // regular this.context is sent to the provider during fetches though, as they
-      // may need all the prop info.
-      const ctx = {
-        apiUrl: this.apiUrl,
-        filter: null,
-        sortBy: null,
-        sortDesc: null,
-        perPage: null,
-        currentPage: null
-      }
-      if (!this.noProviderFiltering) {
-        // Either a string, or could be an object or array.
-        ctx.filter = this.localFilter
-      }
-      if (!this.noProviderSorting) {
-        ctx.sortBy = this.localSortBy
-        ctx.sortDesc = this.localSortDesc
-      }
-      if (!this.noProviderPaging) {
-        ctx.perPage = this.perPage
-        ctx.currentPage = this.currentPage
-      }
-      return clone(ctx)
-    }
-  },
-  watch: {
-    // Provider update triggering
-    items(newValue) {
-      // If a new provider has been specified, trigger an update
-      if (this.hasProvider || isFunction(newValue)) {
-        this.$nextTick(this._providerUpdate)
-      }
-    },
-    providerTriggerContext(newValue, oldValue) {
-      // Trigger the provider to update as the relevant context values have changed.
-      if (!looseEqual(newValue, oldValue)) {
-        this.$nextTick(this._providerUpdate)
-      }
-    }
-  },
-  mounted() {
-    // Call the items provider if necessary
-    if (this.hasProvider && (!this.localItems || this.localItems.length === 0)) {
-      // Fetch on mount if localItems is empty
-      this._providerUpdate()
-    }
-    // Listen for global messages to tell us to force refresh the table
-    this.listenOnRoot(ROOT_ACTION_EVENT_NAME_REFRESH, id => {
-      if (id === this.id || id === this) {
-        this.refresh()
-      }
-    })
-  },
-  methods: {
-    refresh() {
-      const { items, refresh, computedBusy } = safeVueInstance(this)
-
-      // Public Method: Force a refresh of the provider function
-      this.$off(EVENT_NAME_REFRESHED, refresh)
-      if (computedBusy) {
-        // Can't force an update when forced busy by user (busy prop === true)
-        if (this.localBusy && this.hasProvider) {
-          // But if provider running (localBusy), re-schedule refresh once `refreshed` emitted
-          this.$on(EVENT_NAME_REFRESHED, refresh)
-        }
-      } else {
-        this.clearSelected()
-        if (this.hasProvider) {
-          this.$nextTick(this._providerUpdate)
-        } else {
-          /* istanbul ignore next */
-          this.localItems = isArray(items) ? items.slice() : []
-        }
-      }
-    },
-    // Provider related methods
-    _providerSetLocal(items) {
-      this.localItems = isArray(items) ? items.slice() : []
-      this.localBusy = false
-      this.$emit(EVENT_NAME_REFRESHED)
-      // New root emit
-      if (this.id) {
-        this.emitOnRoot(ROOT_EVENT_NAME_REFRESHED, this.id)
-      }
-    },
-    _providerUpdate() {
-      // Refresh the provider function items.
-      if (!this.hasProvider) {
-        // Do nothing if no provider
-        return
-      }
-      // If table is busy, wait until refreshed before calling again
-      if (safeVueInstance(this).computedBusy) {
-        // Schedule a new refresh once `refreshed` is emitted
-        this.$nextTick(this.refresh)
-        return
-      }
-
-      // Set internal busy state
-      this.localBusy = true
-
-      // Call provider function with context and optional callback after DOM is fully updated
-      this.$nextTick(() => {
-        try {
-          // Call provider function passing it the context and optional callback
-          const data = this.items(this.context, this._providerSetLocal)
-          if (isPromise(data)) {
-            // Provider returned Promise
-            data.then(items => {
-              // Provider resolved with items
-              this._providerSetLocal(items)
-            })
-          } else if (isArray(data)) {
-            // Provider returned Array data
-            this._providerSetLocal(data)
-          } else {
-            /* istanbul ignore if */
-            if (this.items.length !== 2) {
-              // Check number of arguments provider function requested
-              // Provider not using callback (didn't request second argument), so we clear
-              // busy state as most likely there was an error in the provider function
-              /* istanbul ignore next */
-              warn(
-                "Provider function didn't request callback and did not return a promise or data.",
-                NAME_TABLE
-              )
-              this.localBusy = false
-            }
-          }
-        } catch (e) /* istanbul ignore next */ {
-          // Provider function borked on us, so we spew out a warning
-          // and clear the busy state
-          warn(`Provider function error [${e.name}] ${e.message}.`, NAME_TABLE)
-          this.localBusy = false
-          this.$off(EVENT_NAME_REFRESHED, this.refresh)
-        }
-      })
-    }
-  }
-})

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

@@ -1,241 +0,0 @@
-import { extend } from '../../../vue'
-import {
-  EVENT_NAME_CONTEXT_CHANGED,
-  EVENT_NAME_FILTERED,
-  EVENT_NAME_ROW_CLICKED,
-  EVENT_NAME_ROW_SELECTED
-} from '../../../constants/events'
-import { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../../constants/props'
-import { arrayIncludes, createArray } from '../../../utils/array'
-import { identity } from '../../../utils/identity'
-import { isArray, isNumber } from '../../../utils/inspect'
-import { looseEqual } from '../../../utils/loose-equal'
-import { mathMax, mathMin } from '../../../utils/math'
-import { makeProp } from '../../../utils/props'
-import { toString } from '../../../utils/string'
-import { sanitizeRow } from './sanitize-row'
-
-// --- Constants ---
-
-const SELECT_MODES = ['range', 'multi', 'single']
-
-const ROLE_GRID = 'grid'
-
-// --- Props ---
-
-export const props = {
-  // Disable use of click handlers for row selection
-  noSelectOnClick: makeProp(PROP_TYPE_BOOLEAN, false),
-  selectMode: makeProp(PROP_TYPE_STRING, 'multi', value => {
-    return arrayIncludes(SELECT_MODES, value)
-  }),
-  selectable: makeProp(PROP_TYPE_BOOLEAN, false),
-  selectedVariant: makeProp(PROP_TYPE_STRING, 'active')
-}
-
-// --- Mixin ---
-
-// @vue/component
-export const selectableMixin = extend({
-  props,
-  data() {
-    return {
-      selectedRows: [],
-      selectedLastRow: -1
-    }
-  },
-  computed: {
-    isSelectable() {
-      return this.selectable && this.selectMode
-    },
-    hasSelectableRowClick() {
-      return this.isSelectable && !this.noSelectOnClick
-    },
-    supportsSelectableRows() {
-      return true
-    },
-    selectableHasSelection() {
-      const { selectedRows } = this
-      return (
-        this.isSelectable && selectedRows && selectedRows.length > 0 && selectedRows.some(identity)
-      )
-    },
-    selectableIsMultiSelect() {
-      return this.isSelectable && arrayIncludes(['range', 'multi'], this.selectMode)
-    },
-    selectableTableClasses() {
-      const { isSelectable } = this
-      return {
-        'b-table-selectable': isSelectable,
-        [`b-table-select-${this.selectMode}`]: isSelectable,
-        'b-table-selecting': this.selectableHasSelection,
-        'b-table-selectable-no-click': isSelectable && !this.hasSelectableRowClick
-      }
-    },
-    selectableTableAttrs() {
-      if (!this.isSelectable) {
-        return {}
-      }
-
-      const role = this.bvAttrs.role || ROLE_GRID
-
-      return {
-        role,
-        // TODO:
-        //   Should this attribute not be included when `no-select-on-click` is set
-        //   since this attribute implies keyboard navigation?
-        'aria-multiselectable': role === ROLE_GRID ? toString(this.selectableIsMultiSelect) : null
-      }
-    }
-  },
-  watch: {
-    computedItems(newValue, oldValue) {
-      // Reset for selectable
-      let equal = false
-      if (this.isSelectable && this.selectedRows.length > 0) {
-        // Quick check against array length
-        equal = isArray(newValue) && isArray(oldValue) && newValue.length === oldValue.length
-        for (let i = 0; equal && i < newValue.length; i++) {
-          // Look for the first non-loosely equal row, after ignoring reserved fields
-          equal = looseEqual(sanitizeRow(newValue[i]), sanitizeRow(oldValue[i]))
-        }
-      }
-      if (!equal) {
-        this.clearSelected()
-      }
-    },
-    selectable(newValue) {
-      this.clearSelected()
-      this.setSelectionHandlers(newValue)
-    },
-    selectMode() {
-      this.clearSelected()
-    },
-    hasSelectableRowClick(newValue) {
-      this.clearSelected()
-      this.setSelectionHandlers(!newValue)
-    },
-    selectedRows(selectedRows, oldValue) {
-      if (this.isSelectable && !looseEqual(selectedRows, oldValue)) {
-        const items = []
-        // `.forEach()` skips over non-existent indices (on sparse arrays)
-        selectedRows.forEach((v, idx) => {
-          if (v) {
-            items.push(this.computedItems[idx])
-          }
-        })
-        this.$emit(EVENT_NAME_ROW_SELECTED, items)
-      }
-    }
-  },
-  beforeMount() {
-    // Set up handlers if needed
-    if (this.isSelectable) {
-      this.setSelectionHandlers(true)
-    }
-  },
-  methods: {
-    // Public methods
-    selectRow(index) {
-      // Select a particular row (indexed based on computedItems)
-      if (
-        this.isSelectable &&
-        isNumber(index) &&
-        index >= 0 &&
-        index < this.computedItems.length &&
-        !this.isRowSelected(index)
-      ) {
-        const selectedRows = this.selectableIsMultiSelect ? this.selectedRows.slice() : []
-        selectedRows[index] = true
-        this.selectedLastClicked = -1
-        this.selectedRows = selectedRows
-      }
-    },
-    unselectRow(index) {
-      // Un-select a particular row (indexed based on `computedItems`)
-      if (this.isSelectable && isNumber(index) && this.isRowSelected(index)) {
-        const selectedRows = this.selectedRows.slice()
-        selectedRows[index] = false
-        this.selectedLastClicked = -1
-        this.selectedRows = selectedRows
-      }
-    },
-    selectAllRows() {
-      const length = this.computedItems.length
-      if (this.isSelectable && length > 0) {
-        this.selectedLastClicked = -1
-        this.selectedRows = this.selectableIsMultiSelect ? createArray(length, true) : [true]
-      }
-    },
-    isRowSelected(index) {
-      // Determine if a row is selected (indexed based on `computedItems`)
-      return !!(isNumber(index) && this.selectedRows[index])
-    },
-    clearSelected() {
-      // Clear any active selected row(s)
-      this.selectedLastClicked = -1
-      this.selectedRows = []
-    },
-    // Internal private methods
-    selectableRowClasses(index) {
-      if (this.isSelectable && this.isRowSelected(index)) {
-        const variant = this.selectedVariant
-        return {
-          'b-table-row-selected': true,
-          [`${this.dark ? 'bg' : 'table'}-${variant}`]: variant
-        }
-      }
-
-      return {}
-    },
-    selectableRowAttrs(index) {
-      return {
-        'aria-selected': !this.isSelectable ? null : this.isRowSelected(index) ? 'true' : 'false'
-      }
-    },
-    setSelectionHandlers(on) {
-      const method = on && !this.noSelectOnClick ? '$on' : '$off'
-      // Handle row-clicked event
-      this[method](EVENT_NAME_ROW_CLICKED, this.selectionHandler)
-      // Clear selection on filter, pagination, and sort changes
-      this[method](EVENT_NAME_FILTERED, this.clearSelected)
-      this[method](EVENT_NAME_CONTEXT_CHANGED, this.clearSelected)
-    },
-    selectionHandler(item, index, event) {
-      /* istanbul ignore if: should never happen */
-      if (!this.isSelectable || this.noSelectOnClick) {
-        // Don't do anything if table is not in selectable mode
-        this.clearSelected()
-        return
-      }
-      const { selectMode, selectedLastRow } = this
-      let selectedRows = this.selectedRows.slice()
-      let selected = !selectedRows[index]
-      // Note 'multi' mode needs no special event handling
-      if (selectMode === 'single') {
-        selectedRows = []
-      } else if (selectMode === 'range') {
-        if (selectedLastRow > -1 && event.shiftKey) {
-          // range
-          for (
-            let idx = mathMin(selectedLastRow, index);
-            idx <= mathMax(selectedLastRow, index);
-            idx++
-          ) {
-            selectedRows[idx] = true
-          }
-          selected = true
-        } else {
-          if (!(event.ctrlKey || event.metaKey)) {
-            // Clear range selection if any
-            selectedRows = []
-            selected = true
-          }
-          if (selected) this.selectedLastRow = index
-        }
-      }
-      selectedRows[index] = selected
-      this.selectedRows = selectedRows
-    }
-  }
-})