@dxos/react-ui 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

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

@@ -5,56 +5,69 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useEffect, useRef, useState } from 'react';
 
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 
 import { withLayout, withTheme } from '../../testing';
 import { Button } from '../Button';
+import { Panel } from '../Panel';
 import { Toolbar } from '../Toolbar';
-
 import { ScrollContainer, type ScrollContainerRootProps, type ScrollController } from './ScrollContainer';
 
-const DefaultStory = (props: ScrollContainerRootProps) => {
+type DefaultStoryProps = ScrollContainerRootProps & { running?: boolean; initialLines?: number };
+
+const DefaultStory = ({ initialLines = 0, running: runningProp, ...props }: DefaultStoryProps) => {
   const [lines, setLines] = useState<string[]>([]);
-  const [running, setRunning] = useState(true);
+  const [running, setRunning] = useState(runningProp);
   const scroller = useRef<ScrollController>(null);
+  useEffect(() => {
+    setLines(Array.from({ length: initialLines }, () => random.lorem.paragraph()));
+  }, [initialLines]);
   useEffect(() => {
     if (!running) {
       return;
     }
 
     const i = setInterval(() => {
-      setLines((lines) => [...lines, faker.lorem.paragraph()]);
+      setLines((lines) => [...lines, random.lorem.paragraph()]);
     }, 500);
 
     return () => clearInterval(i);
   }, [running]);
 
   return (
-    <div className='flex flex-col bs-full overflow-hidden'>
-      <Toolbar.Root>
-        <Button onClick={() => setRunning((running) => !running)}>{running ? 'Stop' : 'Start'}</Button>
-        <Button onClick={() => scroller.current?.scrollToBottom()}>Scroll to bottom</Button>
-        <div className='flex-1' />
-        <div>{lines.length}</div>
-      </Toolbar.Root>
-      <ScrollContainer.Root {...props} ref={scroller}>
-        <ScrollContainer.Viewport>
-          {lines.map((line, index) => (
-            <div key={index} className='p-2'>
-              {line}
-            </div>
-          ))}
-        </ScrollContainer.Viewport>
-      </ScrollContainer.Root>
-    </div>
+    <Panel.Root className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Button onClick={() => setRunning((running) => !running)}>{running ? 'Stop' : 'Start'}</Button>
+          <Button onClick={() => scroller.current?.scrollToBottom()}>Scroll to bottom</Button>
+          <Toolbar.Separator />
+          <div className='px-1'>{lines.length}</div>
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content>
+        <ScrollContainer.Root {...props} ref={scroller}>
+          <ScrollContainer.Content>
+            <ScrollContainer.Viewport>
+              {lines.map((line, index) => (
+                <div key={index} className='p-2 text-description'>
+                  {line}
+                </div>
+              ))}
+            </ScrollContainer.Viewport>
+            <ScrollContainer.ScrollDownButton />
+            <ScrollContainer.Fade />
+          </ScrollContainer.Content>
+        </ScrollContainer.Root>
+      </Panel.Content>
+    </Panel.Root>
   );
 };
 
 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: 'w-[30rem]' })],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;
@@ -64,6 +77,15 @@ type Story = StoryObj<typeof meta>;
 export const Default: Story = {
   args: {
     pin: true,
-    fade: true,
+
+    running: true,
+  },
+};
+
+export const Large: Story = {
+  args: {
+    pin: true,
+
+    initialLines: 100,
   },
 };

package/src/components/ScrollContainer/ScrollContainer.tsx

