@furystack/shades-common-components 3.6.1 → 4.0.0

package/src/components/button.tsx

@@ -1,4 +1,5 @@
 import type { PartialElement } from '@furystack/shades'
+import { attachProps } from '@furystack/shades'
 import { Shade, createComponent } from '@furystack/shades'
 import { promisifyAnimation } from '../utils/promisify-animation'
 import type { Palette, Theme } from '../services/theme-provider-service'
@@ -73,9 +74,9 @@ export const Button = Shade<ButtonProps>({
      * @param ev The Mouse event
      */
     function mouseUp(this: Document, ev: MouseEvent) {
-      if (ev.target === element.firstElementChild) {
+      if (ev.target === element) {
         promisifyAnimation(
-          element.firstChild as Element,
+          element,
           [
             {
               filter: 'drop-shadow(1px 1px 10px rgba(0,0,0,.5))brightness(1)',
@@ -94,32 +95,28 @@ export const Button = Shade<ButtonProps>({
     }
   },
   shadowDomName: 'shade-button',
-  resources: ({ injector, element, props }) => {
-    const tp = injector.getInstance(ThemeProviderService)
-    return [
-      ...(props.variant === 'contained'
-        ? [
-            Trace.method({
-              object: tp,
-              method: tp.set,
-              onFinished: () => {
-                const el = element.firstElementChild as HTMLButtonElement
-                el.style.color = getTextColor(props, tp.theme, () =>
-                  tp.getTextColor(el.style.background || el.style.backgroundColor),
-                )
-              },
-            }),
-          ]
-        : []),
-    ]
-  },
-  render: ({ props, children, injector, element }) => {
+  render: ({ props, children, injector, element, useDisposable }) => {
     const mouseDownHandler = props.onmousedown
     const mouseUpHandler = props.onmouseup
     const themeProvider = injector.getInstance(ThemeProviderService)
     const { theme } = themeProvider
     const background = getBackground(props, theme)
 
+    if (props.variant === 'contained') {
+      useDisposable('themeChanged', () =>
+        Trace.method({
+          object: themeProvider,
+          method: themeProvider.set,
+          onFinished: () => {
+            const el = element
+            el.style.color = getTextColor(props, themeProvider.theme, () =>
+              themeProvider.getTextColor(el.style.background || el.style.backgroundColor),
+            )
+          },
+        }),
+      )
+    }
+
     const hoveredBackground = getHoveredBackground(props, theme, () => {
       const { r, g, b } = themeProvider.getRgbFromColorString(
         (props.color && theme.palette[props.color].main) || theme.text.primary,
@@ -136,76 +133,76 @@ export const Button = Shade<ButtonProps>({
       keyframes: PropertyIndexedKeyframes | Keyframe[] | null,
       options?: number | KeyframeAnimationOptions | undefined,
     ) => {
-      const el = element.firstElementChild
+      const el = element
       el && promisifyAnimation(el, keyframes, options)
     }
 
-    return (
-      <button
-        onmousedown={function (ev) {
-          mouseDownHandler?.call(this, ev)
-          tryAnimate(
-            [
-              {
-                filter: 'drop-shadow(-1px -1px 3px black)brightness(0.5)',
-                transform: 'scale(0.98)',
-              },
-            ],
-            { duration: 150, fill: 'forwards', easing: 'cubic-bezier(0.230, 1.000, 0.320, 1.000)' },
-          )
-        }}
-        onmouseup={function (ev) {
-          mouseUpHandler?.call(this, ev)
-        }}
-        onmouseenter={() => {
-          tryAnimate(
-            [
-              {
-                background,
-                boxShadow,
-                color: getTextColorInner(),
-              },
-              {
-                background: hoveredBackground,
-                boxShadow: hoveredBoxShadow,
-                color: getHoveredTextColorInner(),
-              },
-            ],
-            { duration: 500, fill: 'forwards', easing: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)' },
-          )
-        }}
-        onmouseout={() => {
-          tryAnimate(
-            [
-              { background: hoveredBackground, boxShadow: hoveredBoxShadow, color: getHoveredTextColorInner() },
-              { background, boxShadow, color: getTextColorInner() },
-            ],
+    attachProps(element, {
+      ...props,
+      onmousedown(this: HTMLElement, ev: MouseEvent) {
+        mouseDownHandler?.call(this, ev)
+        tryAnimate(
+          [
+            {
+              filter: 'drop-shadow(-1px -1px 3px black)brightness(0.5)',
+              transform: 'scale(0.98)',
+            },
+          ],
+          { duration: 150, fill: 'forwards', easing: 'cubic-bezier(0.230, 1.000, 0.320, 1.000)' },
+        )
+      },
+      onmouseup(this: HTMLElement, ev: MouseEvent) {
+        mouseUpHandler?.call(this, ev)
+      },
+      onmouseenter: () => {
+        tryAnimate(
+          [
             {
-              duration: 500,
-              fill: 'forwards',
-              easing: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+              background,
+              boxShadow,
+              color: getTextColorInner(),
             },
-          )
-        }}
-        {...props}
-        style={{
-          cursor: props.disabled ? 'not-allowed' : 'pointer',
-          background,
-          boxShadow,
-          margin: '8px',
-          padding: '6px 16px',
-          border: 'none',
-          borderRadius: '4px',
-          textTransform: 'uppercase',
-          color: getTextColorInner(),
-          filter: 'drop-shadow(1px 1px 10px rgba(0,0,0,.5))',
-          backdropFilter: props.variant === 'outlined' ? 'blur(35px)' : undefined,
-          userSelect: 'none',
-          ...props.style,
-        }}
-      >
-        {children}
-      </button>
-    )
+            {
+              background: hoveredBackground,
+              boxShadow: hoveredBoxShadow,
+              color: getHoveredTextColorInner(),
+            },
+          ],
+          { duration: 500, fill: 'forwards', easing: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)' },
+        )
+      },
+      onmouseout: () => {
+        tryAnimate(
+          [
+            { background: hoveredBackground, boxShadow: hoveredBoxShadow, color: getHoveredTextColorInner() },
+            { background, boxShadow, color: getTextColorInner() },
+          ],
+          {
+            duration: 500,
+            fill: 'forwards',
+            easing: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+          },
+        )
+      },
+      ...props,
+      style: {
+        display: 'inline-flex',
+        cursor: props.disabled ? 'not-allowed' : 'pointer',
+        background,
+        boxShadow,
+        margin: '8px',
+        padding: '6px 16px',
+        border: 'none',
+        borderRadius: '4px',
+        textTransform: 'uppercase',
+        color: getTextColorInner(),
+        filter: 'drop-shadow(1px 1px 10px rgba(0,0,0,.5))',
+        backdropFilter: props.variant === 'outlined' ? 'blur(35px)' : undefined,
+        userSelect: 'none',
+        ...props.style,
+      },
+    })
+
+    return <>{children}</>
   },
 })

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

@@ -1,13 +1,18 @@
 import { Shade, createComponent } from '@furystack/shades'
+import { ThemeProviderService } from '../../services'
 import { promisifyAnimation } from '../../utils/promisify-animation'
 import type { CommandPaletteManager } from './command-palette-manager'
 
-export const CommandPaletteInput = Shade<{ manager: CommandPaletteManager }, { isOpened: boolean }>({
-  getInitialState: ({ props }) => ({ isOpened: props.manager.isOpened.getValue() }),
-  constructed: ({ element, props }) => {
+export const CommandPaletteInput = Shade<{ manager: CommandPaletteManager }>({
+  shadowDomName: 'shades-command-palette-input',
+  render: ({ element, props, injector, useObservable }) => {
+    const { theme } = injector.getInstance(ThemeProviderService)
     const { manager } = props
-    const subscriptions = [
-      manager.isOpened.subscribe(async (isOpened) => {
+
+    useObservable(
+      'isOpened',
+      manager.isOpened,
+      async (isOpened) => {
         const input = element.firstChild as HTMLInputElement
         if (isOpened) {
           input.value = ''
@@ -25,20 +30,17 @@ export const CommandPaletteInput = Shade<{ manager: CommandPaletteManager }, { i
           })
           input.value = ''
         }
-      }),
-    ]
-    return () => subscriptions.map((s) => s.dispose())
-  },
-  shadowDomName: 'shades-command-palette-input',
-  render: ({ element, props }) => {
-    const { manager } = props
+      },
+      true,
+    )
+
     element.style.width = manager.isOpened.getValue() ? '100%' : '0%'
     element.style.overflow = 'hidden'
     return (
       <input
         autofocus
         style={{
-          color: 'white',
+          color: theme.text.primary,
           outline: 'none',
           padding: '1em',
           background: 'transparent',

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.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}