@loadsmart/loadsmart-ui 5.13.1 → 5.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadsmart/loadsmart-ui",
-  "version": "5.13.1",
+  "version": "5.13.2",
   "description": "Miranda UI, a React UI library",
   "main": "dist",
   "files": [

package/src/components/Select/useSelect.helpers.test.ts

@@ -1,4 +1,4 @@
-import { getDisplayValue, getValue } from './useSelect.helpers'
+import { getDisplayValue, getValue, toSelection } from './useSelect.helpers'
 import generator from '../../tests/generator'
 
 import type { SelectAdapter, SelectValue, Option } from './Select.types'
@@ -60,6 +60,15 @@ describe('useSelect helpers', () => {
 
       expect(getDisplayValue(adapters, selection, multiple)).toEqual(adapter.getLabel(item))
     })
+
+    it('returns empty string as display value when selection label is undefined', () => {
+      const selection: SelectValue = new Map().set(undefined, {
+        label: undefined,
+        value: undefined,
+      })
+
+      expect(getDisplayValue(adapters, selection, multiple)).toEqual('')
+    })
   })
 
   describe('multiple selection', () => {
@@ -118,5 +127,58 @@ describe('useSelect helpers', () => {
 
       expect(getDisplayValue(adapters, selection, multiple)).toEqual('')
     })
+
+    it('returns empty string as display value when selection label is undefined', () => {
+      const selection: SelectValue = new Map().set(undefined, {
+        label: undefined,
+        value: undefined,
+      })
+
+      expect(getDisplayValue(adapters, selection, multiple)).toEqual('')
+    })
+  })
+
+  describe('getSelection', () => {
+    it('initializes correctly when a null value is provided', () => {
+      expect(toSelection(null)).toEqual([])
+    })
+
+    it('initializes correctly when an undefined value is provided', () => {
+      expect(toSelection(undefined)).toEqual([])
+    })
+
+    it('initializes correctly when a valid value is provided', () => {
+      expect(
+        toSelection({
+          value: 'some-value',
+          label: 'Some label',
+        } as Option)
+      ).toEqual([
+        {
+          value: 'some-value',
+          label: 'Some label',
+        },
+      ])
+
+      expect(
+        toSelection([
+          {
+            value: 'some-value-1',
+            label: 'Some label 1',
+          } as Option,
+        ])
+      ).toEqual([
+        {
+          value: 'some-value-1',
+          label: 'Some label 1',
+        },
+      ])
+    })
+
+    it('initializes correctly when an empty value is provided', () => {
+      expect(toSelection([])).toEqual([])
+      expect(toSelection({})).toEqual([])
+      expect(toSelection([{}])).toEqual([])
+    })
   })
 })

package/src/components/Select/useSelect.helpers.ts

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { GenericAdapter } from './Select.constants'
 import isEmpty from 'utils/toolset/isEmpty'
+import toArray from 'utils/toolset/toArray'
 
-import type { SelectAdapter, SelectValue, Option, Adapters } from './Select.types'
+import type { SelectAdapter, SelectValue, Option, Adapters, SelectProps } from './Select.types'
 
 export function getAdapter(adapters: Adapters, type?: string): SelectAdapter<any> {
   if (type == null) {
@@ -32,6 +33,12 @@ export function getValue(selection: SelectValue, multiple?: boolean): Option | O
   }
 }
 
+export function toSelection(value: SelectProps['value']): Option[] {
+  const safeValue = toArray(value || [])
+
+  return safeValue.filter((option) => !isEmpty(option))
+}
+
 export function getDisplayValue(
   adapters: Adapters,
   selection: SelectValue,
@@ -46,7 +53,7 @@ export function getDisplayValue(
   } else {
     const value = getValue(selection, multiple)
     const adapter = getAdapter(adapters, (value as Option)._type)
-    return adapter.getLabel(value)
+    return adapter.getLabel(value) ?? ''
   }
 }
 

package/src/components/Select/useSelect.test.ts

@@ -0,0 +1,207 @@
+import { renderHook } from '@testing-library/react-hooks'
+
+import useSelect from './useSelect'
+import type { SelectProps, Option } from './Select.types'
+
+describe('useSelect', () => {
+  describe('single selection', () => {
+    it('initializes correctly when no value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when a null value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+        value: null,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when an undefined value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+        value: undefined,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when a valid value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+        value: {
+          value: 'some-value',
+          label: 'Some label',
+        } as Option,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map().set('some-value', {
+        value: 'some-value',
+        label: 'Some label',
+      })
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('Some label')
+    })
+
+    it('initializes correctly when an invalid value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+        value: {
+          label: undefined,
+          value: undefined,
+        } as Option,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map().set(undefined, {
+        label: undefined,
+        value: undefined,
+      })
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when an empty value is provided', () => {
+      const props: SelectProps = {
+        multiple: false,
+        name: 'anything',
+        value: {},
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+  })
+
+  describe('multiple selection', () => {
+    it('initializes correctly when no value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when a null value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+        value: null,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when an undefined value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+        value: undefined,
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when a valid value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+        value: [
+          {
+            value: 'some-value',
+            label: 'Some label',
+          } as Option,
+        ],
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+
+      const expectedSelected = new Map().set('some-value', {
+        value: 'some-value',
+        label: 'Some label',
+      })
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when an invalid value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+        value: [
+          {
+            label: undefined,
+            value: undefined,
+          } as Option,
+        ],
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+      const expectedSelected = new Map().set(undefined, {
+        label: undefined,
+        value: undefined,
+      })
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+
+    it('initializes correctly when an empty value is provided', () => {
+      const props: SelectProps = {
+        multiple: true,
+        name: 'anything',
+        value: [{}],
+      }
+
+      const { result } = renderHook(() => useSelect(props))
+
+      const expectedSelected = new Map()
+
+      expect(result.current.selectable.selected).toEqual(expectedSelected)
+      expect(result.current.query).toBe('')
+    })
+  })
+})

package/src/components/Select/useSelect.ts

@@ -13,7 +13,13 @@ import { isThenable } from 'utils/toolset/isThenable'
 import toArray from 'utils/toolset/toArray'
 import { GenericAdapter } from './Select.constants'
 import { useSelectable } from './Select.context'
-import { escapeRegExp, getAdapter, getDisplayValue, getValue } from './useSelect.helpers'
+import {
+  escapeRegExp,
+  getAdapter,
+  getDisplayValue,
+  getValue,
+  toSelection,
+} from './useSelect.helpers'
 
 import type { ChangeEvent, FocusEvent } from 'react'
 import type {
@@ -213,7 +219,7 @@ function useSelect(props: SelectProps): useSelectReturn {
   const adapters = useMemo<Adapters>(() => extractAdapters(datasources), [datasources])
 
   const selectable = useSelectable({
-    selected: toArray(props.value || []),
+    selected: toSelection(props.value),
     multiple,
     adapters,
     onChange: useCallback(