@@ -2,27 +2,29 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useState } from '@preact-signals/safe-react/react';
 import { createContext } from '@radix-ui/react-context';
 import React, {
-  type HTMLAttributes,
   type PropsWithChildren,
+  type RefObject,
   forwardRef,
   useCallback,
   useEffect,
   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 { useMergeRefs } from '@dxos/react-hooks';
+import { mx } from '@dxos/ui-theme';
+import { type SlottableProps } from '@dxos/ui-types';
 
+import { composable, composableProps, slottable } from '../../util';
 import { type ThemedClassName } from '../../util';
 import { IconButton } from '../Button';
+import { ScrollArea, type ScrollAreaRootProps } from '../ScrollArea';
 
 const isBottom = (el: HTMLElement | null) => {
   return !!(el && el.scrollHeight - el.scrollTop === el.clientHeight);
@@ -35,9 +37,15 @@ export interface ScrollController {
 }
 
 type ScrollContainerContextValue = {
-  scrollToBottom: (behavior?: ScrollBehavior) => void;
   controller?: ScrollController;
   pinned?: boolean;
+  overflow?: boolean;
+  /** Called by Viewport to register/unregister the scroll element. */
+  setViewport: (el: HTMLDivElement | null) => void;
+  /** Called by Viewport on wheel events to update pinned state. */
+  setPinned: (value: boolean) => void;
+  /** Called by Viewport on scroll events to update overflow state. */
+  setOverflow: (value: boolean) => void;
 };
 
 const [ScrollContainerProvider, useScrollContainerContext] =
@@ -47,151 +55,255 @@ const [ScrollContainerProvider, useScrollContainerContext] =
 // Root
 //
 
-type RootProps = ThemedClassName<
-  PropsWithChildren<{
-    pin?: boolean;
-    fade?: boolean;
-  }>
->;
+type ScrollContainerRootProps = PropsWithChildren<{
+  pin?: boolean;
+  behavior?: ScrollBehavior;
+}>;
 
 /**
- * Scroll container that automatically scrolls to the bottom when new content is added.
+ * Headless scroll container that provides context for scroll state.
+ * Render ScrollContainer.Content and ScrollContainer.Viewport as children.
  */
-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);
-      }
-      setPinned(true);
-    }
-  }, []);
-
-  const controller = useMemo(
-    () => ({
-      viewport: scrollerRef.current,
-      scrollToTop: () => {
-        invariant(scrollerRef.current);
-        scrollerRef.current.scrollTo({ top: 0, behavior: 'smooth' });
-        setPinned(false);
-      },
-      scrollToBottom: () => {
-        scrollToBottom('smooth');
+const ScrollContainerRoot = forwardRef<ScrollController, ScrollContainerRootProps>(
+  ({ children, pin, behavior: behaviorProp = 'smooth' }, forwardedRef) => {
+    const scrollerRef = useRef<HTMLDivElement | null>(null);
+    const autoScrollRef = useRef(false);
+    const [pinned, setPinned] = useState(pin);
+    const [overflow, setOverflow] = useState(false);
+
+    const timeoutRef = useRef<NodeJS.Timeout>(undefined);
+    const scrollToBottom = useCallback(
+      (behavior: ScrollBehavior = behaviorProp) => {
+        if (scrollerRef.current) {
+          if (behavior !== 'instant') {
+            // Temporarily hide scrollbar to prevent flickering during smooth scroll.
+            // For instant scrolling we skip this — there's no animation to hide,
+            // and adding the class changes element size which re-fires the ResizeObserver.
+            autoScrollRef.current = true;
+            scrollerRef.current.classList.add('scrollbar-none');
+            clearTimeout(timeoutRef.current);
+            timeoutRef.current = setTimeout(() => {
+              scrollerRef.current?.classList.remove('scrollbar-none');
+              autoScrollRef.current = false;
+            }, 500);
+          }
+
+          scrollerRef.current.scrollTo({
+            top: scrollerRef.current.scrollHeight,
+            behavior,
+          });
+
+          setPinned(true);
+        }
       },
-    }),
-    [scrollToBottom, scrollerRef.current],
-  );
-
-  // Scroll controller imperative ref.
-  useImperativeHandle(forwardedRef, () => controller, [controller]);
-
-  // Listen for scroll events.
-  useEffect(() => {
-    if (!scrollerRef.current) {
-      return;
-    }
+      [behaviorProp],
+    );
 
-    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<ScrollController>(
+      () => ({
+        get viewport() {
+          return scrollerRef.current;
+        },
+        scrollToTop: () => {
+          invariant(scrollerRef.current);
+          scrollerRef.current.scrollTo({ top: 0, behavior: 'smooth' });
+          setPinned(false);
+        },
+        scrollToBottom: (behavior = 'smooth' as ScrollBehavior) => {
+          scrollToBottom(behavior);
+        },
       }),
+      [scrollToBottom],
     );
-  }, []);
 
-  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}
-        </div>
-      </div>
-    </ScrollContainerProvider>
-  );
-});
+    // Scroll controller imperative ref.
+    useImperativeHandle(forwardedRef, () => controller, [controller]);
+
+    // Called by Viewport when the scroll element mounts/unmounts.
+    const setViewport = useCallback((el: HTMLDivElement | null) => {
+      scrollerRef.current = el;
+    }, []);
+
+    return (
+      <ScrollContainerProvider
+        pinned={pinned}
+        overflow={overflow}
+        controller={controller}
+        setViewport={setViewport}
+        setPinned={setPinned}
+        setOverflow={setOverflow}
+      >
+        {children}
+      </ScrollContainerProvider>
+    );
+  },
+);
+
+ScrollContainerRoot.displayName = 'ScrollContainer.Root';
+
+//
+// Content
+//
 
