@gitlab/duo-ui 0.1.0 → 0.2.0

package/src/vendor/bootstrap-vue/src/components/table/helpers/default-sort-compare.spec.js

@@ -0,0 +1,112 @@
+import { defaultSortCompare } from './default-sort-compare'
+
+describe('table/helpers/default-sort-compare', () => {
+  it('sorts numbers correctly', async () => {
+    const options = { sortBy: 'a' }
+    expect(defaultSortCompare({ a: 1 }, { a: 2 }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: 2 }, { a: 1 }, options)).toBe(1)
+    expect(defaultSortCompare({ a: 1 }, { a: 1 }, options)).toBe(0)
+    expect(defaultSortCompare({ a: -1 }, { a: 1 }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: 1 }, { a: -1 }, options)).toBe(1)
+    expect(defaultSortCompare({ a: 0 }, { a: 0 }, options)).toBe(0)
+    expect(defaultSortCompare({ a: 1.234 }, { a: 1.567 }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: 1.561 }, { a: 1.234 }, options)).toBe(1)
+  })
+
+  it('sorts dates correctly', async () => {
+    const date1 = { a: new Date(2020, 1, 1) }
+    const date2 = { a: new Date(1999, 11, 31) }
+    const date3 = { a: new Date(1999, 1, 1) }
+    const date4 = { a: new Date(1999, 1, 1, 12, 12, 12, 12) }
+    const options = { sortBy: 'a' }
+
+    expect(defaultSortCompare(date1, date2, options)).toBe(1)
+    expect(defaultSortCompare(date1, date1, options)).toBe(0)
+    expect(defaultSortCompare(date2, date1, options)).toBe(-1)
+    expect(defaultSortCompare(date2, date3, options)).toBe(1)
+    expect(defaultSortCompare(date3, date2, options)).toBe(-1)
+    expect(defaultSortCompare(date3, date4, options)).toBe(-1)
+    expect(defaultSortCompare(date4, date3, options)).toBe(1)
+    expect(defaultSortCompare(date4, date4, options)).toBe(0)
+  })
+
+  it('sorts date strings correctly', async () => {
+    const date1 = { a: new Date(2020, 1, 1).toISOString() }
+    const date2 = { a: new Date(1999, 11, 31).toISOString() }
+    const date3 = { a: new Date(1999, 1, 1).toISOString() }
+    const date4 = { a: new Date(1999, 1, 1, 12, 12, 12, 12).toISOString() }
+    const options = { sortBy: 'a' }
+
+    expect(defaultSortCompare(date1, date2, options)).toBe(1)
+    expect(defaultSortCompare(date1, date1, options)).toBe(0)
+    expect(defaultSortCompare(date2, date1, options)).toBe(-1)
+    expect(defaultSortCompare(date2, date3, options)).toBe(1)
+    expect(defaultSortCompare(date3, date2, options)).toBe(-1)
+    expect(defaultSortCompare(date3, date4, options)).toBe(-1)
+    expect(defaultSortCompare(date4, date3, options)).toBe(1)
+    expect(defaultSortCompare(date4, date4, options)).toBe(0)
+  })
+
+  it('sorts strings correctly', async () => {
+    const options = { sortBy: 'a' }
+
+    // Note: string comparisons are locale based
+    expect(defaultSortCompare({ a: 'a' }, { a: 'b' }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: 'b' }, { a: 'a' }, options)).toBe(1)
+    expect(defaultSortCompare({ a: 'a' }, { a: 'a' }, options)).toBe(0)
+    expect(defaultSortCompare({ a: 'a' }, { a: 'aaa' }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: 'aaa' }, { a: 'a' }, options)).toBe(1)
+  })
+
+  it('sorts by nested key correctly', async () => {
+    const options = { sortBy: 'a.b' }
+
+    // Note: string comparisons are locale based
+    expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'b' } }, options)).toBe(-1)
+    expect(defaultSortCompare({ a: { b: 'b' } }, { a: { b: 'a' } }, options)).toBe(1)
+    expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'a' } }, options)).toBe(0)
+    expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'aaa' } }, options)).toBe(-1)
+  })
+
+  it('sorts using provided formatter correctly', async () => {
+    const formatter = value => {
+      // Reverse the string
+      return value
+        .split('')
+        .reverse()
+        .join('')
+    }
+
+    expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, { sortBy: 'a' })).toBe(-1)
+    expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, { sortBy: 'a', formatter })).toBe(1)
+  })
+
+  it('sorts nulls always last when sor-null-lasst is set', async () => {
+    const x = { a: 'ab' }
+    const y = { a: null }
+    const z = {}
+    const w = { a: '' }
+    const options = { sortBy: 'a', localeOptions: { numeric: true } }
+    const optionsNullLast = { ...options, nullLast: true }
+
+    // Without nullLast set (false)
+    expect(defaultSortCompare(x, y, options)).toBe(1)
+    expect(defaultSortCompare(y, x, options)).toBe(-1)
+    expect(defaultSortCompare(x, z, options)).toBe(1)
+    expect(defaultSortCompare(z, x, options)).toBe(-1)
+    expect(defaultSortCompare(y, z, options)).toBe(0)
+    expect(defaultSortCompare(z, y, options)).toBe(0)
+    expect(defaultSortCompare(x, w, options)).toBe(1)
+    expect(defaultSortCompare(w, x, options)).toBe(-1)
+
+    // With nullLast set
+    expect(defaultSortCompare(x, y, optionsNullLast)).toBe(-1)
+    expect(defaultSortCompare(y, x, optionsNullLast)).toBe(1)
+    expect(defaultSortCompare(x, z, optionsNullLast)).toBe(-1)
+    expect(defaultSortCompare(z, x, optionsNullLast)).toBe(1)
+    expect(defaultSortCompare(y, z, optionsNullLast)).toBe(0)
+    expect(defaultSortCompare(z, y, optionsNullLast)).toBe(0)
+    expect(defaultSortCompare(x, w, optionsNullLast)).toBe(-1)
+    expect(defaultSortCompare(w, x, optionsNullLast)).toBe(1)
+  })
+})

