@dxos/react-ui 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

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

@@ -0,0 +1,70 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useEffect, useRef, useState } from 'react';
+
+import { faker } from '@dxos/random';
+
+import { withLayout, withTheme } from '../../testing';
+import { Button } from '../Button';
+import { Toolbar } from '../Toolbar';
+
+import { ScrollContainer, type ScrollContainerRootProps, type ScrollController } from './ScrollContainer';
+
+const DefaultStory = (props: ScrollContainerRootProps) => {
+  const [lines, setLines] = useState<string[]>([]);
+  const [running, setRunning] = useState(true);
+  const scroller = useRef<ScrollController>(null);
+  useEffect(() => {
+    if (!running) {
+      return;
+    }
+
+    const i = setInterval(() => {
+      setLines((lines) => [...lines, faker.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.ScrollDownButton />
+      </ScrollContainer.Root>
+    </div>
+  );
+};
+
+const meta = {
+  title: 'ui/react-ui-core/components/ScrollContainer',
+  component: ScrollContainer.Root,
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'is-[30rem]' })],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    pin: true,
+    fade: true,
+  },
+};

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';
+
+// 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/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 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');
+        },
+      }),
+      [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 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>
+      </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('is-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

@@ -8,7 +8,7 @@ import React, { useState } from 'react';
 import { faker } from '@dxos/random';
 
 import { withTheme } from '../../testing';
-import { withSurfaceVariantsLayout } from '../../testing';
+import { withLayoutVariants } from '../../testing';
 
 import { Select } from './Select';
 
@@ -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, withSurfaceVariantsLayout()],
+  decorators: [withTheme(), withLayoutVariants()],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

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;
@@ -39,7 +39,7 @@ const SelectTriggerButton = forwardRef<HTMLButtonElement, SelectTriggerButtonPro
       <SelectPrimitive.Trigger asChild ref={forwardedRef}>
         <Button {...props}>
           <SelectPrimitive.Value placeholder={placeholder}>{children}</SelectPrimitive.Value>
-          <span className='w-1 flex-1' />
+          <span className='is-1 flex-1' />
           <SelectPrimitive.Icon asChild>
             <Icon size={3} icon='ph--caret-down--bold' />
           </SelectPrimitive.Icon>
@@ -61,7 +61,7 @@ const SelectContent = forwardRef<HTMLDivElement, SelectContentProps>(
         {...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,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' />}
@@ -96,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' />}
@@ -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}
@@ -156,9 +152,9 @@ 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' />
+      <span className='grow is-1' />
       {/* <SelectPrimitive.ItemIndicator className={tx('select.itemIndicator', 'option__indicator', {})}> */}
       <Icon icon='ph--check--regular' />
       {/* </SelectPrimitive.ItemIndicator> */}
@@ -178,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

@@ -19,7 +19,7 @@ const Separator = forwardRef<HTMLDivElement, SeparatorProps>(
       <SeparatorPrimitive
         orientation={orientation}
         {...props}
-        className={tx('separator.root', 'separator', { orientation, subdued }, classNames)}
+        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-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', { 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,
+  },
+};