@dxos/react-ui 0.8.4-main.e8ec1fe → 0.8.4-main.ef1bc66f44

package/src/components/ScrollContainer/ScrollContainer.stories.tsx

@@ -45,16 +45,17 @@ const DefaultStory = (props: ScrollContainerRootProps) => {
             </div>
           ))}
         </ScrollContainer.Viewport>
+        <ScrollContainer.ScrollDownButton />
       </ScrollContainer.Root>
     </div>
   );
 };
 
 const meta = {
-  title: 'ui/react-ui-core/ScrollContainer',
+  title: 'ui/react-ui-core/components/ScrollContainer',
   component: ScrollContainer.Root,
   render: DefaultStory,
-  decorators: [withTheme, withLayout({ container: 'column', classNames: 'is-[30rem]' })],
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'is-[30rem]' })],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

package/src/components/ScrollContainer/ScrollContainer.tsx

@@ -2,7 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useState } from '@preact-signals/safe-react/react';
 import { createContext } from '@radix-ui/react-context';
 import React, {
   type HTMLAttributes,
@@ -13,16 +12,18 @@ import React, {
   useImperativeHandle,
   useMemo,
   useRef,
+  useState,
 } from 'react';
 
 // TODO(burdon): Move these deps to @dxos/dom-util.
 import { addEventListener, combine } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
 import { useForwardedRef } from '@dxos/react-hooks';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
 
 import { type ThemedClassName } from '../../util';
 import { IconButton } from '../Button';
+import { ScrollArea } from '../ScrollArea';
 
 const isBottom = (el: HTMLElement | null) => {
   return !!(el && el.scrollHeight - el.scrollTop === el.clientHeight);
@@ -51,98 +52,101 @@ type RootProps = ThemedClassName<
   PropsWithChildren<{
     pin?: boolean;
     fade?: boolean;
+    behavior?: ScrollBehavior;
   }>
 >;
 
 /**
  * Scroll container that automatically scrolls to the bottom when new content is added.
  */
-const Root = forwardRef<ScrollController, RootProps>(({ children, classNames, pin, fade }, forwardedRef) => {
-  const scrollerRef = useRef<HTMLDivElement>(null);
-  const autoScrollRef = useRef(false);
-  const [overflow, setOverflow] = useState(false);
-  const [pinned, setPinned] = useState(pin);
-
-  const timeoutRef = useRef<NodeJS.Timeout>(undefined);
-  const scrollToBottom = useCallback((behavior: ScrollBehavior = 'instant') => {
-    if (scrollerRef.current) {
-      // Temporarily hide scrollbar to prevent flicker.
-      autoScrollRef.current = true;
-      scrollerRef.current.classList.add('scrollbar-none');
-      scrollerRef.current.scrollTo({
-        top: scrollerRef.current.scrollHeight,
-        behavior,
-      });
-
-      clearTimeout(timeoutRef.current);
-      if (behavior !== 'instant') {
-        timeoutRef.current = setTimeout(() => {
-          scrollerRef.current?.classList.remove('scrollbar-none');
-          autoScrollRef.current = false;
-        }, 500);
+const Root = forwardRef<ScrollController, RootProps>(
+  ({ children, classNames, pin, fade, behavior: behaviorProp = 'smooth' }, forwardedRef) => {
+    const scrollerRef = useRef<HTMLDivElement>(null);
+    const autoScrollRef = useRef(false);
+    const [overflow, setOverflow] = useState(false);
+    const [pinned, setPinned] = useState(pin);
+
+    const timeoutRef = useRef<NodeJS.Timeout>(undefined);
+    const scrollToBottom = useCallback((behavior: ScrollBehavior = behaviorProp) => {
+      if (scrollerRef.current) {
+        // Temporarily hide scrollbar to prevent flicker.
+        autoScrollRef.current = true;
+        scrollerRef.current.classList.add('scrollbar-none');
+        scrollerRef.current.scrollTo({
+          top: scrollerRef.current.scrollHeight,
+          behavior,
+        });
+
+        clearTimeout(timeoutRef.current);
+        if (behavior !== 'instant') {
+          timeoutRef.current = setTimeout(() => {
+            scrollerRef.current?.classList.remove('scrollbar-none');
+            autoScrollRef.current = false;
+          }, 500);
+        }
+        setPinned(true);
       }
-      setPinned(true);
-    }
-  }, []);
-
-  const controller = useMemo(
-    () => ({
-      viewport: scrollerRef.current,
-      scrollToTop: () => {
-        invariant(scrollerRef.current);
-        scrollerRef.current.scrollTo({ top: 0, behavior: 'smooth' });
-        setPinned(false);
-      },
-      scrollToBottom: () => {
-        scrollToBottom('smooth');
-      },
-    }),
-    [scrollToBottom, scrollerRef.current],
-  );
-
-  // Scroll controller imperative ref.
-  useImperativeHandle(forwardedRef, () => controller, [controller]);
-
-  // Listen for scroll events.
-  useEffect(() => {
-    if (!scrollerRef.current) {
-      return;
-    }
-
-    return combine(
-      // Check if user scrolls.
-      addEventListener(scrollerRef.current, 'wheel', () => {
-        setPinned(isBottom(scrollerRef.current));
-      }),
-      // Check if scrolls.
-      addEventListener(scrollerRef.current, 'scroll', () => {
-        setOverflow((scrollerRef.current?.scrollTop ?? 0) > 0);
+    }, []);
+
+    const controller = useMemo(
+      () => ({
+        viewport: scrollerRef.current,
+        scrollToTop: () => {
+          invariant(scrollerRef.current);
+          scrollerRef.current.scrollTo({ top: 0, behavior: 'smooth' });
+          setPinned(false);
+        },
+        scrollToBottom: () => {
+          scrollToBottom('smooth');
+        },
       }),
+      [scrollToBottom, scrollerRef.current],
     );
-  }, []);
 
-  return (
-    <ScrollContainerProvider pinned={pinned} controller={controller} scrollToBottom={scrollToBottom}>
-      <div className='relative grid flex-1 min-bs-0 overflow-hidden'>
-        {fade && (
-          <div
-            role='none'
-            data-visible={overflow}
-            className={mx(
-              // NOTE: Gradients may not be visible with dark reader extensions.
-              'z-10 absolute block-start-0 inset-inline-0 bs-24 is-full',
-              'opacity-0 duration-200 transition-opacity data-[visible="true"]:opacity-100',
-              'bg-gradient-to-b from-[--surface-bg] to-transparent pointer-events-none',
-            )}
-          />
-        )}
-        <div className={mx('flex flex-col min-bs-0 overflow-y-auto scrollbar-thin', classNames)} ref={scrollerRef}>
-          {children}
+    // Scroll controller imperative ref.
+    useImperativeHandle(forwardedRef, () => controller, [controller]);
+
+    // Listen for scroll events.
+    useEffect(() => {
+      if (!scrollerRef.current) {
+        return;
+      }
+
+      return combine(
+        // Check if user scrolls.
+        addEventListener(scrollerRef.current, 'wheel', () => {
+          setPinned(isBottom(scrollerRef.current));
+        }),
+        // Check if scrolls.
+        addEventListener(scrollerRef.current, 'scroll', () => {
+          setOverflow((scrollerRef.current?.scrollTop ?? 0) > 0);
+        }),
+      );
+    }, []);
+
+    return (
+      <ScrollContainerProvider pinned={pinned} controller={controller} scrollToBottom={scrollToBottom}>
+        <div className='relative grid flex-1 min-bs-0 overflow-hidden'>
+          {fade && (
+            <div
+              role='none'
+              data-visible={overflow}
+              className={mx(
+                // NOTE: Gradients may not be visible with dark reader extensions.
+                'z-10 absolute block-start-0 inset-inline-0 bs-24 is-full',
+                'opacity-0 duration-200 transition-opacity data-[visible="true"]:opacity-100',
+                'bg-gradient-to-b from-[--surface-bg] to-transparent pointer-events-none',
+              )}
+            />
+          )}
+          <ScrollArea.Root classNames={mx('min-bs-0', classNames)} ref={scrollerRef} thin>
+            <ScrollArea.Viewport>{children}</ScrollArea.Viewport>
+          </ScrollArea.Root>
         </div>
-      </div>
-    </ScrollContainerProvider>
-  );
-});
+      </ScrollContainerProvider>
+    );
+  },
+);
 
 Root.displayName = 'ScrollContainer.Root';
 
@@ -150,25 +154,26 @@ Root.displayName = 'ScrollContainer.Root';
 // Viewport
 //
 
+const VIEWPORT_NAME = 'ScrollContainer.Viewport';
+
 type ViewportProps = ThemedClassName<PropsWithChildren<Omit<HTMLAttributes<HTMLDivElement>, 'className'>>>;
 
 const Viewport = forwardRef<HTMLDivElement, ViewportProps>(({ classNames, children, ...props }, forwardedRef) => {
   const contentRef = useForwardedRef(forwardedRef);
-  const { pinned, scrollToBottom } = useScrollContainerContext(Viewport.displayName!);
+  const { pinned, scrollToBottom } = useScrollContainerContext(VIEWPORT_NAME);
 
   useEffect(() => {
     if (!pinned || !contentRef.current) {
       return;
     }
 
+    // Scroll instantly otherwise it might move while we're scrolling.
+    scrollToBottom();
+
     // Setup resize observer to detect content changes.
     const resizeObserver = new ResizeObserver(() => scrollToBottom());
-    scrollToBottom('instant');
-
     resizeObserver.observe(contentRef.current);
-    return () => {
-      resizeObserver.disconnect();
-    };
+    return () => resizeObserver.disconnect();
   }, [pinned, scrollToBottom]);
 
   return (
@@ -178,16 +183,18 @@ const Viewport = forwardRef<HTMLDivElement, ViewportProps>(({ classNames, childr
   );
 });
 
-Viewport.displayName = 'ScrollContainer.Viewport';
+Viewport.displayName = VIEWPORT_NAME;
 
 //
 // ScrollDownButton
 //
 
+const SCROLL_DOWN_BUTTON_NAME = 'ScrollContainer.ScrollDownButton';
+
 type ScrollDownButtonProps = ThemedClassName;
 
 const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
-  const { pinned, scrollToBottom } = useScrollContainerContext(ScrollDownButton.displayName!);
+  const { pinned, scrollToBottom } = useScrollContainerContext(SCROLL_DOWN_BUTTON_NAME);
 
   return (
     <div
@@ -210,7 +217,7 @@ const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
   );
 };
 
-ScrollDownButton.displayName = 'ScrollContainer.ScrollDownButton';
+ScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
 
 //
 // ScrollContainer

package/src/components/Select/Select.stories.tsx

@@ -42,9 +42,9 @@ const DefaultStory = ({ items = [] }: StoryProps) => {
 };
 
 const meta = {
-  title: 'ui/react-ui-core/Select',
+  title: 'ui/react-ui-core/components/Select',
   render: DefaultStory,
-  decorators: [withTheme, withLayoutVariants()],
+  decorators: [withTheme(), withLayoutVariants()],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

package/src/components/Skeleton/Skeleton.stories.tsx

@@ -0,0 +1,52 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React from 'react';
+
+import { withTheme } from '../../testing';
+
+import { Skeleton } from './Skeleton';
+
+export default {
+  title: 'ui/react-ui-core/components/Skeleton',
+  component: Skeleton,
+  decorators: [withTheme()],
+  parameters: {
+    layout: 'centered',
+  },
+};
+
+export const Default = {
+  render: () => (
+    <div className='flex flex-col gap-4 p-4 border border-separator rounded-sm'>
+      <div className='flex is-fit items-center gap-4'>
+        <Skeleton classNames='size-10 shrink-0 rounded-full' />
+        <div className='grid gap-2'>
+          <Skeleton classNames='bs-4 is-[150px]' />
+          <Skeleton classNames='bs-4 is-[100px]' />
+        </div>
+      </div>
+    </div>
+  ),
+};
+
+export const Card = {
+  render: () => (
+    <div className='flex flex-col gap-3 is-96 p-4 border border-separator rounded-sm'>
+      <div className='flex items-center gap-3'>
+        <Skeleton variant='circle' classNames='bs-12 is-12 rounded-full' />
+        <div className='flex flex-col gap-2 flex-1'>
+          <Skeleton classNames='bs-4 is-24' />
+          <Skeleton classNames='bs-3 is-32' />
+        </div>
+      </div>
+      <Skeleton classNames='bs-32 is-full rounded' />
+      <div className='flex flex-col gap-2'>
+        <Skeleton classNames='bs-3 is-full' />
+        <Skeleton classNames='bs-3 is-5/6' />
+        <Skeleton classNames='bs-3 is-4/6' />
+      </div>
+    </div>
+  ),
+};

package/src/components/Skeleton/Skeleton.tsx

@@ -0,0 +1,26 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { type ComponentPropsWithRef, forwardRef } from 'react';
+
+import { useThemeContext } from '../../hooks';
+import { type ThemedClassName } from '../../util';
+
+type SkeletonProps = ThemedClassName<ComponentPropsWithRef<'div'>> & {
+  variant?: 'default' | 'circle' | 'text';
+};
+
+/**
+ * A skeleton loading component that displays a placeholder while content is loading.
+ */
+const Skeleton = forwardRef<HTMLDivElement, SkeletonProps>(
+  ({ classNames, variant = 'default', ...props }, forwardedRef) => {
+    const { tx } = useThemeContext();
+    return <div {...props} className={tx('skeleton.root', 'skeleton', { variant }, classNames)} ref={forwardedRef} />;
+  },
+);
+
+export { Skeleton };
+
+export type { SkeletonProps };

package/src/components/Skeleton/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './Skeleton';

package/src/components/Splitter/Splitter.stories.tsx

@@ -0,0 +1,73 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useState } from 'react';
+
+import { Layout } from '../../primitives';
+import { withLayout, withTheme } from '../../testing';
+import { ScrollArea } from '../ScrollArea';
+import { Toolbar } from '../Toolbar';
+
+import { Splitter, type SplitterRootProps } from './Splitter';
+
+const Panel = ({ label }: { label: string }) => {
+  return (
+    <Layout.Main toolbar>
+      <Toolbar.Root>{label}</Toolbar.Root>
+      <ScrollArea.Root orientation='vertical'>
+        <ScrollArea.Viewport>
+          {Array.from({ length: 100 }).map((_, i) => (
+            <div key={i} className='p-1'>
+              {label}-{i}
+            </div>
+          ))}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    </Layout.Main>
+  );
+};
+
+const DefaultStory = (props: SplitterRootProps) => {
+  const [mode, setMode] = useState(props.mode ?? 'both');
+
+  return (
+    <div className='grid grid-rows-[min-content_1fr] bs-full overflow-hidden'>
+      <Toolbar.Root>
+        <Toolbar.Button onClick={() => setMode('upper')}>A</Toolbar.Button>
+        <Toolbar.Button onClick={() => setMode('both')}>A + B</Toolbar.Button>
+        <Toolbar.Button onClick={() => setMode('lower')}>B</Toolbar.Button>
+      </Toolbar.Root>
+      <Splitter.Root mode={mode} ratio={props.ratio} classNames='divide-y divide-subduedSeparator'>
+        <Splitter.Panel position='upper'>
+          <Panel label='A' />
+        </Splitter.Panel>
+        <Splitter.Panel position='lower'>
+          <Panel label='B' />
+        </Splitter.Panel>
+      </Splitter.Root>
+    </div>
+  );
+};
+
+const meta: Meta<SplitterRootProps> = {
+  title: 'ui/react-ui-core/components/Splitter',
+  component: Splitter.Root,
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    layout: 'fullscreen',
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<SplitterRootProps>;
+
+export const Default: Story = {
+  args: {
+    mode: 'both',
+    ratio: 0.5,
+  },
+};

package/src/components/Splitter/Splitter.tsx

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { createContextScope } from '@radix-ui/react-context';
+import React, { type ComponentPropsWithoutRef, forwardRef } from 'react';
+
+import { mx } from '@dxos/ui-theme';
+
+import { type ThemedClassName } from '../../util';
+
+type ScopedProps<P> = P & { __scopeSplitter?: any };
+
+// TODO(burdon): Generalize styles.
+// TODO(burdon): Enalbe resize.
+// TODO(burdon): Generalize horizontal/vertical and change to start/end.
+type Mode = 'upper' | 'lower' | 'both';
+
+type SplitterContextValue = {
+  mode: Mode;
+  ratio: number;
+  transition: number;
+};
+
+const SPLITTER_NAME = 'Splitter';
+
+const [createSplitterContext, createSplitterScope] = createContextScope(SPLITTER_NAME);
+
+const [SplitterProvider, useSplitterContext] = createSplitterContext<SplitterContextValue>(SPLITTER_NAME);
+
+//
+// Root
+//
+
+const ROOT_NAME = 'Splitter.Root';
+
+type RootProps = ThemedClassName<ComponentPropsWithoutRef<'div'>> & Partial<SplitterContextValue>;
+
+const Root = forwardRef<HTMLDivElement, ScopedProps<RootProps>>(
+  (
+    { __scopeSplitter, classNames, mode = 'upper', ratio = 0.5, transition = 250, children, ...rootProps },
+    forwardedRef,
+  ) => {
+    return (
+      <SplitterProvider scope={__scopeSplitter} mode={mode} ratio={ratio} transition={transition}>
+        <div
+          role='none'
+          {...rootProps}
+          ref={forwardedRef}
+          className={mx('relative bs-full overflow-hidden', classNames)}
+        >
+          {children}
+        </div>
+      </SplitterProvider>
+    );
+  },
+);
+
+Root.displayName = ROOT_NAME;
+
+//
+// Panel
+//
+
+const PANEL_NAME = 'Splitter.Panel';
+
+interface PanelProps extends ThemedClassName<ComponentPropsWithoutRef<'div'>> {
+  position: 'upper' | 'lower';
+}
+
+const Panel = forwardRef<HTMLDivElement, ScopedProps<PanelProps>>(
+  ({ __scopeSplitter, classNames, children, position, style, ...panelProps }, forwardedRef) => {
+    const context = useSplitterContext(PANEL_NAME, __scopeSplitter);
+    const { mode, ratio, transition } = context;
+
+    // Calculate position and height based on mode and ratio.
+    const isUpper = position === 'upper';
+    const top = isUpper ? '0%' : mode === 'upper' ? '100%' : mode === 'lower' ? '0%' : `${ratio * 100}%`;
+
+    const height = isUpper
+      ? mode === 'upper'
+        ? '100%'
+        : mode === 'lower'
+          ? '0%'
+          : `${ratio * 100}%`
+      : mode === 'lower'
+        ? '100%'
+        : mode === 'upper'
+          ? '0%'
+          : `${(1 - ratio) * 100}%`;
+
+    return (
+      <div
+        {...panelProps}
+        ref={forwardedRef}
+        className={mx('absolute inset-inline-0 flex flex-col overflow-hidden', classNames)}
+        style={{
+          top,
+          height,
+          transition: `top ${transition}ms, height ${transition}ms ease-out`,
+          ...style,
+        }}
+      >
+        {children}
+      </div>
+    );
+  },
+);
+
+Panel.displayName = PANEL_NAME;
+
+//
+// Splitter
+//
+
+const Splitter = {
+  Root,
+  Panel,
+};
+
+export { Splitter, createSplitterScope };
+
+export type { Mode as SplitterMode, RootProps as SplitterRootProps, PanelProps as SplitterPanelProps };

package/src/components/Splitter/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './Splitter';

package/src/components/Status/Status.stories.tsx

@@ -10,9 +10,9 @@ import { withTheme } from '../../testing';
 import { Status } from './Status';
 
 const meta = {
-  title: 'ui/react-ui-core/Status',
+  title: 'ui/react-ui-core/components/Status',
   component: Status,
-  decorators: [withTheme],
+  decorators: [withTheme()],
 } satisfies Meta<typeof Status>;
 
 export default meta;

package/src/components/Tag/Tag.stories.tsx

@@ -5,8 +5,8 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { hues } from '@dxos/react-ui-theme';
-import { type ChromaticPalette, type MessageValence } from '@dxos/react-ui-types';
+import { hues } from '@dxos/ui-theme';
+import { type ChromaticPalette, type MessageValence } from '@dxos/ui-types';
 
 import { withTheme } from '../../testing';
 
@@ -15,7 +15,7 @@ import { Tag } from './Tag';
 const palettes = ['neutral', 'success', 'info', 'warning', 'error', ...hues] as (ChromaticPalette | MessageValence)[];
 
 const meta = {
-  title: 'ui/react-ui-core/Tag',
+  title: 'ui/react-ui-core/components/Tag',
   component: Tag,
   render: () => (
     <div role='grid' className='grid grid-cols-5 gap-2 max-is-screen-md'>
@@ -26,7 +26,7 @@ const meta = {
       ))}
     </div>
   ),
-  decorators: [withTheme],
+  decorators: [withTheme()],
   parameters: {
     chromatic: {
       disableSnapshot: false,

package/src/components/Tag/Tag.tsx

@@ -6,7 +6,7 @@ import { Primitive } from '@radix-ui/react-primitive';
 import { Slot } from '@radix-ui/react-slot';
 import React, { type ComponentPropsWithRef, forwardRef } from 'react';
 
-import { type ChromaticPalette, type MessageValence, type NeutralPalette } from '@dxos/react-ui-types';
+import { type ChromaticPalette, type MessageValence, type NeutralPalette } from '@dxos/ui-types';
 
 import { useThemeContext } from '../../hooks';
 import { type ThemedClassName } from '../../util';

package/src/components/ThemeProvider/ThemeProvider.tsx

@@ -5,7 +5,7 @@
 import { createKeyborg } from 'keyborg';
 import React, { type PropsWithChildren, createContext, useEffect, useMemo } from 'react';
 
-import { type Density, type Elevation, type ThemeFunction } from '@dxos/react-ui-types';
+import { type Density, type Elevation, type ThemeFunction, type ThemeMode } from '@dxos/ui-types';
 
 import { type SafeAreaPadding, useSafeArea } from '../../hooks';
 import { hasIosKeyboard } from '../../util';
@@ -14,14 +14,13 @@ import { ElevationProvider } from '../ElevationProvider';
 
 import { TranslationsProvider, type TranslationsProviderProps } from './TranslationsProvider';
 
-export type ThemeMode = 'dark' | 'light';
-
 export type ThemeContextValue = {
   tx: ThemeFunction<any>;
   themeMode: ThemeMode;
   hasIosKeyboard: boolean;
   safeAreaPadding?: SafeAreaPadding;
   noCache?: boolean;
+  platform?: 'mobile' | 'desktop';
 };
 
 /**