-Root.displayName = 'ScrollContainer.Root';
+type ScrollContainerContentProps = Pick<ScrollAreaRootProps, 'thin' | 'padding' | 'centered'>;
+
+/**
+ * Composable wrapper around ScrollArea.Root.
+ * Provides the DOM structure for the scroll container.
+ */
+const ScrollContainerContent = composable<HTMLDivElement, ScrollContainerContentProps>(
+  ({ children, thin, padding, centered, ...props }, forwardedRef) => {
+    return (
+      <ScrollArea.Root
+        {...composableProps(props, { classNames: 'relative isolate' })}
+        thin={thin}
+        padding={padding}
+        centered={centered}
+        ref={forwardedRef}
+      >
+        {children}
+      </ScrollArea.Root>
+    );
+  },
+);
+
+ScrollContainerContent.displayName = 'ScrollContainer.Content';
 
 //
 // Viewport
 //
 
-type ViewportProps = ThemedClassName<PropsWithChildren<Omit<HTMLAttributes<HTMLDivElement>, 'className'>>>;
+const VIEWPORT_NAME = 'ScrollContainer.Viewport';
+
+type ScrollContainerViewportProps = SlottableProps;
+
+const ScrollContainerViewport = slottable<HTMLDivElement, ScrollContainerViewportProps>(
+  ({ children, asChild, ...props }, forwardedRef) => {
+    const scrollerRef = useRef<HTMLDivElement>(null);
+    const mergedRef = useMergeRefs([forwardedRef, scrollerRef]);
+    const { setViewport, setPinned, setOverflow } = useScrollContainerContext(VIEWPORT_NAME);
 
-const Viewport = forwardRef<HTMLDivElement, ViewportProps>(({ classNames, children, ...props }, forwardedRef) => {
-  const contentRef = useForwardedRef(forwardedRef);
-  const { pinned, scrollToBottom } = useScrollContainerContext(Viewport.displayName!);
+    // Register the scroll element with Root and set up wheel/scroll listeners.
+    useEffect(() => {
+      const el = scrollerRef.current;
+      if (!el) {
+        return;
+      }
+
+      setViewport(el);
+
+      return combine(
+        addEventListener(el, 'wheel', () => setPinned(isBottom(el))),
+        addEventListener(el, 'scroll', () => setOverflow((el.scrollTop ?? 0) > 0)),
+        () => setViewport(null),
+      );
+    }, [setViewport, setPinned, setOverflow]);
+
+    return (
+      <>
+        <ScrollArea.Viewport asChild={asChild} {...composableProps(props)} ref={mergedRef}>
+          {children}
+        </ScrollArea.Viewport>
+        <ScrollContainerPinEffect scrollerRef={scrollerRef} />
+      </>
+    );
+  },
+);
 
+ScrollContainerViewport.displayName = VIEWPORT_NAME;
+
+/**
+ * Isolated component that consumes pinned/controller from context.
+ * Kept separate so that Viewport does not re-render when pinned changes.
+ */
+const PIN_EFFECT_NAME = 'ScrollContainer.PinEffect';
+
+const ScrollContainerPinEffect = ({ scrollerRef }: { scrollerRef: RefObject<HTMLDivElement | null> }) => {
+  const { pinned, controller } = useScrollContainerContext(PIN_EFFECT_NAME);
+
+  // Pin scroll to bottom when content changes.
   useEffect(() => {
-    if (!pinned || !contentRef.current) {
+    const viewport = scrollerRef.current;
+    if (!pinned || !viewport) {
       return;
     }
 
-    // Setup resize observer to detect content changes.
-    const resizeObserver = new ResizeObserver(() => scrollToBottom());
-    scrollToBottom('instant');
+    // Scroll instantly so we don't visually jump while content is being added.
+    controller?.scrollToBottom('instant');
+
+    // Setup resize observer on content children to detect size changes (e.g. streaming).
+    // We observe children rather than the viewport itself, because the viewport's size
+    // stays fixed — only its content grows.
+    // Use instant scroll in the callback — smooth scrolling adds/removes the
+    // scrollbar-none class, which changes the element size and re-fires the
+    // observer, creating an infinite loop.
+    const resizeObserver = new ResizeObserver(() => controller?.scrollToBottom('smooth'));
+    Array.from(viewport.children).forEach((child) => {
+      resizeObserver.observe(child);
+    });
+
+    // Watch for added/removed children.
+    const mutationObserver = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node instanceof Element) {
+            resizeObserver.observe(node);
+          }
+        });
+      });
+
+      controller?.scrollToBottom('smooth');
+    });
+    mutationObserver.observe(viewport, { childList: true });
 
