@dxos/react-ui 0.8.4-main.5ea62a8 → 0.8.4-main.60689f5b1c

package/src/components/ScrollContainer/ScrollContainer.tsx

@@ -0,0 +1,345 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createContext } from '@radix-ui/react-context';
+import React, {
+  type PropsWithChildren,
+  type RefObject,
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { addEventListener, combine } from '@dxos/async';
+import { invariant } from '@dxos/invariant';
+import { useMergeRefs } from '@dxos/react-hooks';
+import { composable, composableProps, slottable } from '@dxos/ui-theme';
+import { mx } from '@dxos/ui-theme';
+import { type SlottableProps } from '@dxos/ui-types';
+
+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);
+};
+
+export interface ScrollController {
+  viewport: HTMLDivElement | null;
+  scrollToTop: (behavior?: ScrollBehavior) => void;
+  scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+
+type ScrollContainerContextValue = {
+  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] =
+  createContext<ScrollContainerContextValue>('ScrollContainer');
+
+//
+// Root
+//
+
+type RootProps = PropsWithChildren<{
+  pin?: boolean;
+  behavior?: ScrollBehavior;
+}>;
+
+/**
+ * Headless scroll container that provides context for scroll state.
+ * Render ScrollContainer.Content and ScrollContainer.Viewport as children.
+ */
+const Root = forwardRef<ScrollController, RootProps>(
+  ({ 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);
+        }
+      },
+      [behaviorProp],
+    );
+
+    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],
+    );
+
+    // 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>
+    );
+  },
+);
+
+Root.displayName = 'ScrollContainer.Root';
+
+//
+// Content
+//
+
+type ContentProps = Pick<ScrollAreaRootProps, 'thin' | 'padding' | 'centered'>;
+
+/**
+ * Composable wrapper around ScrollArea.Root.
+ * Provides the DOM structure for the scroll container.
+ */
+const Content = composable<HTMLDivElement, ContentProps>(
+  ({ children, thin, padding, centered, ...props }, forwardedRef) => {
+    return (
+      <ScrollArea.Root
+        {...composableProps(props, { classNames: 'relative' })}
+        thin={thin}
+        padding={padding}
+        centered={centered}
+        ref={forwardedRef}
+      >
+        {children}
+      </ScrollArea.Root>
+    );
+  },
+);
+
+Content.displayName = 'ScrollContainer.Content';
+
+//
+// Viewport
+//
+
+const VIEWPORT_NAME = 'ScrollContainer.Viewport';
+
+type ViewportProps = SlottableProps;
+
+const Viewport = slottable<HTMLDivElement, ViewportProps>(({ children, asChild, ...props }, forwardedRef) => {
+  const scrollerRef = useRef<HTMLDivElement>(null);
+  const mergedRef = useMergeRefs([forwardedRef, scrollerRef]);
+  const { setViewport, setPinned, setOverflow } = useScrollContainerContext(VIEWPORT_NAME);
+
+  // 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>
+      <PinEffect scrollerRef={scrollerRef} />
+    </>
+  );
+});
+
+Viewport.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 PinEffect = ({ scrollerRef }: { scrollerRef: RefObject<HTMLDivElement | null> }) => {
+  const { pinned, controller } = useScrollContainerContext(PIN_EFFECT_NAME);
+
+  // Pin scroll to bottom when content changes.
+  useEffect(() => {
+    const viewport = scrollerRef.current;
+    if (!pinned || !viewport) {
+      return;
+    }
+
+    // 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 });
+
+    return () => {
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+    };
+  }, [pinned, controller, scrollerRef]);
+
+  return null;
+};
+
+//
+// Fade
+//
+
+const FADE_NAME = 'ScrollContainer.Fade';
+
+type FadeProps = {};
+
+const Fade = () => {
+  const { overflow } = useScrollContainerContext(FADE_NAME);
+
+  return (
+    <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',
+      )}
+    />
+  );
+};
+
+Fade.displayName = FADE_NAME;
+
+//
+// ScrollDownButton
+//
+
+const SCROLL_DOWN_BUTTON_NAME = 'ScrollContainer.ScrollDownButton';
+
+type ScrollDownButtonProps = ThemedClassName;
+
+const ScrollDownButton = ({ classNames }: ScrollDownButtonProps) => {
+  const { pinned, controller } = useScrollContainerContext(SCROLL_DOWN_BUTTON_NAME);
+
+  return (
+    <div
+      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={() => controller?.scrollToBottom()}
+      />
+    </div>
+  );
+};
+
+ScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
+
+//
+// ScrollContainer
+//
+
+export { useScrollContainerContext };
+
+export const ScrollContainer = {
+  Root,
+  Content,
+  Viewport,
+  Fade,
+  ScrollDownButton,
+};
+
+export type {
+  RootProps as ScrollContainerRootProps,
+  ContentProps as ScrollContainerContentProps,
+  ViewportProps as ScrollContainerViewportProps,
+  FadeProps as ScrollContainerFadeProps,
+  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,24 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
 
-import { faker } from '@dxos/random';
-
-import { withSurfaceVariantsLayout, withTheme } from '../../testing';
+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}>
@@ -43,10 +41,9 @@ const DefaultStory = ({ items = [] }: StoryProps) => {
 };
 
 const meta = {
-  title: 'ui/react-ui-core/Select',
+  title: 'ui/react-ui-core/components/Select',
   render: DefaultStory,
-  decorators: [withSurfaceVariantsLayout(), withTheme],
-  parameters: { chromatic: { disableSnapshot: false } },
+  decorators: [withTheme(), withLayoutVariants()],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;
@@ -55,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.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;
@@ -59,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}
       >
@@ -78,7 +79,7 @@ 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 size={3} icon='ph--caret-up--bold' />}
@@ -95,7 +96,7 @@ 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 size={3} icon='ph--caret-down--bold' />}
@@ -107,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>
     );
@@ -125,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;
@@ -140,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}
@@ -155,7 +152,7 @@ type SelectOptionProps = SelectItemProps;
 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,51 @@
+//
+// 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';