@furystack/shades-common-components 3.6.0 → 4.0.0

package/src/components/command-palette/command-palette-suggestion-list.tsx

@@ -1,66 +1,57 @@
 import { Shade, createComponent } from '@furystack/shades'
 import { promisifyAnimation } from '../../utils/promisify-animation'
-import type { CommandPaletteSuggestionResult } from './command-provider'
 import type { CommandPaletteManager } from './command-palette-manager'
 import { ThemeProviderService } from '../../services/theme-provider-service'
 
-export const CommandPaletteSuggestionList = Shade<
-  { manager: CommandPaletteManager; fullScreenSuggestions?: boolean },
-  { suggestions: CommandPaletteSuggestionResult[] }
->({
+export const CommandPaletteSuggestionList = Shade<{ manager: CommandPaletteManager; fullScreenSuggestions?: boolean }>({
   shadowDomName: 'shade-command-palette-suggestion-list',
-  getInitialState: ({ props }) => ({
-    suggestions: props.manager.currentSuggestions.getValue(),
-  }),
-  constructed: ({ updateState, element, props }) => {
+  render: ({ element, injector, props, useObservable }) => {
     const { manager } = props
-    const subscriptions = [
-      manager.currentSuggestions.subscribe((suggestions) => {
-        updateState({ suggestions })
-      }),
-      manager.isOpened.subscribe(async (isOpened) => {
-        const container = element.firstElementChild as HTMLDivElement
-        if (isOpened) {
-          container.style.display = 'initial'
-          container.style.zIndex = '1'
-          container.style.width = `calc(${Math.round(
-            element.parentElement?.getBoundingClientRect().width || 200,
-          )}px - 3em)`
-          await promisifyAnimation(
-            container,
-            [
-              { opacity: 0, transform: 'translate(0, -50px)' },
-              { opacity: 1, transform: 'translate(0, 0)' },
-            ],
-            { fill: 'forwards', duration: 500 },
-          )
+    const { theme } = injector.getInstance(ThemeProviderService)
+
+    const [suggestions] = useObservable('suggestions', props.manager.currentSuggestions)
+    const [selectedIndex] = useObservable('selectedIndex', props.manager.selectedIndex, (idx) => {
+      ;([...element.querySelectorAll('.suggestion-item')] as HTMLDivElement[]).map((s, i) => {
+        if (i === idx) {
+          s.style.background = theme.background.paper
+          s.style.fontWeight = 'bolder'
         } else {
-          await promisifyAnimation(
-            container,
-            [
-              { opacity: 1, transform: 'translate(0, 0)' },
-              { opacity: 0, transform: 'translate(0, -50px)' },
-            ],
-            { fill: 'forwards', duration: 200 },
-          )
-          container.style.zIndex = '-1'
-          container.style.display = 'none'
+          s.style.background = theme.background.default
+          s.style.fontWeight = 'normal'
         }
-      }),
-      manager.selectedIndex.subscribe((idx) => {
-        ;[...element.querySelectorAll('.suggestion-item')].map((s, i) => {
-          if (i === idx) {
-            ;(s as HTMLDivElement).style.background = 'rgba(128,128,128,0.2)'
-          } else {
-            ;(s as HTMLDivElement).style.background = 'rgba(96,96,96,0.2)'
-          }
-        })
-      }),
-    ]
-    return () => subscriptions.map((s) => s.dispose())
-  },
-  render: ({ element, injector, getState, props }) => {
-    const { manager } = props
+      })
+    })
+
+    const [isOpenedAtRender] = useObservable('isOpenedAtRender', props.manager.isOpened, async (isOpened) => {
+      const container = element.firstElementChild as HTMLDivElement
+      if (isOpened) {
+        container.style.display = 'initial'
+        container.style.zIndex = '1'
+        container.style.width = `calc(${Math.round(
+          element.parentElement?.getBoundingClientRect().width || 200,
+        )}px - 3em)`
+        await promisifyAnimation(
+          container,
+          [
+            { opacity: 0, transform: 'translate(0, -50px)' },
+            { opacity: 1, transform: 'translate(0, 0)' },
+          ],
+          { fill: 'forwards', duration: 500 },
+        )
+      } else {
+        await promisifyAnimation(
+          container,
+          [
+            { opacity: 1, transform: 'translate(0, 0)' },
+            { opacity: 0, transform: 'translate(0, -50px)' },
+          ],
+          { fill: 'forwards', duration: 200 },
+        )
+        container.style.zIndex = '-1'
+        container.style.display = 'none'
+      }
+    })
+
     return (
       <div
         className="suggestion-items-container"
@@ -75,22 +66,23 @@ export const CommandPaletteSuggestionList = Shade<
           maxHeight: `${window.innerHeight * 0.8}px`,
           zIndex: '1',
           left: 'auto',
-          backgroundColor: injector.getInstance(ThemeProviderService).theme.getValue().background.paper,
+          backgroundColor: theme.background.paper,
           boxShadow: '3px 3px 5px rgba(0,0,0,0.3)',
           width: `calc(${Math.round(element.parentElement?.getBoundingClientRect().width || 200)}px - 3em)`,
           ...(props.fullScreenSuggestions ? { left: '0', width: 'calc(100% - 42px)' } : {}),
         }}
       >
-        {getState().suggestions.map((s, i) => (
+        {suggestions.map((s, i) => (
           <div
             className="suggestion-item"
             onclick={() => {
-              manager.isOpened.getValue() && manager.selectSuggestion(injector, i)
+              isOpenedAtRender && manager.selectSuggestion(injector, i)
             }}
             style={{
               padding: '1em',
               cursor: 'default',
-              background: i === manager.selectedIndex.getValue() ? 'rgba(128,128,128,0.2)' : 'transparent',
+              background: i === selectedIndex ? theme.background.paper : theme.background.default,
+              fontWeight: i === selectedIndex ? 'bolder' : 'normal',
             }}
           >
             {s.element}

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,39 +67,29 @@ 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: ({ injector, element, props }) => {
-    const tp = injector.getInstance(ThemeProviderService)
-    return [
-      tp.theme.subscribe((t) => {
-        const headers = element.querySelectorAll('th')
-        const { r, g, b } = tp.getRgbFromColorString(t.background.paper)
-        headers.forEach((header) => {
-          header.style.color = t.text.secondary
-          header.style.backgroundColor = `rgba(${r}, ${g}, ${b}, 0.3)`
-        })
-      }),
-      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.theme.getValue()
+    const { theme } = tp
+
+    useDisposable(
+      'clickAway',
+      () =>
+        new ClickAwayService(element, () => {
+          props.service.hasFocus.setValue(false)
+        }),
+    )
 
-    const { r, g, b } = tp.getRgbFromColorString(theme.background.paper)
     const headerStyle: Partial<CSSStyleDeclaration> = {
-      backgroundColor: `rgba(${r}, ${g}, ${b}, 0.3)`,
-      backdropFilter: 'blur(10px)',
+      backdropFilter: 'blur(12px)',
       padding: '12px 0',
       color: theme.text.secondary,
       alignItems: 'center',

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

@@ -1,33 +1,22 @@
 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, injector, element }) => {
-    const disposables = [
-      props.service.data.subscribe((data) => updateState({ data })),
+  render: ({ props, injector, useObservable }) => {
+    const { theme } = injector.getInstance(ThemeProviderService)
 
-      injector.getInstance(ThemeProviderService).theme.subscribe((t) => {
-        const el = element.querySelector('div') as HTMLDivElement
-        el.style.color = t.text.secondary
-        el.style.background = t.background.paper
-      }),
-    ]
+    const [currentData] = useObservable('dataUpdater', props.service.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
-    const theme = injector.getInstance(ThemeProviderService).theme.getValue()
+    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
@@ -55,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()}