package/src/vendor/bootstrap-vue/src/components/table/helpers/normalize-fields.spec.js

@@ -0,0 +1,93 @@
+import { normalizeFields } from './normalize-fields'
+
+describe('table/helpers/normalize-fields', () => {
+  it('uses first row of items when fields are not defined and items passed', async () => {
+    const fields = normalizeFields(null, [
+      { foo: 1, bar: { a: 2 }, 'foo bar': 3, baz_bar: 4 },
+      { foo: 1, bar: { a: 2 }, 'foo bar': 3, baz: 5 }
+    ])
+    expect(fields).toEqual([
+      { key: 'foo', label: 'Foo' },
+      { key: 'bar', label: 'Bar' },
+      { key: 'foo bar', label: 'Foo Bar' },
+      { key: 'baz_bar', label: 'Baz Bar' }
+    ])
+  })
+
+  it('ignores special fields in items when fields are not defined and items passed', async () => {
+    const fields = normalizeFields(null, [
+      {
+        foo: 1,
+        bar: 2,
+        _showDetails: true,
+        _rowVariant: 'primary',
+        _cellVariants: ['primary', 'secondary', 'info'],
+        baz: 3
+      }
+    ])
+    expect(fields).toEqual([
+      { key: 'foo', label: 'Foo' },
+      { key: 'bar', label: 'Bar' },
+      { key: 'baz', label: 'Baz' }
+    ])
+  })
+
+  it('returns and empty array when no fields or items passed', async () => {
+    expect(normalizeFields(undefined, undefined)).toEqual([])
+    expect(normalizeFields(null, null)).toEqual([])
+    expect(normalizeFields([], undefined)).toEqual([])
+    expect(normalizeFields(undefined, [])).toEqual([])
+    expect(normalizeFields([], [])).toEqual([])
+    expect(normalizeFields({}, [])).toEqual([])
+  })
+
+  it('handles simple array as fields', async () => {
+    const arr1 = ['foo', 'bar', 'foo_bar']
+    expect(normalizeFields(arr1, [])).toEqual([
+      { key: 'foo', label: 'Foo' },
+      { key: 'bar', label: 'Bar' },
+      { key: 'foo_bar', label: 'Foo Bar' }
+    ])
+  })
+
+  it('handles mixed array format', async () => {
+    const arr1 = ['foo', { bar: { label: 'Bar Label' } }, { baz: 'Baz Label' }]
+
+    expect(normalizeFields(arr1, [])).toEqual([
+      { key: 'foo', label: 'Foo' },
+      { key: 'bar', label: 'Bar Label' },
+      { key: 'baz', label: 'Baz Label' }
+    ])
+  })
+
+  it('handles formatter shortcut', async () => {
+    const formatter = value => value
+    const arr1 = [{ foo: formatter }]
+
+    expect(normalizeFields(arr1, [])).toEqual([{ key: 'foo', label: 'Foo', formatter }])
+  })
+
+  it('handles when "key: false" shortcut', async () => {
+    const arr1 = [{ foo: false }, { bar: 'BAR' }]
+
+    // Should filter out when key uses false shortcut
+    expect(normalizeFields(arr1, [])).toEqual([{ key: 'bar', label: 'BAR' }])
+  })
+
+  it('removes duplicate fields (preserving the first found)', async () => {
+    const arr1 = ['foo', 'bar', 'foo', 'foo_bar']
+    const arr2 = [{ key: 'foo', label: 'Fiz' }, 'bar', 'foo', 'foo_bar']
+
+    expect(normalizeFields(arr1, [])).toEqual([
+      { key: 'foo', label: 'Foo' },
+      { key: 'bar', label: 'Bar' },
+      { key: 'foo_bar', label: 'Foo Bar' }
+    ])
+
+    expect(normalizeFields(arr2, [])).toEqual([
+      { key: 'foo', label: 'Fiz' },
+      { key: 'bar', label: 'Bar' },
+      { key: 'foo_bar', label: 'Foo Bar' }
+    ])
+  })
+})

