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

package/src/components/Popover/Popover.tsx

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-// This is based upon `@radix-ui/react-popover` fetched 25 Oct 2024 at https://github.com/radix-ui/primitives at commit 374c7d7.
+// This is based upon `@radix-ui/react-popover` fetched Oct 25, 2024 at https://github.com/radix-ui/primitives at commit 374c7d7.
 
 import { composeEventHandlers } from '@radix-ui/primitive';
 import { useComposedRefs } from '@radix-ui/react-compose-refs';
@@ -23,9 +23,8 @@ import { hideOthers } from 'aria-hidden';
 import React, {
   type ComponentPropsWithRef,
   type ComponentPropsWithoutRef,
-  type ElementRef,
+  type ComponentRef,
   type FC,
-  type MutableRefObject,
   type ReactNode,
   type RefObject,
   forwardRef,
@@ -37,30 +36,31 @@ import React, {
 } from 'react';
 import { RemoveScroll } from 'react-remove-scroll';
 
-import { useElevationContext, useThemeContext } from '../../hooks';
-import { useSafeCollisionPadding } from '../../hooks/useSafeCollisionPadding';
+import { useSafeCollisionPadding, useElevationContext, useThemeContext } from '../../hooks';
 import { type ThemedClassName } from '../../util';
 
 //
 // Context
 //
 
+type ScopedProps<P> = P & { __scopePopover?: Scope };
+
 const POPOVER_NAME = 'Popover';
 
-type ScopedProps<P> = P & { __scopePopover?: Scope };
 const [createPopoverContext, createPopoverScope] = createContextScope(POPOVER_NAME, [createPopperScope]);
+
 const usePopperScope = createPopperScope();
 
 type PopoverContextValue = {
-  triggerRef: MutableRefObject<HTMLButtonElement>;
+  triggerRef: RefObject<HTMLButtonElement>;
   contentId: string;
+  hasCustomAnchor: boolean;
+  modal: boolean;
   open: boolean;
   onOpenChange(open: boolean): void;
   onOpenToggle(): void;
-  hasCustomAnchor: boolean;
   onCustomAnchorAdd(): void;
   onCustomAnchorRemove(): void;
-  modal: boolean;
 };
 
 const [PopoverProvider, usePopoverContext] = createPopoverContext<PopoverContextValue>(POPOVER_NAME);
@@ -69,13 +69,13 @@ const [PopoverProvider, usePopoverContext] = createPopoverContext<PopoverContext
 // PopoverRoot
 //
 
-interface PopoverRootProps {
+type PopoverRootProps = {
   children?: ReactNode;
   open?: boolean;
   defaultOpen?: boolean;
   onOpenChange?: (open: boolean) => void;
   modal?: boolean;
-}
+};
 
 const PopoverRoot: FC<PopoverRootProps> = (props: ScopedProps<PopoverRootProps>) => {
   const { __scopePopover, children, open: openProp, defaultOpen, onOpenChange, modal = false } = props;
@@ -93,7 +93,7 @@ const PopoverRoot: FC<PopoverRootProps> = (props: ScopedProps<PopoverRootProps>)
       <PopoverProvider
         scope={__scopePopover}
         contentId={useId()}
-        triggerRef={triggerRef as MutableRefObject<HTMLButtonElement>}
+        triggerRef={triggerRef as RefObject<HTMLButtonElement>}
         open={open}
         onOpenChange={setOpen}
         onOpenToggle={useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen])}
@@ -116,9 +116,9 @@ PopoverRoot.displayName = POPOVER_NAME;
 
 const ANCHOR_NAME = 'PopoverAnchor';
 
-type PopoverAnchorElement = ElementRef<typeof PopperPrimitive.Anchor>;
+type PopoverAnchorElement = ComponentRef<typeof PopperPrimitive.Anchor>;
 type PopperAnchorProps = ComponentPropsWithoutRef<typeof PopperPrimitive.Anchor>;
