@furystack/shades-common-components 3.6.1 → 4.0.1

package/src/components/command-palette/index.tsx

@@ -6,6 +6,7 @@ import { CommandPaletteInput } from './command-palette-input'
 import { CommandPaletteSuggestionList } from './command-palette-suggestion-list'
 import type { CommandProvider } from './command-provider'
 import { ClickAwayService } from '../../services/click-away-service'
+import { ThemeProviderService } from '../../services'
 
 export * from './command-palette-input'
 export * from './command-palette-manager'
@@ -19,23 +20,35 @@ export interface CommandPaletteProps {
   fullScreenSuggestions?: boolean
 }
 
-export interface CommandPaletteState {
-  manager: CommandPaletteManager
-}
-
-export const CommandPalette = Shade<CommandPaletteProps, CommandPaletteState>({
+export const CommandPalette = Shade<CommandPaletteProps>({
   shadowDomName: 'shade-command-palette',
-  getInitialState: ({ props }) => ({
-    manager: new CommandPaletteManager(props.commandProviders),
-  }),
-  resources: ({ getState, element: rootElement }) => {
-    const { manager } = getState()
-    const element = rootElement.querySelector('.input-container') as HTMLDivElement
-    const clickAwayListener = new ClickAwayService(rootElement, () => manager.isOpened.setValue(false))
-    return [
-      manager.isOpened.subscribe((isOpened) => {
-        const suggestions = rootElement.querySelector('.close-suggestions')
-        const postControls = rootElement.querySelector('.post-controls')
+  render: ({ props, injector, element, useState, useDisposable, useObservable }) => {
+    element.style.flexGrow = '1'
+    const [manager] = useState('manager', new CommandPaletteManager(props.commandProviders))
+    const { theme } = injector.getInstance(ThemeProviderService)
+
+    useDisposable('clickAwayService', () => new ClickAwayService(element, () => manager.isOpened.setValue(false)))
+
+    const [isLoadingAtRender] = useObservable('isLoading', manager.isLoading, async (isLoading) => {
+      const loader = element.querySelector('.loader-container')
+      if (isLoading) {
+        promisifyAnimation(loader, [{ opacity: 0 }, { opacity: 1 }], {
+          duration: 100,
+          fill: 'forwards',
+        })
+      } else {
+        promisifyAnimation(loader, [{ opacity: 1 }, { opacity: 0 }], {
+          duration: 100,
+          fill: 'forwards',
+        })
+      }
+    })
+
+    const [isOpenedAtRender, setIsOpened] = useObservable('isOpened', manager.isOpened, (isOpened) => {
+      {
+        const suggestions = element.querySelector('.close-suggestions')
+        const postControls = element.querySelector('.post-controls')
+        const inputContainer = element.querySelector('.input-container') as HTMLDivElement
         if (isOpened) {
           promisifyAnimation(suggestions, [{ opacity: 0 }, { opacity: 1 }], {
             duration: 500,
@@ -47,11 +60,15 @@ export const CommandPalette = Shade<CommandPaletteProps, CommandPaletteState>({
             fill: 'forwards',
           })
 
-          promisifyAnimation(element, [{ background: 'transparent' }, { background: 'rgba(128,128,128,0.1)' }], {
-            duration: 500,
-            fill: 'forwards',
-            easing: 'cubic-bezier(0.050, 0.570, 0.840, 1.005)',
-          })
+          promisifyAnimation(
+            inputContainer,
+            [{ background: 'transparent' }, { background: theme.background.default }],
+            {
+              duration: 500,
+              fill: 'forwards',
+              easing: 'cubic-bezier(0.050, 0.570, 0.840, 1.005)',
+            },
+          )
         } else {
           promisifyAnimation(suggestions, [{ opacity: 1 }, { opacity: 0 }], {
             duration: 500,
@@ -64,34 +81,19 @@ export const CommandPalette = Shade<CommandPaletteProps, CommandPaletteState>({
             delay: 300,
           })
 
-          promisifyAnimation(element, [{ background: 'rgba(128,128,128,0.1)' }, { background: 'transparent' }], {
-            duration: 300,
-            fill: 'forwards',
-            easing: 'cubic-bezier(0.000, 0.245, 0.190, 0.790)',
-          })
+          promisifyAnimation(
+            inputContainer,
+            [{ background: theme.background.default }, { background: 'transparent' }],
+            {
+              duration: 300,
+              fill: 'forwards',
+              easing: 'cubic-bezier(0.000, 0.245, 0.190, 0.790)',
+            },
+          )
         }
-      }),
-      manager.isLoading.subscribe(async (isLoading) => {
-        const loader = rootElement.querySelector('.loader-container')
-        if (isLoading) {
-          promisifyAnimation(loader, [{ opacity: 0 }, { opacity: 1 }], {
-            duration: 100,
-            fill: 'forwards',
-          })
-        } else {
-          promisifyAnimation(loader, [{ opacity: 1 }, { opacity: 0 }], {
-            duration: 100,
-            fill: 'forwards',
-          })
-        }
-      }),
-      clickAwayListener,
-      manager,
-    ]
-  },
-  render: ({ props, injector, element, getState }) => {
-    element.style.flexGrow = '1'
-    const { manager } = getState()
+      }
+    })
+
     return (
       <div
         style={{ display: 'flex', flexDirection: 'column' }}
@@ -135,7 +137,7 @@ export const CommandPalette = Shade<CommandPaletteProps, CommandPaletteState>({
               fontWeight: 'bolder',
               textShadow: '0 0 1px #aaa',
             }}
-            onclick={() => manager.isOpened.setValue(true)}
+            onclick={() => setIsOpened(true)}
           >
             {props.defaultPrefix}
           </div>
@@ -146,19 +148,19 @@ export const CommandPalette = Shade<CommandPaletteProps, CommandPaletteState>({
               display: 'flex',
               alignItems: 'center',
               justifyContent: 'space-between',
-              width: manager.isOpened.getValue() ? '50px' : '0px',
+              width: isOpenedAtRender ? '50px' : '0px',
               overflow: 'hidden',
             }}
           >
             <div
               className="loader-container"
-              style={{ width: '20px', height: '20px', opacity: manager.isLoading.getValue() ? '1' : '0' }}
+              style={{ width: '20px', height: '20px', opacity: isLoadingAtRender ? '1' : '0' }}
             >
               <Loader style={{ width: '100%', height: '100%' }} />
             </div>
             <div
               className="close-suggestions"
-              onclick={() => manager.isOpened.setValue(false)}
+              onclick={() => setIsOpened(false)}
               style={{
                 width: '20px',
                 height: '20px',

package/src/components/data-grid/body.tsx

@@ -1,6 +1,6 @@
 import type { CollectionService } from '../../services/collection-service'
 import type { ChildrenList } from '@furystack/shades'
-import { Shade, createComponent, createFragment } from '@furystack/shades'
+import { Shade, createComponent } from '@furystack/shades'
 import type { DataRowCells } from './data-grid'
 import { Loader } from '../loader'
 import { DataGridRow } from './data-grid-row'
@@ -20,29 +20,17 @@ export interface DataGridBodyProps<T> {
   loaderComponent?: JSX.Element
 }
 
-export interface DataGridBodyState<T> {
-  data: T[]
-  isLoading: boolean
-}
-
-export const DataGridBody: <T>(props: DataGridBodyProps<T>, children: ChildrenList) => JSX.Element<any, any> = Shade<
-  DataGridBodyProps<any>,
-  DataGridBodyState<any>
+export const DataGridBody: <T>(props: DataGridBodyProps<T>, children: ChildrenList) => JSX.Element<any> = Shade<
+  DataGridBodyProps<any>
 >({
-  getInitialState: ({ props }) => ({
-    data: props.service.data.getValue().entries,
-    isLoading: props.service.isLoading.getValue(),
-  }),
-  resources: ({ props, updateState }) => [
-    props.service.data.subscribe((data) => updateState({ data: data.entries })),
-    props.service.isLoading.subscribe((isLoading) => updateState({ isLoading })),
-  ],
   shadowDomName: 'shade-data-grid-body',
-  render: ({ getState, props, element }) => {
+  render: ({ props, element, useObservable }) => {
     element.style.display = 'table-row-group'
-    const state = getState()
 
-    if (state.isLoading) {
+    const [data] = useObservable('data', props.service.data)
+    const [isLoading] = useObservable('isLoading', props.service.isLoading)
+
+    if (isLoading) {
       return (
         <div style={{ display: 'flex', height: '100%', justifyContent: 'center', alignItems: 'center', width: '100%' }}>
           {/* TODO: Skeleton */}
@@ -51,13 +39,13 @@ export const DataGridBody: <T>(props: DataGridBodyProps<T>, children: ChildrenLi
       )
     }
 
-    if (!state.data?.length) {
+    if (!data?.entries?.length) {
       return props.emptyComponent || <div> - No Data - </div>
     }
 
     return (
       <>
-        {state.data.map((entry) => (
+        {data?.entries?.map((entry) => (
           <DataGridRow<any>
             columns={props.columns}
             entry={entry}

package/src/components/data-grid/data-grid-row.tsx

@@ -1,5 +1,6 @@
 import type { ChildrenList } from '@furystack/shades'
-import { attachStyles, createComponent, createFragment, Shade } from '@furystack/shades'
+import { attachStyles, createComponent, Shade } from '@furystack/shades'
+import { ThemeProviderService } from '../../services'
 import type { CollectionService } from '../../services/collection-service'
 import type { DataRowCells } from './data-grid'
 
@@ -16,87 +17,88 @@ export interface DataGridRowProps<T> {
   unselectedRowStyle?: Partial<CSSStyleDeclaration>
 }
 
-export interface DataGridRowState<T> {
-  selection?: T[]
-  focus?: T
-}
-
-export const DataGridRow: <T>(props: DataGridRowProps<T>, children: ChildrenList) => JSX.Element<any, any> = Shade<
-  DataGridRowProps<any>,
-  DataGridRowState<any>
+export const DataGridRow: <T>(props: DataGridRowProps<T>, children: ChildrenList) => JSX.Element<any> = Shade<
+  DataGridRowProps<any>
 >({
-  getInitialState: ({ props }) => ({
-    focus: props.service.focusedEntry.getValue(),
-    selection: props.service.selection.getValue(),
-  }),
   shadowDomName: 'shades-data-grid-row',
-  resources: ({ props, element }) => [
-    props.service.focusedEntry.subscribe((newEntry) => {
-      if (newEntry === props.entry) {
-        attachStyles(element, {
-          style: props.focusedRowStyle || {
-            filter: 'brightness(1.5)',
-            fontWeight: 'bolder',
-          },
-        })
 
-        element.classList.add('focused')
+  render: ({ props, element, useObservable, injector }) => {
+    const { entry, rowComponents, columns, service } = props
 
-        const headerHeight = element.closest('table')?.querySelector('th')?.getBoundingClientRect().height || 42
+    const { theme } = injector.getInstance(ThemeProviderService)
 
-        const parent = element.closest('.shade-grid-wrapper') as HTMLElement
-        const maxTop = element.offsetTop - headerHeight
-        const currentTop = parent.scrollTop
-        if (maxTop < currentTop) {
-          parent.scrollTo({ top: maxTop, behavior: 'smooth' })
-        }
-
-        const footerHeight =
-          element.closest('shade-data-grid')?.querySelector('shade-data-grid-footer')?.getBoundingClientRect().height ||
-          42
-        const visibleMaxTop = parent.clientHeight - footerHeight
-        const desiredMaxTop = element.offsetTop + element.clientHeight
-        if (desiredMaxTop > visibleMaxTop) {
-          parent.scrollTo({ top: desiredMaxTop - visibleMaxTop, behavior: 'smooth' })
-        }
-      } else {
-        element.classList.remove('focused')
-        attachStyles(element, {
-          style: props.unfocusedRowStyle || {
-            filter: 'brightness(1)',
-            fontWeight: 'inherit',
-          },
-        })
-      }
-    }, true),
-    props.service.selection.subscribe((selection) => {
-      if (selection.includes(props.entry)) {
+    const attachSelectedStyles = (selection: any[]) => {
+      if (selection.includes(entry)) {
         element.classList.add('selected')
-        attachStyles(element, { style: props.selectedRowStyle || { backgroundColor: 'rgba(128,128,128,0.1)' } })
+        attachStyles(element, { style: props.selectedRowStyle || { backgroundColor: theme.background.default } })
         element.setAttribute('aria-selected', 'true')
       } else {
         element.classList.remove('selected')
         attachStyles(element, { style: props.unselectedRowStyle || { backgroundColor: 'transparent' } })
         element.setAttribute('aria-selected', 'false')
       }
-    }, true),
-  ],
+    }
+
+    const [selection] = useObservable('isSelected', service.selection, attachSelectedStyles, true)
+
+    attachSelectedStyles(selection)
+
+    const [focus] = useObservable(
+      'focus',
+      service.focusedEntry,
+      (newEntry) => {
+        if (newEntry === props.entry) {
+          attachStyles(element, {
+            style: props.focusedRowStyle || {
+              boxShadow: `0 0 0 1px ${theme.palette.primary.main}`,
+              fontWeight: 'bolder',
+            },
+          })
+
+          element.classList.add('focused')
+
+          const headerHeight = element.closest('table')?.querySelector('th')?.getBoundingClientRect().height || 42
+
+          const parent = element.closest('.shade-grid-wrapper') as HTMLElement
+          const maxTop = element.offsetTop - headerHeight
+          const currentTop = parent.scrollTop
+          if (maxTop < currentTop) {
+            parent.scrollTo({ top: maxTop, behavior: 'smooth' })
+          }
+
+          const footerHeight =
+            element.closest('shade-data-grid')?.querySelector('shade-data-grid-footer')?.getBoundingClientRect()
+              .height || 42
+          const visibleMaxTop = parent.clientHeight - footerHeight
+          const desiredMaxTop = element.offsetTop + element.clientHeight
+          if (desiredMaxTop > visibleMaxTop) {
+            parent.scrollTo({ top: desiredMaxTop - visibleMaxTop, behavior: 'smooth' })
+          }
+        } else {
+          element.classList.remove('focused')
+          attachStyles(element, {
+            style: props.unfocusedRowStyle || {
+              boxShadow: 'none',
+              fontWeight: 'inherit',
+            },
+          })
+        }
+      },
+      true,
+    )
 
-  render: ({ getState, props, element }) => {
-    const state = getState()
-    const { entry, rowComponents, columns } = props
     element.style.display = 'table-row'
     element.style.cursor = 'default'
     element.style.userSelect = 'none'
-    if (state.selection?.includes(entry)) {
+    if (selection?.includes(entry)) {
       element.setAttribute('aria-selected', 'true')
       element.classList.add('selected')
     }
 
-    if (state.focus === entry) {
+    if (focus === entry) {
       element.classList.add('focused')
     }
-    element.setAttribute('aria-selected', state.selection?.includes(entry).toString() || 'false')
+    element.setAttribute('aria-selected', selection?.includes(entry).toString() || 'false')
 
     return (
       <>
@@ -106,9 +108,8 @@ export const DataGridRow: <T>(props: DataGridRowProps<T>, children: ChildrenList
             onclick={(ev) => props.onRowClick?.(entry, ev)}
             ondblclick={(ev) => props.onRowDoubleClick?.(entry, ev)}
           >
-            {rowComponents?.[column]?.(entry, state) || rowComponents?.default?.(entry, state) || (
-              <span>{entry[column]}</span>
-            )}
+            {rowComponents?.[column]?.(entry, { selection, focus }) ||
+              rowComponents?.default?.(entry, { selection, focus }) || <span>{entry[column]}</span>}
           </td>
         ))}
       </>

package/src/components/data-grid/data-grid.tsx

@@ -6,13 +6,12 @@ import { DataGridHeader } from './header'
 import { DataGridBody } from './body'
 import { DataGridFooter } from './footer'
 import { ClickAwayService, ThemeProviderService } from '../../services'
-import type { DataGridRowState } from './data-grid-row'
 
 export type DataHeaderCells<T> = {
   [TKey in keyof T | 'default']?: (name: keyof T) => JSX.Element
 }
 export type DataRowCells<T> = {
-  [TKey in keyof T | 'default']?: (element: T, state: DataGridRowState<T>) => JSX.Element
+  [TKey in keyof T | 'default']?: (element: T, state: { focus?: T; selection: T[] }) => JSX.Element
 }
 
 export interface DataGridProps<T> {
@@ -68,26 +67,27 @@ export interface DataGridProps<T> {
   loaderComponent?: JSX.Element
 }
 
-export const DataGrid: <T>(props: DataGridProps<T>, children: ChildrenList) => JSX.Element<any, any> = Shade<
+export const DataGrid: <T>(props: DataGridProps<T>, children: ChildrenList) => JSX.Element<any> = Shade<
   DataGridProps<any>
 >({
   shadowDomName: 'shade-data-grid',
-  resources: ({ element, props }) => {
-    return [
-      new ClickAwayService(element, () => {
-        props.service.hasFocus.setValue(false)
-      }),
-    ]
-  },
   constructed: ({ props }) => {
     const listener = (ev: KeyboardEvent) => props.service.handleKeyDown(ev)
     window.addEventListener('keydown', listener)
     return () => window.removeEventListener('keydown', listener)
   },
-  render: ({ props, injector }) => {
+  render: ({ props, injector, useDisposable, element }) => {
     const tp = injector.getInstance(ThemeProviderService)
     const { theme } = tp
 
+    useDisposable(
+      'clickAway',
+      () =>
+        new ClickAwayService(element, () => {
+          props.service.hasFocus.setValue(false)
+        }),
+    )
+
     const headerStyle: Partial<CSSStyleDeclaration> = {
       backdropFilter: 'blur(12px)',
       padding: '12px 0',

package/src/components/data-grid/footer.tsx

@@ -1,26 +1,23 @@
 import { Shade, createComponent } from '@furystack/shades'
 import { ThemeProviderService } from '../../services'
-import type { CollectionService, CollectionData } from '../../services/collection-service'
+import type { CollectionService } from '../../services/collection-service'
 
 export const dataGridItemsPerPage = [10, 20, 25, 50, 100, Infinity]
 
-export const DataGridFooter = Shade<{ service: CollectionService<any> }, { data: CollectionData<any> }>({
+export const DataGridFooter = Shade<{ service: CollectionService<any> }>({
   shadowDomName: 'shade-data-grid-footer',
-  getInitialState: ({ props }) => ({
-    data: props.service.data.getValue(),
-  }),
-  constructed: ({ props, updateState }) => {
-    const disposables = [props.service.data.subscribe((data) => updateState({ data }))]
-
-    return () => disposables.forEach((d) => d.dispose())
-  },
-  render: ({ props, getState, injector }) => {
-    const state = getState()
-    const currentQuerySettings = props.service.querySettings.getValue()
-    const currentPage = Math.ceil(currentQuerySettings.skip || 0) / (currentQuerySettings.top || 1)
-    const currentEntriesPerPage = currentQuerySettings.top || Infinity
+  render: ({ props, injector, useObservable }) => {
     const { theme } = injector.getInstance(ThemeProviderService)
 
+    const [currentData] = useObservable('dataUpdater', props.service.data)
+
+    const [currentQuerySettings] = useObservable('querySettings', props.service.querySettings)
+
+    const top = currentQuerySettings.top || Infinity
+    const skip = currentQuerySettings.skip || 0
+    const currentPage = Math.ceil(skip) / (top || 1)
+    const currentEntriesPerPage = top
+
     return (
       <div
         className="pager"
@@ -47,7 +44,7 @@ export const DataGridFooter = Shade<{ service: CollectionService<any> }, { data:
               }}
             >
               {[
-                ...new Array(Math.ceil(state.data.count / (props.service.querySettings.getValue().top || Infinity))),
+                ...new Array(Math.ceil(currentData.count / (props.service.querySettings.getValue().top || Infinity))),
               ].map((_val, index) => (
                 <option value={index.toString()} selected={currentPage === index}>
                   {(index + 1).toString()}

package/src/components/data-grid/header.tsx

@@ -19,37 +19,41 @@ export interface DataGridHeaderState<T> {
 export const DataGridHeader: <T, K extends keyof T>(
   props: DataGridHeaderProps<T, K>,
   children: ChildrenList,
-) => JSX.Element<any, any> = Shade<DataGridHeaderProps<any, any>, DataGridHeaderState<any>>({
+) => JSX.Element<any> = Shade<DataGridHeaderProps<any, any>>({
   shadowDomName: 'data-grid-header',
-  getInitialState: ({ props }) => ({
-    querySettings: props.collectionService.querySettings.getValue(),
-    isSearchOpened: false,
-    updateSearchValue: debounce((value: string) => {
-      const currentSettings = props.collectionService.querySettings.getValue()
-      const newSettings: FindOptions<unknown, any> = {
-        ...currentSettings,
-        filter: {
-          ...currentSettings.filter,
-          [props.field]: { $regex: value },
-        },
-      }
-      props.collectionService.querySettings.setValue(newSettings)
-    }),
-  }),
-  constructed: ({ props, updateState, getState }) => {
-    const disposable = props.collectionService.querySettings.subscribe((querySettings) =>
-      updateState({ querySettings }, getState().isSearchOpened),
+  // getInitialState: ({ props }) => ({
+  //   querySettings: props.collectionService.querySettings.getValue(),
+  //   isSearchOpened: false,
+  // updateSearchValue: ,
+  // }),
+  render: ({ props, element, useState, useObservable }) => {
+    const [querySettings, setQuerySettings] = useObservable('querySettings', props.collectionService.querySettings)
+    const currentOrder = Object.keys(querySettings.order || {})[0]
+    const currentOrderDirection = Object.values(querySettings.order || {})[0]
+
+    const [isSearchOpened, setIsSearchOpened] = useState('isSearchOpened', false)
+    const [updateSearchValue] = useState(
+      'updateSearchValue',
+      debounce((value: string) => {
+        const currentSettings = props.collectionService.querySettings.getValue()
+        const newSettings: FindOptions<unknown, any> = {
+          ...currentSettings,
+          filter: {
+            ...currentSettings.filter,
+            [props.field]: { $regex: value },
+          },
+        }
+        props.collectionService.querySettings.setValue(newSettings)
+      }),
     )
-    return () => disposable.dispose()
-  },
-  render: ({ getState, props, updateState, element }) => {
-    const currentState = getState()
-    const currentOrder = Object.keys(currentState.querySettings.order || {})[0]
-    const currentOrderDirection = Object.values(currentState.querySettings.order || {})[0]
 
     const filterValue = (props.collectionService.querySettings.getValue().filter as any)?.[props.field]?.$regex || ''
 
-    if (currentState.isSearchOpened) {
+    useObservable('querySettingsChange', props.collectionService.querySettings, (newSettings) => {
+      setQuerySettings(newSettings)
+    })
+
+    if (isSearchOpened) {
       setTimeout(() => {
         element.querySelector('input')?.focus()
       }, 1)
@@ -59,8 +63,8 @@ export const DataGridHeader: <T, K extends keyof T>(
           value={filterValue}
           placeholder={props.field}
           autofocus
-          onblur={() => updateState({ isSearchOpened: false })}
-          onkeyup={(ev) => currentState.updateSearchValue((ev.target as HTMLInputElement).value)}
+          onblur={() => setIsSearchOpened(false)}
+          onkeyup={(ev) => updateSearchValue((ev.target as HTMLInputElement).value)}
           labelProps={{
             style: { padding: '0px 2em' },
           }}
@@ -71,7 +75,7 @@ export const DataGridHeader: <T, K extends keyof T>(
     return (
       <div
         style={{ display: 'flex', width: '100%', height: '100%', justifyContent: 'space-around' }}
-        onclick={() => updateState({ isSearchOpened: true })}
+        onclick={() => setIsSearchOpened(true)}
       >
         <div>{props.field}</div>
         <div className="header-controls" style={{ display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
@@ -88,7 +92,7 @@ export const DataGridHeader: <T, K extends keyof T>(
               }
               newOrder[props.field] = newDirection
               props.collectionService.querySettings.setValue({
-                ...currentState.querySettings,
+                ...querySettings,
                 order: newOrder,
               })
             }}

package/src/components/data-grid/selection-cell.tsx

@@ -3,29 +3,19 @@ import type { CollectionService } from '../../services'
 
 export const SelectionCell = Shade<{ entry: any; service: CollectionService<any> }>({
   shadowDomName: 'shades-data-grid-selection-cell',
-  resources: ({ props, element }) => [
-    props.service.selection.subscribe((selection) => {
-      if (selection.includes(props.entry)) {
-        ;(element.firstChild as HTMLInputElement).checked = true
-      } else {
-        ;(element.firstChild as HTMLInputElement).checked = false
-      }
-    }),
-  ],
-  render: ({ props }) => {
+  render: ({ props, useObservable, element }) => {
+    const [selection] = useObservable('selection', props.service.selection, (newSelection) => {
+      ;(element.querySelector('input') as HTMLInputElement).checked = newSelection.includes(props.entry)
+    })
+    const isSelected = selection.includes(props.entry)
+
     return (
       <input
-        onchange={(ev) => {
-          if ((ev.target as HTMLInputElement).checked) {
-            props.service.selection.setValue([...props.service.selection.getValue(), props.entry])
-          } else {
-            props.service.selection.setValue([
-              ...props.service.selection.getValue().filter((entry) => entry !== props.entry),
-            ])
-          }
+        onchange={() => {
+          props.service.toggleSelection(props.entry)
         }}
         type="checkbox"
-        checked={props.service.selection.getValue().includes(props.entry) ? true : false}
+        checked={isSelected}
       />
     )
   },