@dxos/react-ui 0.8.4-main.c1de068 → 0.8.4-main.c351d160a8

package/src/components/ScrollContainer/ScrollContainer.tsx

@@ -0,0 +1,238 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createContext } from '@radix-ui/react-context';
+import React, {
+  type HTMLAttributes,
+  type PropsWithChildren,
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { addEventListener, combine } from '@dxos/async';
+import { invariant } from '@dxos/invariant';
+import { useForwardedRef } from '@dxos/react-hooks';
+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);
+};
+
+export interface ScrollController {
+  viewport: HTMLDivElement | null;
+  scrollToTop: (behavior?: ScrollBehavior) => void;
+  scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+
+type ScrollContainerContextValue = {
+  scrollToBottom: (behavior?: ScrollBehavior) => void;
+  controller?: ScrollController;
+  pinned?: boolean;
+};
+
+const [ScrollContainerProvider, useScrollContainerContext] =
+  createContext<ScrollContainerContextValue>('ScrollContainer');
+
+//
+// Root
+//
+
+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, 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 flickering.
+        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);
+      }
+    }, []);
+
+    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);
+        }),
+      );
+    }, []);
+
+    return (
+      <ScrollContainerProvider pinned={pinned} controller={controller} scrollToBottom={scrollToBottom}>
+        <div className='relative grid dx-container overflow-hidden'>
+          {fade && (
+            <div
+              role='none'
+              data-visible={overflow}
+              className={mx(
+                // NOTE: Gradients may not be visible with dark reader extensions.
+                'z-10 absolute top-0 inset-x-0 h-24 w-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-h-0', classNames)} thin>
+            <ScrollArea.Viewport ref={scrollerRef}>{children}</ScrollArea.Viewport>
+          </ScrollArea.Root>
+        </div>
+      </ScrollContainerProvider>
+    );
+  },
+);
+
+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_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());
+    resizeObserver.observe(contentRef.current);
+    return () => resizeObserver.disconnect();
+  }, [pinned, scrollToBottom]);
+
+  return (
+    <div className={mx('w-full', classNames)} {...props} ref={contentRef}>
+      {children}
+    </div>
+  );
+});
+
+Viewport.displayName = VIEWPORT_NAME;
+
+//
+// ScrollDownButton
+//
+
+const SCROLL_DOWN_BUTTON_NAME = 'ScrollContainer.ScrollDownButton';
+
+type ScrollDownButtonProps = ThemedClassName;
+
+const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
+  const { pinned, scrollToBottom } = useScrollContainerContext(SCROLL_DOWN_BUTTON_NAME);
+
+  return (
+    <div
+      role='none'
+      className={mx(
+        'absolute bottom-2 right-4 opacity-100 transition-opacity duration-300',
+        pinned && 'opacity-0',
+        classNames,
+      )}
+    >
+      <IconButton
+        variant='primary'
+        icon='ph--arrow-down--regular'
+        iconOnly
+        size={4}
+        label='Scroll down'
+        onClick={() => scrollToBottom()}
+      />
+    </div>
+  );
+};
+
+ScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
+
+//
+// ScrollContainer
+//
+
+export { useScrollContainerContext };
+
+export const ScrollContainer = {
+  Root,
+  Viewport,
+  ScrollDownButton,
+};
+
+export type {
+  RootProps as ScrollContainerRootProps,
+  ViewportProps as ScrollContainerViewportProps,
+  ScrollDownButtonProps as ScrollContainerScrollDownButtonProps,
+};

package/src/components/ScrollContainer/index.ts

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

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

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { type StoryObj } from '@storybook/react-vite';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
 
 import { faker } from '@dxos/random';
 
+import { withTheme } from '../../testing';
+import { withLayoutVariants } from '../../testing';
+
 import { Select } from './Select';
-import { withSurfaceVariantsLayout, withTheme } from '../../testing';
 
 faker.seed(1234);
 