-interface PopoverAnchorProps extends PopperAnchorProps {}
+type PopoverAnchorProps = PopperAnchorProps;
 
 const PopoverAnchor = forwardRef<PopoverAnchorElement, PopoverAnchorProps>(
   (props: ScopedProps<PopoverAnchorProps>, forwardedRef) => {
@@ -144,19 +144,22 @@ PopoverAnchor.displayName = ANCHOR_NAME;
 
 const TRIGGER_NAME = 'PopoverTrigger';
 
-type PopoverTriggerElement = ElementRef<typeof Primitive.button>;
+type PopoverTriggerElement = ComponentRef<typeof Primitive.button>;
 type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
-interface PopoverTriggerProps extends PrimitiveButtonProps {}
+type PopoverTriggerProps = PrimitiveButtonProps & {
+  asChild?: boolean;
+};
 
 const PopoverTrigger = forwardRef<PopoverTriggerElement, PopoverTriggerProps>(
   (props: ScopedProps<PopoverTriggerProps>, forwardedRef) => {
-    const { __scopePopover, ...triggerProps } = props;
+    const { __scopePopover, asChild, ...triggerProps } = props;
     const context = usePopoverContext(TRIGGER_NAME, __scopePopover);
     const popperScope = usePopperScope(__scopePopover);
     const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);
+    const Comp = asChild ? Slot : Primitive.button;
 
     const trigger = (
-      <Primitive.button
+      <Comp
         type='button'
         aria-haspopup='dialog'
         aria-expanded={context.open}
@@ -186,9 +189,9 @@ PopoverTrigger.displayName = TRIGGER_NAME;
 
 const VIRTUAL_TRIGGER_NAME = 'PopoverVirtualTrigger';
 
-interface PopoverVirtualTriggerProps {
+type PopoverVirtualTriggerProps = {
   virtualRef: RefObject<PopoverTriggerElement | null>;
-}
+};
 
 const PopoverVirtualTrigger = (props: ScopedProps<PopoverVirtualTriggerProps>) => {
   const { __scopePopover, virtualRef } = props;
@@ -216,7 +219,7 @@ const [PortalProvider, usePortalContext] = createPopoverContext<PortalContextVal
 });
 
 type PortalProps = ComponentPropsWithoutRef<typeof PortalPrimitive>;
-interface PopoverPortalProps {
+type PopoverPortalProps = {
   children?: ReactNode;
   /**
    * Specify a container element to portal the content into.
@@ -227,9 +230,9 @@ interface PopoverPortalProps {
    * controlling animation with React animation libraries.
    */
   forceMount?: true;
-}
+};
 
-const PopoverPortal: FC<PopoverPortalProps> = (props: ScopedProps<PopoverPortalProps>) => {
+const PopoverPortal = (props: ScopedProps<PopoverPortalProps>) => {
   const { __scopePopover, forceMount, children, container } = props;
   const context = usePopoverContext(PORTAL_NAME, __scopePopover);
   return (
@@ -280,8 +283,10 @@ const PopoverContent = forwardRef<PopoverContentTypeElement, PopoverContentProps
 PopoverContent.displayName = CONTENT_NAME;
 
 type PopoverContentTypeElement = PopoverContentImplElement;
-export interface PopoverContentTypeProps
-  extends Omit<PopoverContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {}
+export interface PopoverContentTypeProps extends Omit<
+  PopoverContentImplProps,
+  'trapFocus' | 'disableOutsidePointerEvents'
+> {}
 
 const PopoverContentModal = forwardRef<PopoverContentTypeElement, PopoverContentTypeProps>(
   (props: ScopedProps<PopoverContentTypeProps>, forwardedRef) => {
@@ -303,8 +308,7 @@ const PopoverContentModal = forwardRef<PopoverContentTypeElement, PopoverContent
         <PopoverContentImpl
           {...props}
           ref={composedRefs}
-          // we make sure we're not trapping once it's been closed
-          // (closed !== unmounted when animating out)
+          // Make sure we're not trapping once it's been closed (closed !== unmounted when animating out).
           trapFocus={context.open}
           disableOutsidePointerEvents
           onCloseAutoFocus={composeEventHandlers(props.onCloseAutoFocus, (event) => {
@@ -393,32 +397,31 @@ const PopoverContentNonModal = forwardRef<PopoverContentTypeElement, PopoverCont
   },
 );
 
-type PopoverContentImplElement = ElementRef<typeof PopperPrimitive.Content>;
+type PopoverContentImplElement = ComponentRef<typeof PopperPrimitive.Content>;
 type FocusScopeProps = ComponentPropsWithoutRef<typeof FocusScope>;
 type DismissableLayerProps = ComponentPropsWithoutRef<typeof DismissableLayer>;
 type PopperContentProps = ThemedClassName<ComponentPropsWithoutRef<typeof PopperPrimitive.Content>>;
 
-interface PopoverContentImplProps
-  extends Omit<PopperContentProps, 'onPlaced'>,
-    Omit<DismissableLayerProps, 'onDismiss'> {
-  /**
-   * Whether focus should be trapped within the `Popover`
-   * (default: false)
-   */
-  trapFocus?: FocusScopeProps['trapped'];
-
-  /**
-   * Event handler called when auto-focusing on open.
-   * Can be prevented.
-   */
-  onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
-
-  /**
-   * Event handler called when auto-focusing on close.
-   * Can be prevented.
-   */
-  onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
-}
+type PopoverContentImplProps = Omit<PopperContentProps, 'onPlaced'> &
+  Omit<DismissableLayerProps, 'onDismiss'> & {
+    /**
+     * Whether focus should be trapped within the `Popover`
+     * (default: false)
+     */
+    trapFocus?: FocusScopeProps['trapped'];
+
+    /**
+     * Event handler called when auto-focusing on open.
+     * Can be prevented.
+     */
+    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
+
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+  };
 
 const PopoverContentImpl = forwardRef<PopoverContentImplElement, PopoverContentImplProps>(
   (props: ScopedProps<PopoverContentImplProps>, forwardedRef) => {
@@ -485,7 +488,7 @@ const PopoverContentImpl = forwardRef<PopoverContentImplElement, PopoverContentI
             {...contentProps}
             collisionPadding={safeCollisionPadding}
             collisionBoundary={computedCollisionBoundary}
-            className={tx('popover.content', 'popover', { elevation }, classNames)}
+            className={tx('popover.content', { elevation }, classNames)}
             ref={forwardedRef}
             style={{
               ...contentProps.style,
@@ -511,8 +514,8 @@ const PopoverContentImpl = forwardRef<PopoverContentImplElement, PopoverContentI
 
 const CLOSE_NAME = 'PopoverClose';
 
-type PopoverCloseElement = ElementRef<typeof Primitive.button>;
-interface PopoverCloseProps extends PrimitiveButtonProps {}
+type PopoverCloseElement = ComponentRef<typeof Primitive.button>;
+type PopoverCloseProps = PrimitiveButtonProps;
 
 const PopoverClose = forwardRef<PopoverCloseElement, PopoverCloseProps>(
   (props: ScopedProps<PopoverCloseProps>, forwardedRef) => {
@@ -537,9 +540,9 @@ PopoverClose.displayName = CLOSE_NAME;
 
 const ARROW_NAME = 'PopoverArrow';
 
-type PopoverArrowElement = ElementRef<typeof PopperPrimitive.Arrow>;
+type PopoverArrowElement = ComponentRef<typeof PopperPrimitive.Arrow>;
 type PopperArrowProps = ThemedClassName<ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>>;
-interface PopoverArrowProps extends PopperArrowProps {}
+type PopoverArrowProps = PopperArrowProps;
 
 const PopoverArrow = forwardRef<PopoverArrowElement, PopoverArrowProps>(
   (props: ScopedProps<PopoverArrowProps>, forwardedRef) => {
@@ -550,7 +553,7 @@ const PopoverArrow = forwardRef<PopoverArrowElement, PopoverArrowProps>(
       <PopperPrimitive.Arrow
         {...popperScope}
         {...arrowProps}
-        className={tx('popover.arrow', 'popover__arrow', {}, classNames)}
+        className={tx('popover.arrow', {}, classNames)}
         ref={forwardedRef}
       />
     );
@@ -572,15 +575,15 @@ type PopoverViewportProps = ThemedClassName<ComponentPropsWithRef<typeof Primiti
 const PopoverViewport = forwardRef<HTMLDivElement, PopoverViewportProps>(
   ({ classNames, asChild, constrainInline = true, constrainBlock = true, children, ...props }, forwardedRef) => {
     const { tx } = useThemeContext();
-    const Root = asChild ? Slot : Primitive.div;
+    const Comp = asChild ? Slot : Primitive.div;
     return (
-      <Root
+      <Comp
         {...props}
-        className={tx('popover.viewport', 'popover__viewport', { constrainInline, constrainBlock }, classNames)}
+        className={tx('popover.viewport', { constrainInline, constrainBlock }, classNames)}
         ref={forwardedRef}
       >
         {children}
-      </Root>
+      </Comp>
     );
   },
 );

package/src/components/ScrollArea/ScrollArea.stories.tsx

@@ -2,16 +2,18 @@
 // Copyright 2026 DXOS.org
 //
 
-import React, { useMemo } from 'react';
+import React, { PropsWithChildren, useMemo } from 'react';
 
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { mx } from '@dxos/ui-theme';
+import { ThemedClassName } from '@dxos/ui-types';
 
+import { Column } from '../../primitives';
 import { withLayout, withTheme } from '../../testing';
-
+import { Input } from '../Input';
 import { ScrollArea } from './ScrollArea';
 
-faker.seed(123);
+random.seed(123);
 
 export default {
   title: 'ui/react-ui-core/components/ScrollArea',
@@ -22,22 +24,22 @@ export default {
   },
 };
 
-const Column = () => (
+const List = ({ items = 50 }: { items?: number }) => (
   <div>
-    {Array.from({ length: 50 }).map((_, index) => (
-      <div key={index} className='text-sm'>
+    {Array.from({ length: items }).map((_, index) => (
+      <div key={index} className='px-1 cursor-pointer hover:bg-hover-surface'>
         Item {index + 1}
       </div>
     ))}
   </div>
 );
 
-const Row = () => (
-  <div className='flex gap-2 is-max'>
-    {Array.from({ length: 50 }).map((_, index) => (
+const Row = ({ items = 50 }: { items?: number }) => (
+  <div className='flex gap-2 w-max'>
+    {Array.from({ length: items }).map((_, index) => (
       <div
         key={index}
-        className='shrink-0 bs-20 is-20 border border-separator rounded-md flex items-center justify-center text-sm'
+        className='shrink-0 h-20 w-20 cursor-pointer border border-separator rounded-md flex items-center justify-center hover:bg-hover-surface'
       >
         {index + 1}
       </div>
@@ -45,58 +47,91 @@ const Row = () => (
   </div>
 );
 
+const Container = ({ classNames, children }: ThemedClassName<PropsWithChildren>) => {
+  return <div className={mx('border border-separator rounded-md overflow-hidden', classNames)}>{children}</div>;
+};
+
 export const Vertical = {
   render: () => (
-    <div className='bs-72 is-48 p-2 border border-separator rounded-md'>
+    <Container classNames='h-72 w-48'>
       <ScrollArea.Root orientation='vertical'>
         <ScrollArea.Viewport>
-          <Column />
+          <List />
         </ScrollArea.Viewport>
       </ScrollArea.Root>
-    </div>
+    </Container>
   ),
 };
 
 export const VerticalThin = {
   render: () => (
-    <div className='bs-72 is-48 p-2 border border-separator rounded-md'>
+    <Container classNames='h-72 w-48'>
       <ScrollArea.Root orientation='vertical' thin>
         <ScrollArea.Viewport>
-          <Column />
+          <List />
         </ScrollArea.Viewport>
       </ScrollArea.Root>
-    </div>
+    </Container>
+  ),
+};
+
+export const VerticalPadded = {
+  render: () => (
+    <Container classNames='h-72 w-48'>
+      <ScrollArea.Root orientation='vertical' centered padding thin>
+        <ScrollArea.Viewport>
+          <List />
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    </Container>
+  ),
+};
+
+export const VerticalColumn = {
+  render: () => (
+    <Container classNames='h-72 w-48'>
+      <Column.Root gutter='sm' classNames='h-full overflow-hidden'>
+        <ScrollArea.Root orientation='vertical' padding thin>
+          <ScrollArea.Viewport classNames='py-2'>
+            <Input.Root>
+              <Input.TextInput classNames='p-1' />
+            </Input.Root>
+            <List />
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      </Column.Root>
+    </Container>
   ),
 };
 
 export const Horizontal = {
   render: () => (
-    <div className='is-96 p-2 border border-separator rounded-md'>
+    <Container classNames='w-96'>
       <ScrollArea.Root orientation='horizontal'>
         <ScrollArea.Viewport>
           <Row />
         </ScrollArea.Viewport>
       </ScrollArea.Root>
-    </div>
+    </Container>
   ),
 };
 
 export const HorizontalThin = {
   render: () => (
-    <div className='is-96 p-2 border border-separator rounded-md'>
+    <Container classNames='w-96'>
       <ScrollArea.Root orientation='horizontal' thin>
         <ScrollArea.Viewport>
           <Row />
         </ScrollArea.Viewport>
       </ScrollArea.Root>
-    </div>
+    </Container>
   ),
 };
 
 export const Both = {
   render: () => (
-    <div className='bs-72 is-96 p-2 border border-separator rounded-md'>
-      <ScrollArea.Root thin orientation='all'>
+    <Container classNames='w-96 h-96'>
+      <ScrollArea.Root orientation='all'>
         <ScrollArea.Viewport>
           <div className='flex flex-col gap-2'>
             {Array.from({ length: 50 }).map((_, rowIndex) => (
@@ -104,7 +139,7 @@ export const Both = {
                 {Array.from({ length: 50 }).map((_, colIndex) => (
                   <div
                     key={colIndex}
-                    className='shrink-0 bs-20 is-20 flex items-center justify-center text-sm border border-separator font-mono'
+                    className='shrink-0 h-20 w-20 flex items-center justify-center text-sm border border-separator font-mono'
                   >
                     [{colIndex}:{rowIndex}]
                   </div>
@@ -114,7 +149,31 @@ export const Both = {
           </div>
         </ScrollArea.Viewport>
       </ScrollArea.Root>
-    </div>
+    </Container>
+  ),
+};
+
+export const Fullscreen = {
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
+  render: () => (
+    <ScrollArea.Root orientation='all' thin>
+      <ScrollArea.Viewport>
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 50 }).map((_, rowIndex) => (
+            <div key={rowIndex} className='flex gap-2'>
+              {Array.from({ length: 50 }).map((_, colIndex) => (
+                <div
+                  key={colIndex}
+                  className='shrink-0 h-20 w-20 flex items-center justify-center text-sm border border-separator font-mono'
+                >
+                  [{colIndex}:{rowIndex}]
+                </div>
+              ))}
+            </div>
+          ))}
+        </div>
+      </ScrollArea.Viewport>
+    </ScrollArea.Root>
   ),
 };
 
@@ -125,30 +184,30 @@ export const NestedScrollAreas = {
       () =>
         Array.from({ length: 8 }).map((_, index) => ({
           id: String(index),
-          count: faker.number.int({ min: 5, max: 20 }),
+          count: random.number.int({ min: 5, max: 20 }),
         })),
       [],
     );
 
     return (
-      <ScrollArea.Root thin orientation='horizontal'>
+      <ScrollArea.Root orientation='horizontal' thin padding>
         <ScrollArea.Viewport classNames='gap-4'>
           {columns.map((column) => (
             <section
               key={column.id}
-              className='shrink-0 bs-full is-[16rem] grid grid-rows-[min-content_1fr_min-content] border border-separator'
+              className='shrink-0 h-full w-[16rem] grid grid-rows-[min-content_1fr_min-content] border border-separator'
             >
-              <header className='flex shrink-0 p-2 border-be border-separator'>Column {column.id}</header>
+              <header className='flex shrink-0 p-2 border-b border-separator'>Column {column.id}</header>
               <ScrollArea.Root thin orientation='vertical'>
-                <ScrollArea.Viewport classNames='plb-2 pli-2 gap-2'>
+                <ScrollArea.Viewport classNames='py-2 px-2 gap-2'>
                   {Array.from({ length: column.count }, (_, i) => (
-                    <div key={i} role='listitem' className={`shrink-0 p-2 text-sm border border-separator rounded-sm`}>
+                    <div key={i} role='listitem' className={`shrink-0 p-2 text-sm border border-separator rounded-xs`}>
                       Item {i + 1}
                     </div>
                   ))}
                 </ScrollArea.Viewport>
               </ScrollArea.Root>
-              <footer className={`p-2 text-subdued border-bs border-separator`}>{column.count}</footer>
+              <footer className={`p-2 text-subdued border-t border-separator`}>{column.count}</footer>
             </section>
           ))}
         </ScrollArea.Viewport>
@@ -159,18 +218,18 @@ export const NestedScrollAreas = {
 
 export const NativeScroll = {
   render: () => (
-    <div className='group bs-48 is-48 border border-separator'>
+    <div className='group h-48 w-48 border border-separator'>
       <div
         className={mx(
-          'group bs-full is-full overflow-y-scroll',
-          '[&::-webkit-scrollbar]:is-3',
+          'group h-full w-full overflow-y-scroll',
+          '[&::-webkit-scrollbar]:w-3',
           '[&::-webkit-scrollbar-thumb]:rounded-none',
-          '[&::-webkit-scrollbar-track]:bg-scrollbarTrack',
-          '[&::-webkit-scrollbar-thumb]:bg-scrollbarThumbSubdued',
-          'group-hover:[&::-webkit-scrollbar-thumb]:bg-scrollbarThumb',
+          '[&::-webkit-scrollbar-track]:bg-scrollbar-track',
+          '[&::-webkit-scrollbar-thumb]:bg-scrollbar-thumbSubdued',
+          'group-hover:[&::-webkit-scrollbar-thumb]:bg-scrollbar-thumb',
         )}
       >
-        <Column />
+        <List />
       </div>
     </div>
   ),

package/src/components/ScrollArea/ScrollArea.tsx

@@ -3,9 +3,12 @@
 //
 
 import { createContext } from '@radix-ui/react-context';
-import React, { type HTMLAttributes, forwardRef } from 'react';
+import { Primitive } from '@radix-ui/react-primitive';
+import { Slot } from '@radix-ui/react-slot';
+import React, { CSSProperties, useMemo } from 'react';
 
-import { type AllowedAxis, type SlottableProps, type ThemedClassName } from '@dxos/ui-types';
+import { composableProps, scrollbar, slottable } from '@dxos/ui-theme';
+import { type AllowedAxis, type SlottableProps } from '@dxos/ui-types';
 
 import { useThemeContext } from '../../hooks';
 
@@ -21,7 +24,7 @@ type ScrollAreaContextType = {
   /** Hide scrollbars when not scrolling. */
   autoHide: boolean;
   /** Apply padding to opposite side of scrollbar. */
-  margin?: boolean;
+  centered?: boolean;
   /** Apply padding. */
   padding: boolean;
   /** Use thin scrollbars. */
@@ -38,20 +41,19 @@ const [ScrollAreaProvider, useScrollAreaContext] = createContext<ScrollAreaConte
 
 const SCROLLAREA_ROOT_NAME = 'ScrollArea.Root';
 
-type ScrollAreaRootProps = SlottableProps<HTMLDivElement> & Partial<ScrollAreaContextType>;
+type ScrollAreaRootProps = Partial<ScrollAreaContextType>;
 
 /**
  * ScrollArea provides native scrollbars with custom styling.
  */
-const ScrollAreaRoot = forwardRef<HTMLDivElement, ScrollAreaRootProps>(
+const ScrollAreaRoot = slottable<HTMLDivElement, ScrollAreaRootProps>(
   (
     {
-      className,
-      classNames,
       children,
+      asChild,
       orientation = 'vertical',
       autoHide = true,
-      margin = false,
+      centered = false,
       padding = false,
       thin = false,
       snap = false,
@@ -60,17 +62,18 @@ const ScrollAreaRoot = forwardRef<HTMLDivElement, ScrollAreaRootProps>(
     forwardedRef,
   ) => {
     const { tx } = useThemeContext();
-    const options = { orientation, autoHide, margin, padding, thin, snap };
+    const { className, ...rest } = composableProps(props);
+    const Comp = asChild ? Slot : Primitive.div;
+    const options = useMemo(
+      () => ({ orientation, autoHide, centered, padding, thin, snap }),
+      [orientation, autoHide, centered, padding, thin, snap],
+    );
 
     return (
       <ScrollAreaProvider {...options}>
-        <div
-          {...props}
-          className={tx('scrollArea.root', 'scroll-area', options, [className, classNames])}
-          ref={forwardedRef}
-        >
+        <Comp {...rest} className={tx('scrollArea.root', options, className)} ref={forwardedRef}>
           {children}
-        </div>
+        </Comp>
       </ScrollAreaProvider>
     );
   },
@@ -84,24 +87,33 @@ ScrollAreaRoot.displayName = SCROLLAREA_ROOT_NAME;
 
 const SCROLLAREA_VIEWPORT_NAME = 'ScrollArea.Viewport';
 
-type ScrollAreaViewportProps = ThemedClassName<HTMLAttributes<HTMLDivElement>>;
-
-const ScrollAreaViewport = forwardRef<HTMLDivElement, ScrollAreaViewportProps>(
-  ({ classNames, children, ...props }, forwardedRef) => {
-    const { tx } = useThemeContext();
-    const options = useScrollAreaContext(SCROLLAREA_VIEWPORT_NAME);
-
-    return (
-      <div
-        {...props}
-        className={tx('scrollArea.viewport', 'scroll-area__viewport', options, classNames)}
-        ref={forwardedRef}
-      >
-        {children}
-      </div>
-    );
-  },
-);
+type ScrollAreaViewportProps = SlottableProps;
+
+const ScrollAreaViewport = slottable<HTMLDivElement>(({ children, asChild, ...props }, forwardedRef) => {
+  const { tx } = useThemeContext();
+  const options = useScrollAreaContext(SCROLLAREA_VIEWPORT_NAME);
+  const density = options.thin ? scrollbar.thin : scrollbar.coarse;
+  const { className, ...rest } = composableProps(props);
+  const { style, ...restWithoutStyle } = rest as { style?: CSSProperties; [key: string]: any };
+  const Comp = asChild ? Slot : Primitive.div;
+
+  return (
+    <Comp
+      {...restWithoutStyle}
+      style={
+        {
+          '--scroll-width': `${density.size}px`,
+          '--scroll-padding': `${density.padding}px`,
+          ...style,
+        } as CSSProperties
+      }
+      className={tx('scrollArea.viewport', options, className)}
+      ref={forwardedRef}
+    >
+      {children}
+    </Comp>
+  );
+});
 
 ScrollAreaViewport.displayName = SCROLLAREA_VIEWPORT_NAME;