package/src/vendor/bootstrap-vue/src/components/table/index.d.ts

@@ -0,0 +1,237 @@
+//
+// Table
+//
+import { BvComponent } from '../../'
+
+// Component: b-table
+export declare class BTable extends BvComponent {
+  // Public methods
+  refresh: () => void
+  clearSelected: () => void
+  selectAllRows: () => void
+  isRowSelected: (index: number) => boolean
+  selectRow: (index: number) => void
+  unselectRow: (index: number) => void
+  // Props
+  id?: string
+  items: Array<any> | BvTableProviderCallback
+  fields?: BvTableFieldArray
+  primaryKey?: string
+  sortBy?: string | null
+  sortKey?: string
+  sortDesc?: boolean
+  sortDirection?: BvTableSortDirection
+  sortCompare?: BvTableSortCompareCallback
+  sortCompareLocale?: string | Array<string>
+  sortCompareOptions?: BvTableLocaleCompareOptions
+  perPage?: number | string
+  currentPage?: number | string
+  filter?: string | Array<any> | RegExp | object | any
+  filterFunction?: BvTableFilterCallback
+  filterIgnoredFields?: Array<string>
+  filterIncludedFields?: Array<string>
+  busy?: boolean
+  tbodyTrClass?: string | Array<any> | object | BvTableTbodyTrClassCallback
+  tbodyTrAttr?: object | BvTableTbodyTrAttrCallback
+  tableVariant?: BvTableVariant | string
+  headVariant?: BvTableHeadFootVariant | string
+  footVariant?: BvTableHeadFootVariant | string
+  tbodyTransitionProps?: BvTableTbodyTransitionProps
+  tbodyTransitionHandlers?: BvTableTbodyTransitionHandlers
+  responsive?: boolean | string
+  stacked?: boolean | string
+  stickyHeader?: boolean
+}
+
+// Component: b-table-lite
+export declare class BTableLite extends BvComponent {
+  // Props
+  id?: string
+  items: Array<any> | BvTableProviderCallback
+  fields?: BvTableFieldArray
+  primaryKey?: string
+  tbodyTrClass?: string | Array<any> | object | BvTableTbodyTrClassCallback
+  tbodyTrAttr?: object | BvTableTbodyTrAttrCallback
+  tableClass?: string
+  tableVariant?: BvTableVariant | string
+  headVariant?: BvTableHeadFootVariant | string
+  footVariant?: BvTableHeadFootVariant | string
+  tbodyTransitionProps?: BvTableTbodyTransitionProps
+  tbodyTransitionHandlers?: BvTableTbodyTransitionHandlers
+  responsive?: boolean | string
+  stacked?: boolean | string
+  stickyHeader?: boolean
+}
+
+// Component: b-table-simple
+export declare class BTableSimple extends BvComponent {
+  // Props
+  id?: string
+  tableClass?: string
+  tabelVariant?: BvTableVariant | string
+  responsive?: boolean | string
+  stacked?: boolean | string
+  stickyHeader?: boolean
+}
+
+// Component: b-tbody
+export declare class BTbody extends BvComponent {
+  tbodyTransitionProps?: BvTableTbodyTransitionProps
+  tbodyTransitionHandlers?: BvTableTbodyTransitionHandlers
+}
+
+// Component: b-thead
+export declare class BThead extends BvComponent {
+  headVariant?: BvTableHeadFootVariant | string
+}
+
+// Component: b-tfoot
+export declare class BTfoot extends BvComponent {
+  footVariant?: BvTableHeadFootVariant | string
+}
+
+// Component: b-tr
+export declare class BTr extends BvComponent {
+  variant?: BvTableVariant | string
+}
+
+// Component: b-th
+export declare class BTh extends BvComponent {
+  variant?: BvTableVariant | string
+  colspan?: number | string
+  rowspan?: number | string
+  stackedHeading?: number | string
+  stickyColumn?: boolean
+}
+
+// Component: b-td
+export declare class BTd extends BvComponent {
+  variant?: BvTableVariant | string
+  colspan?: number | string
+  rowspan?: number | string
+  stackedHeading?: number | string
+  stickyColumn?: boolean
+}
+
+export type BvTableVariant =
+  | 'active'
+  | 'success'
+  | 'info'
+  | 'warning'
+  | 'danger'
+  | 'primary'
+  | 'secondary'
+  | 'light'
+  | 'dark'
+
+export type BvTableHeadFootVariant = 'light' | 'dark'
+
+export type BvTableSortDirection = 'asc' | 'desc' | 'last'
+
+export type BvTableFormatterCallback = ((value: any, key: string, item: any) => any)
+
+export type BvTableTbodyTrAttrCallback = ((item: any, type: string) => object)
+
+export type BvTableTbodyTrClassCallback = ((item: any, type: string) => any)
+
+export type BvTableFilterCallback = ((item: any, filter: any) => boolean)
+
+export type BvTableLocaleCompareOptionLocaleMatcher = 'lookup' | 'best fit'
+
+export type BvTableLocaleCompareOptionSensitivity = 'base' | 'accent' | 'case' | 'variant'
+
+export type BvTableLocaleCompareOptionCaseFirst = 'upper' | 'lower' | 'false'
+
+export type BvTableLocaleCompareOptionUsage = 'sort'
+
+export interface BvTableTbodyTransitionProps {
+  name?: string
+  appear?: boolean
+  css?: boolean
+  type?: string
+  duration?: number
+  moveClass?: string
+  enterClass?: string
+  leaveClass?: string
+  appearClass?: string
+  enterToClass?: string
+  leaveToClass?: string
+  appearToClass?: string
+  enterActiveClass?: string
+  leaveActiveClass?: string
+  appearActiveClass?: string
+}
+
+export interface BvTableTbodyTransitionHandlers {
+  beforeEnter?: (el: any) => void
+  beforeLeave?: (el: any) => void
+  beforeAppear?: (el: any) => void
+  enter?: (el: any, done: () => void) => void
+  leave?: (el: any, done: () => void) => void
+  appear?: (el: any, done: () => void) => void
+  afterEnter?: (el: any) => void
+  afterLeave?: (el: any) => void
+  afterAppear?: (el: any) => void
+  enterCancelled?: (el: any) => void
+  leaveCancelled?: (el: any) => void
+  appearCancelled?: (el: any) => void
+}
+
+export interface BvTableLocaleCompareOptions {
+  ignorePunctuation?: boolean
+  numeric?: boolean
+  localeMatcher?: BvTableLocaleCompareOptionLocaleMatcher
+  sensitivity?: BvTableLocaleCompareOptionSensitivity
+  caseFirst?: BvTableLocaleCompareOptionCaseFirst
+  usage?: BvTableLocaleCompareOptionUsage
+}
+
+export type BvTableSortCompareCallback = ((
+  a: any,
+  b: any,
+  field: string,
+  sortDesc?: boolean,
+  formatter?: BvTableFormatterCallback | undefined | null,
+  localeOptions?: BvTableLocaleCompareOptions,
+  locale?: string | Array<string> | undefined | null
+) => number | boolean | null | undefined)
+
+export interface BvTableCtxObject {
+  currentPage: number
+  perPage: number
+  filter: string | RegExp | BvTableFilterCallback | null
+  sortBy: string | null
+  sortDesc: boolean
+  apiUrl: string | null
+  [key: string]: any
+}
+
+export type BvTableProviderPromiseResult = Array<any> | null
+
+export interface BvTableProviderCallback {
+  (ctx: BvTableCtxObject): Array<any> | Promise<BvTableProviderPromiseResult> | any
+  (ctx: BvTableCtxObject, callback: () => Array<any>): null
+}
+
+export interface BvTableField {
+  label?: string
+  headerTitle?: string
+  headerAbbr?: string
+  class?: string | string[]
+  formatter?: string | BvTableFormatterCallback
+  sortable?: boolean
+  sortKey?: string
+  sortDirection?: BvTableSortDirection
+  sortByFormatted?: boolean | BvTableFormatterCallback
+  filterByFormatted?: boolean | BvTableFormatterCallback
+  tdClass?: string | string[] | ((value: any, key: string, item: any) => any)
+  thClass?: string | string[]
+  thStyle?: any
+  variant?: BvTableVariant | string
+  tdAttr?: any | ((value: any, key: string, item: any) => any)
+  thAttr?: any | ((value: any, key: string, item: any, type: string) => any)
+  stickyColumn?: boolean
+  isRowHeader?: boolean
+}
+
+export type BvTableFieldArray = Array<string | ({ key: string } & BvTableField)>