-    resizeObserver.observe(contentRef.current);
     return () => {
       resizeObserver.disconnect();
+      mutationObserver.disconnect();
     };
-  }, [pinned, scrollToBottom]);
+  }, [pinned, controller, scrollerRef]);
+
+  return null;
+};
+
+//
+// Fade
+//
+
+const FADE_NAME = 'ScrollContainer.Fade';
+
+type ScrollContainerFadeProps = {};
+
+function ScrollContainerFade() {
+  const { overflow } = useScrollContainerContext(FADE_NAME);
 
   return (
-    <div className={mx('is-full', classNames)} {...props} ref={contentRef}>
-      {children}
-    </div>
+    <div
+      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-(--color-base-surface) to-transparent pointer-events-none',
+      )}
+    />
   );
-});
+}
 
-Viewport.displayName = 'ScrollContainer.Viewport';
+ScrollContainerFade.displayName = FADE_NAME;
 
 //
 // ScrollDownButton
 //
 
-type ScrollDownButtonProps = ThemedClassName;
+const SCROLL_DOWN_BUTTON_NAME = 'ScrollContainer.ScrollDownButton';
 
-const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
-  const { pinned, scrollToBottom } = useScrollContainerContext(ScrollDownButton.displayName!);
+type ScrollContainerScrollDownButtonProps = ThemedClassName;
+
+function ScrollContainerScrollDownButton({ classNames }: ScrollContainerScrollDownButtonProps) {
+  const { pinned, controller } = 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',
@@ -204,13 +316,13 @@ const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
         iconOnly
         size={4}
         label='Scroll down'
-        onClick={() => scrollToBottom()}
+        onClick={() => controller?.scrollToBottom()}
       />
     </div>
   );
-};
+}
 
-ScrollDownButton.displayName = 'ScrollContainer.ScrollDownButton';
+ScrollContainerScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
 
 //
 // ScrollContainer