@@ -41,15 +41,18 @@ const DefaultStory = ({ items = [] }: StoryProps) => {
   );
 };
 
-export const Default: StoryObj<StoryProps> = {
+const meta = {
+  title: 'ui/react-ui-core/components/Select',
+  render: DefaultStory,
+  decorators: [withTheme(), withLayoutVariants()],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
   args: {
     items: Array.from({ length: 16 }).map((_, i) => ({ id: `item-${i}`, text: faker.lorem.word() })),
   },
 };
-
-export default {
-  title: 'ui/react-ui-core/Select',
-  render: DefaultStory,
-  decorators: [withSurfaceVariantsLayout(), withTheme],
-  parameters: { chromatic: { disableSnapshot: false } },
-};

package/src/components/Select/Select.tsx

@@ -8,7 +8,7 @@ import React, { forwardRef } from 'react';
 import { useElevationContext, useThemeContext } from '../../hooks';
 import { useSafeCollisionPadding } from '../../hooks/useSafeCollisionPadding';
 import { type ThemedClassName } from '../../util';
-import { Button, type ButtonProps } from '../Buttons';
+import { Button, type ButtonProps } from '../Button';
 import { Icon } from '../Icon';
 
 type SelectRootProps = SelectPrimitive.SelectProps;
@@ -35,14 +35,13 @@ type SelectTriggerButtonProps = Omit<ButtonProps, 'children'> & Pick<SelectValue
 
 const SelectTriggerButton = forwardRef<HTMLButtonElement, SelectTriggerButtonProps>(
   ({ children, placeholder, ...props }, forwardedRef) => {
-    const { tx } = useThemeContext();
     return (
       <SelectPrimitive.Trigger asChild ref={forwardedRef}>
         <Button {...props}>
           <SelectPrimitive.Value placeholder={placeholder}>{children}</SelectPrimitive.Value>
           <span className='w-1 flex-1' />
           <SelectPrimitive.Icon asChild>
-            <Icon icon='ph--caret-down--bold' classNames={tx('select.triggerIcon', 'select__trigger__icon', {})} />
+            <Icon size={3} icon='ph--caret-down--bold' />
           </SelectPrimitive.Icon>
         </Button>
       </SelectPrimitive.Trigger>
@@ -60,8 +59,9 @@ const SelectContent = forwardRef<HTMLDivElement, SelectContentProps>(
     return (
       <SelectPrimitive.Content
         {...props}
+        data-arrow-keys='up down'
         collisionPadding={safeCollisionPadding}
-        className={tx('select.content', 'select__content', { elevation }, classNames)}
+        className={tx('select.content', { elevation }, classNames)}
         position='popper'
         ref={forwardedRef}
       >
@@ -79,10 +79,10 @@ const SelectScrollUpButton = forwardRef<HTMLDivElement, SelectScrollUpButtonProp
     return (
       <SelectPrimitive.SelectScrollUpButton
         {...props}
-        className={tx('select.scrollButton', 'select__scroll-button--up', {}, classNames)}
+        className={tx('select.scrollButton', {}, classNames)}
         ref={forwardedRef}
       >
-        {children ?? <Icon icon='ph--caret-up--bold' />}
+        {children ?? <Icon size={3} icon='ph--caret-up--bold' />}
       </SelectPrimitive.SelectScrollUpButton>
     );
   },
@@ -96,10 +96,10 @@ const SelectScrollDownButton = forwardRef<HTMLDivElement, SelectScrollDownButton
     return (
       <SelectPrimitive.SelectScrollDownButton
         {...props}
-        className={tx('select.scrollButton', 'select__scroll-button--down', {}, classNames)}
+        className={tx('select.scrollButton', {}, classNames)}
         ref={forwardedRef}
       >
-        {children ?? <Icon icon='ph--caret-down--bold' />}
+        {children ?? <Icon size={3} icon='ph--caret-down--bold' />}
       </SelectPrimitive.SelectScrollDownButton>
     );
   },
@@ -108,14 +108,10 @@ const SelectScrollDownButton = forwardRef<HTMLDivElement, SelectScrollDownButton
 type SelectViewportProps = ThemedClassName<SelectPrimitive.SelectViewportProps>;
 
 const SelectViewport = forwardRef<HTMLDivElement, SelectViewportProps>(
-  ({ classNames, asChild, children, ...props }, forwardedRef) => {
+  ({ classNames, children, ...props }, forwardedRef) => {
     const { tx } = useThemeContext();
     return (
-      <SelectPrimitive.SelectViewport
-        {...props}
-        className={tx('select.viewport', 'select__viewport', {}, classNames)}
-        ref={forwardedRef}
-      >
+      <SelectPrimitive.SelectViewport {...props} className={tx('select.viewport', {}, classNames)} ref={forwardedRef}>
         {children}
       </SelectPrimitive.SelectViewport>
     );
@@ -126,7 +122,7 @@ type SelectItemProps = ThemedClassName<SelectPrimitive.SelectItemProps>;
 
 const SelectItem = forwardRef<HTMLDivElement, SelectItemProps>(({ classNames, ...props }, forwardedRef) => {
   const { tx } = useThemeContext();
-  return <SelectPrimitive.Item {...props} className={tx('select.item', 'option', {}, classNames)} ref={forwardedRef} />;
+  return <SelectPrimitive.Item {...props} className={tx('select.item', {}, classNames)} ref={forwardedRef} />;
 });
 
 type SelectItemTextProps = SelectPrimitive.SelectItemTextProps;
@@ -141,7 +137,7 @@ const SelectItemIndicator = forwardRef<HTMLDivElement, SelectItemIndicatorProps>
     return (
       <SelectPrimitive.ItemIndicator
         {...props}
-        className={tx('select.itemIndicator', 'option__indicator', {}, classNames)}
+        className={tx('select.itemIndicator', {}, classNames)}
         ref={forwardedRef}
       >
         {children}
@@ -152,10 +148,11 @@ const SelectItemIndicator = forwardRef<HTMLDivElement, SelectItemIndicatorProps>
 
 type SelectOptionProps = SelectItemProps;
 
+// TODO(burdon): Option to show icon on left/right.
 const SelectOption = forwardRef<HTMLDivElement, SelectItemProps>(({ children, classNames, ...props }, forwardedRef) => {
   const { tx } = useThemeContext();
   return (
-    <SelectPrimitive.Item {...props} className={tx('select.item', 'option', {}, classNames)} ref={forwardedRef}>
+    <SelectPrimitive.Item {...props} className={tx('select.item', {}, classNames)} ref={forwardedRef}>
       <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
       <span className='grow w-1' />
       {/* <SelectPrimitive.ItemIndicator className={tx('select.itemIndicator', 'option__indicator', {})}> */}
@@ -177,26 +174,14 @@ type SelectSeparatorProps = ThemedClassName<SelectPrimitive.SelectSeparatorProps
 
 const SelectSeparator = forwardRef<HTMLDivElement, SelectSeparatorProps>(({ classNames, ...props }, forwardedRef) => {
   const { tx } = useThemeContext();
-  return (
-    <SelectPrimitive.Separator
-      {...props}
-      className={tx('select.separator', 'select__separator', {}, classNames)}
-      ref={forwardedRef}
-    />
-  );
+  return <SelectPrimitive.Separator {...props} className={tx('select.separator', {}, classNames)} ref={forwardedRef} />;
 });
 
 type SelectArrowProps = ThemedClassName<SelectPrimitive.SelectArrowProps>;
 
 const SelectArrow = forwardRef<SVGSVGElement, SelectArrowProps>(({ classNames, ...props }, forwardedRef) => {
   const { tx } = useThemeContext();
-  return (
-    <SelectPrimitive.Arrow
-      {...props}
-      className={tx('select.arrow', 'select__arrow', {}, classNames)}
-      ref={forwardedRef}
-    />
-  );
+  return <SelectPrimitive.Arrow {...props} className={tx('select.arrow', {}, classNames)} ref={forwardedRef} />;
 });
 
 export const Select = {

package/src/components/Separator/Separator.tsx

@@ -1,25 +1,22 @@
 //
 // Copyright 2023 DXOS.org
 //
-import {
-  Separator as SeparatorPrimitive,
-  type SeparatorProps as SeparatorPrimitiveProps,
-} from '@radix-ui/react-separator';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
 import React, { forwardRef } from 'react';
 
 import { useThemeContext } from '../../hooks';
 import { type ThemedClassName } from '../../util';
 
-type SeparatorProps = ThemedClassName<SeparatorPrimitiveProps> & { subdued?: boolean };
+type SeparatorProps = ThemedClassName<SeparatorPrimitive.SeparatorProps> & { subdued?: boolean };
 
 const Separator = forwardRef<HTMLDivElement, SeparatorProps>(
   ({ classNames, orientation = 'horizontal', subdued, ...props }, forwardedRef) => {
     const { tx } = useThemeContext();
     return (
-      <SeparatorPrimitive
-        orientation={orientation}
+      <SeparatorPrimitive.Root
         {...props}
-        className={tx('separator.root', 'separator', { orientation, subdued }, classNames)}
+        orientation={orientation}
+        className={tx('separator.root', { orientation, subdued }, classNames)}
         ref={forwardedRef}
       />
     );

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-xs'>
+      <div className='flex w-fit items-center gap-4'>
+        <Skeleton classNames='size-10 shrink-0 rounded-full' />
+        <div className='grid gap-2'>
+          <Skeleton classNames='h-4 w-[150px]' />
+          <Skeleton classNames='h-4 w-[100px]' />
+        </div>
+      </div>
+    </div>
+  ),
+};
+
+export const Card = {
+  render: () => (
+    <div className='flex flex-col gap-3 w-96 p-4 border border-separator rounded-xs'>
+      <div className='flex items-center gap-3'>
+        <Skeleton variant='circle' classNames='h-12 w-12 rounded-full' />
+        <div className='flex flex-col gap-2 flex-1'>
+          <Skeleton classNames='h-4 w-24' />
+          <Skeleton classNames='h-3 w-32' />
+        </div>
+      </div>
+      <Skeleton classNames='h-32 w-full rounded-sm' />
+      <div className='flex flex-col gap-2'>
+        <Skeleton classNames='h-3 w-full' />
+        <Skeleton classNames='h-3 w-5/6' />
+        <Skeleton classNames='h-3 w-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', { 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,83 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { type ComponentPropsWithoutRef, forwardRef, useState } from 'react';
+
+import { Panel } from '../../primitives';
+import { withLayout, withTheme } from '../../testing';
+import { ScrollArea } from '../ScrollArea';
+import { Toolbar } from '../Toolbar';
+
+import { Splitter, type SplitterRootProps } from './Splitter';
+
+const PanelContent = forwardRef<HTMLDivElement, ComponentPropsWithoutRef<'div'> & { label: string }>(
+  ({ label, ...props }, ref) => (
+    <div ref={ref} {...props}>
+      <Panel.Root>
+        <Panel.Toolbar asChild>
+          <Toolbar.Root>{label}</Toolbar.Root>
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <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>
+        </Panel.Content>
+      </Panel.Root>
+    </div>
+  ),
+);
+
+const DefaultStory = (props: SplitterRootProps) => {
+  const [mode, setMode] = useState(props.mode ?? 'both');
+
+  return (
+    <Panel.Root>
+      <Panel.Toolbar asChild>
+        <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>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <Splitter.Root mode={mode} ratio={props.ratio}>
+          <Splitter.Panel asChild position='upper'>
+            <PanelContent label='A' />
+          </Splitter.Panel>
+          <Splitter.Panel asChild position='lower'>
+            <PanelContent label='B' />
+          </Splitter.Panel>
+        </Splitter.Root>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+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,
+  },
+};