@@ -219,13 +331,17 @@ ScrollDownButton.displayName = 'ScrollContainer.ScrollDownButton';
 export { useScrollContainerContext };
 
 export const ScrollContainer = {
-  Root,
-  Viewport,
-  ScrollDownButton,
+  Root: ScrollContainerRoot,
+  Content: ScrollContainerContent,
+  Viewport: ScrollContainerViewport,
+  Fade: ScrollContainerFade,
+  ScrollDownButton: ScrollContainerScrollDownButton,
 };
 
 export type {
-  RootProps as ScrollContainerRootProps,
-  ViewportProps as ScrollContainerViewportProps,
-  ScrollDownButtonProps as ScrollContainerScrollDownButtonProps,
+  ScrollContainerRootProps,
+  ScrollContainerContentProps,
+  ScrollContainerViewportProps,
+  ScrollContainerFadeProps,
+  ScrollContainerScrollDownButtonProps,
 };

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

@@ -5,20 +5,19 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
 
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 
 import { withTheme } from '../../testing';
 import { withLayoutVariants } from '../../testing';
-
 import { Select } from './Select';
 
-faker.seed(1234);
+random.seed(1234);
 
 type ItemProps = { id: string; text: string };
 
-type StoryProps = { items: ItemProps[] };
+type DefaultStoryProps = { items: ItemProps[] };
 
-const DefaultStory = ({ items = [] }: StoryProps) => {
+const DefaultStory = ({ items = [] }: DefaultStoryProps) => {
   const [value, setValue] = useState<string>();
   return (
     <Select.Root value={value} onValueChange={setValue}>
@@ -42,9 +41,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;
@@ -53,6 +52,6 @@ type Story = StoryObj<typeof meta>;
 
 export const Default: Story = {
   args: {
-    items: Array.from({ length: 16 }).map((_, i) => ({ id: `item-${i}`, text: faker.lorem.word() })),
+    items: Array.from({ length: 16 }).map((_, i) => ({ id: `item-${i}`, text: random.lorem.word() })),
   },
 };

package/src/components/Select/Select.theme.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { mx, surfaceShadow, surfaceZIndex } from '@dxos/ui-theme';
+import { type ComponentFunction, type Elevation, type Theme } from '@dxos/ui-types';
+
+export type SelectStyleProps = Partial<{
+  elevation: Elevation;
+}>;
+
+const content: ComponentFunction<SelectStyleProps> = ({ elevation }, ...etc) => {
+  return mx(
+    'dx-modal-surface rounded-sm border border-separator',
+    'min-w-(--radix-select-trigger-width) max-h-(--radix-select-content-available-height)',
+    surfaceShadow({ elevation: 'positioned' }),
+    surfaceZIndex({ elevation, level: 'menu' }),
+    ...etc,
+  );
+};
+
+const triggerButton: ComponentFunction<SelectStyleProps> = (_props, ...etc) =>
+  mx('grid grid-cols-[1fr_auto] [&>span]:text-left', ...etc);
+
+const viewport: ComponentFunction<SelectStyleProps> = (_props, ...etc) => mx(...etc);
+
+const item: ComponentFunction<SelectStyleProps> = (_props, ...etc) =>
+  mx(
+    'flex items-center min-h-[2rem] px-2.5 py-1 gap-2',
+    'text-base-fg leading-none select-none outline-hidden',
+    '[&>svg]:invisible [&[data-state=checked]>svg]:visible',
+    'dx-highlighted',
+    ...etc,
+  );
+
+const itemIndicator: ComponentFunction<SelectStyleProps> = (_props, ...etc) => mx('items-center', ...etc);
+
+const arrow: ComponentFunction<SelectStyleProps> = (_props, ...etc) => mx('fill-separator', ...etc);
+
+const separator: ComponentFunction<SelectStyleProps> = (_props, ...etc) =>
+  mx('self-stretch border-b my-1 border-separator', ...etc);
+
+const scrollButton: ComponentFunction<SelectStyleProps> = (_props, ...etc) =>
+  mx('dx-modal-surface flex items-center justify-center cursor-default h-6 w-full', ...etc);
+
+export const selectTheme: Theme<SelectStyleProps> = {
+  content,
+  triggerButton,
+  viewport,
+  item,
+  itemIndicator,
+  arrow,
+  separator,
+  scrollButton,
+};