@dxos/react-ui 0.8.4-main.406dc2a → 0.8.4-main.40e3dcdf1b

package/src/components/Toolbar/Toolbar.stories.tsx

@@ -6,7 +6,7 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
 import { withTheme } from '../../testing';
-import { Toggle } from '../Buttons';
+import { Toggle } from '../Button';
 import { Icon } from '../Icon';
 import { Select } from '../Select';
 
@@ -63,18 +63,16 @@ const DefaultStory = (props: StorybookToolbarProps) => {
       </Toolbar.Button>
       <Toolbar.Separator />
       <Toolbar.Button>Test</Toolbar.Button>
-      <Toolbar.Button>
-        <Icon icon='ph--arrow-clockwise--regular' />
-      </Toolbar.Button>
+      <Toolbar.IconButton icon='ph--arrow-clockwise--regular' label='Refresh' iconOnly />
     </Toolbar.Root>
   );
 };
 
 const meta = {
-  title: 'ui/react-ui-core/Toolbar',
+  title: 'ui/react-ui-core/components/Toolbar',
   component: Toolbar as any,
   render: DefaultStory,
-  decorators: [withTheme],
+  decorators: [withTheme()],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

package/src/components/Toolbar/Toolbar.tsx

@@ -2,11 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Primitive } from '@radix-ui/react-primitive';
+import { Slot } from '@radix-ui/react-slot';
 import type { ToggleGroupItemProps as ToggleGroupItemPrimitiveProps } from '@radix-ui/react-toggle-group';
 import * as ToolbarPrimitive from '@radix-ui/react-toolbar';
 import React, { Fragment, forwardRef } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { composableProps, type ToolbarStyleProps } from '@dxos/ui-theme';
+import { type SlottableProps } from '@dxos/ui-types';
 
 import { useThemeContext } from '../../hooks';
+import { translationKey } from '../../translations';
 import { type ThemedClassName } from '../../util';
 import {
   Button,
@@ -18,30 +25,44 @@ import {
   Toggle,
   type ToggleGroupItemProps,
   type ToggleProps,
-} from '../Buttons';
+} from '../Button';
 import { Link, type LinkProps } from '../Link';
+import { DropdownMenu } from '../Menu';
 import { Separator, type SeparatorProps } from '../Separator';
 
+//
+// Root
+//
+
 type ToolbarRootProps = ThemedClassName<
-  ToolbarPrimitive.ToolbarProps & {
-    layoutManaged?: boolean;
-    textBlockWidth?: boolean;
-  }
+  ToolbarPrimitive.ToolbarProps &
+    ToolbarStyleProps & {
+      textBlockWidth?: boolean;
+    }
 >;
 
+// TODO(burdon): Implement asChild property.
 const ToolbarRoot = forwardRef<HTMLDivElement, ToolbarRootProps>(
-  ({ classNames, children, layoutManaged, textBlockWidth: wrapContents, ...props }, forwardedRef) => {
+  (
+    { children, density, disabled, layoutManaged, textBlockWidth: textBlockWidthProp, orientation, ...props },
+    forwardedRef,
+  ) => {
+    const { className, dir: _, ...rest } = composableProps(props);
     const { tx } = useThemeContext();
-    const InnerRoot = wrapContents ? 'div' : Fragment;
-    const innerRootProps = wrapContents
-      ? { role: 'none', className: tx('toolbar.inner', 'toolbar', { layoutManaged }, classNames) }
+    const InnerRoot = textBlockWidthProp ? 'div' : Fragment;
+    const innerRootProps = textBlockWidthProp
+      ? {
+          role: 'none',
+          className: tx('toolbar.inner', { layoutManaged }, className),
+        }
       : {};
 
     return (
       <ToolbarPrimitive.Root
-        {...props}
-        data-arrow-keys={props.orientation === 'vertical' ? 'up down' : 'left right'}
-        className={tx('toolbar.root', 'toolbar', { layoutManaged }, classNames)}
+        {...rest}
+        orientation={orientation}
+        data-arrow-keys={orientation === 'vertical' ? 'up down' : 'left right'}
+        className={tx('toolbar.root', { density, disabled, layoutManaged }, className)}
         ref={forwardedRef}
       >
         <InnerRoot {...innerRootProps}>{children}</InnerRoot>
@@ -50,6 +71,27 @@ const ToolbarRoot = forwardRef<HTMLDivElement, ToolbarRootProps>(
   },
 );
 
+//
+// Text
+//
+
+type ToolbarTextProps = SlottableProps<HTMLDivElement>;
+
+const ToolbarText = forwardRef<HTMLDivElement, ToolbarTextProps>(({ children, asChild, ...props }, forwardedRef) => {
+  const { className, ...rest } = composableProps(props);
+  const Comp = asChild ? Slot : Primitive.div;
+  const { tx } = useThemeContext();
+  return (
+    <Comp {...rest} className={tx('toolbar.text', {}, className)} ref={forwardedRef}>
+      {children}
+    </Comp>
+  );
+});
+
+//
+// Button
+//
+
 type ToolbarButtonProps = ButtonProps;
 
 const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>((props, forwardedRef) => {
@@ -60,12 +102,16 @@ const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>((props,
   );
 });
 
+//
+// IconButton
+//
+
 type ToolbarIconButtonProps = IconButtonProps;
 
 const ToolbarIconButton = forwardRef<HTMLButtonElement, ToolbarIconButtonProps>((props, forwardedRef) => {
   return (
     <ToolbarPrimitive.Button asChild>
-      <IconButton {...props} ref={forwardedRef} />
+      <IconButton {...props} noTooltip ref={forwardedRef} />
     </ToolbarPrimitive.Button>
   );
 });
@@ -80,6 +126,10 @@ const ToolbarToggle = forwardRef<HTMLButtonElement, ToolbarToggleProps>((props,
   );
 });
 
+//
+// Link
+//
+
 type ToolbarLinkProps = LinkProps;
 
 const ToolbarLink = forwardRef<HTMLAnchorElement, ToolbarLinkProps>((props, forwardedRef) => {
@@ -96,6 +146,10 @@ type ToolbarToggleGroupProps = (
 ) &
   ButtonGroupProps;
 
+//
+// ToggleGroup
+//
+
 const ToolbarToggleGroup = forwardRef<HTMLDivElement, ToolbarToggleGroupProps>(
   ({ classNames, children, elevation, ...props }, forwardedRef) => {
     return (
@@ -124,16 +178,31 @@ const ToolbarToggleGroupIconItem = forwardRef<HTMLButtonElement, ToolbarToggleGr
   ({ variant, density, elevation, classNames, icon, label, iconOnly, ...props }, forwardedRef) => {
     return (
       <ToolbarPrimitive.ToolbarToggleItem {...props} asChild>
-        <IconButton {...{ variant, density, elevation, classNames, icon, label, iconOnly }} ref={forwardedRef} />
+        <IconButton
+          {...{
+            variant,
+            density,
+            elevation,
+            classNames,
+            icon,
+            label,
+            iconOnly,
+          }}
+          ref={forwardedRef}
+        />
       </ToolbarPrimitive.ToolbarToggleItem>
     );
   },
 );
 
+//
+// Separator
+//
+
 type ToolbarSeparatorProps = SeparatorProps & { variant?: 'gap' | 'line' };
 
 const ToolbarSeparator = forwardRef<HTMLDivElement, ToolbarSeparatorProps>(
-  ({ variant = 'line', ...props }, forwardedRef) => {
+  ({ variant = 'gap', ...props }, forwardedRef) => {
     return variant === 'line' ? (
       <ToolbarPrimitive.Separator asChild>
         <Separator {...props} ref={forwardedRef} />
@@ -144,8 +213,109 @@ const ToolbarSeparator = forwardRef<HTMLDivElement, ToolbarSeparatorProps>(
   },
 );
 
+//
+// DragHandle
+//
+
+type ToolbarDragHandleProps = { testId?: string; label?: string };
+
+const ToolbarDragHandle = forwardRef<HTMLButtonElement, ToolbarDragHandleProps>(
+  ({ testId = 'drag-handle', label }, forwardedRef) => {
+    const { t } = useTranslation(translationKey);
+    return (
+      <ToolbarIconButton
+        data-testid={testId}
+        noTooltip
+        iconOnly
+        icon='ph--dots-six-vertical--regular'
+        variant='ghost'
+        label={label ?? t('toolbar drag handle label')}
+        classNames='cursor-pointer'
+        size={5}
+        disabled={!forwardedRef}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+//
+// CloseIconButton
+//
+
+type ToolbarCloseIconButtonProps = { onClick?: () => void; label?: string };
+
+const ToolbarCloseIconButton = forwardRef<HTMLButtonElement, ToolbarCloseIconButtonProps>(
+  ({ onClick, label }, forwardedRef) => {
+    const { t } = useTranslation(translationKey);
+    return (
+      <ToolbarIconButton
+        iconOnly
+        icon='ph--x--regular'
+        variant='ghost'
+        label={label ?? t('toolbar close label')}
+        classNames='cursor-pointer'
+        size={5}
+        onClick={onClick}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+//
+// Menu
+//
+
+type ToolbarMenuItem<T extends any | void = void> = {
+  label: string;
+  onClick: (context: T) => void;
+};
+
+type ToolbarMenuProps<T extends any | void = void> = {
+  context?: T;
+  items?: ToolbarMenuItem<T>[];
+};
+
+// TODO(burdon): Make slottable.
+const ToolbarMenu = <T extends any | void = void>({ context, items }: ToolbarMenuProps<T>) => {
+  const { t } = useTranslation(translationKey);
+
+  return (
+    <DropdownMenu.Root>
+      <DropdownMenu.Trigger disabled={!items?.length} asChild>
+        <ToolbarIconButton
+          iconOnly
+          variant='ghost'
+          icon='ph--dots-three-vertical--regular'
+          label={t('toolbar menu label')}
+        />
+      </DropdownMenu.Trigger>
+      {(items?.length ?? 0) > 0 && (
+        <DropdownMenu.Portal>
+          <DropdownMenu.Content>
+            <DropdownMenu.Viewport>
+              {items?.map(({ label, onClick: onSelect }, index) => (
+                <DropdownMenu.Item key={index} onSelect={() => onSelect(context as T)}>
+                  {label}
+                </DropdownMenu.Item>
+              ))}
+            </DropdownMenu.Viewport>
+            <DropdownMenu.Arrow />
+          </DropdownMenu.Content>
+        </DropdownMenu.Portal>
+      )}
+    </DropdownMenu.Root>
+  );
+};
+
+//
+// Toolbar
+//
+
 export const Toolbar = {
   Root: ToolbarRoot,
+  Text: ToolbarText,
   Button: ToolbarButton,
   IconButton: ToolbarIconButton,
   Link: ToolbarLink,
@@ -154,10 +324,14 @@ export const Toolbar = {
   ToggleGroupItem: ToolbarToggleGroupItem,
   ToggleGroupIconItem: ToolbarToggleGroupIconItem,
   Separator: ToolbarSeparator,
+  DragHandle: ToolbarDragHandle,
+  CloseIconButton: ToolbarCloseIconButton,
+  Menu: ToolbarMenu,
 };
 
 export type {
   ToolbarRootProps,
+  ToolbarTextProps,
   ToolbarButtonProps,
   ToolbarIconButtonProps,
   ToolbarLinkProps,
@@ -166,4 +340,8 @@ export type {
   ToolbarToggleGroupItemProps,
   ToolbarToggleGroupIconItemProps,
   ToolbarSeparatorProps,
+  ToolbarDragHandleProps,
+  ToolbarCloseIconButtonProps,
+  ToolbarMenuItem,
+  ToolbarMenuProps,
 };

package/src/components/Tooltip/Tooltip.stories.tsx

@@ -8,7 +8,7 @@ import React from 'react';
 import { faker } from '@dxos/random';
 
 import { withTheme } from '../../testing';
-import { Button } from '../Buttons';
+import { Button } from '../Button';
 
 import { Tooltip } from './Tooltip';
 
@@ -17,23 +17,25 @@ type StoryProps = {
   defaultOpen?: boolean;
 };
 
-const DefaultStory = ({ tooltips, defaultOpen }: StoryProps) => (
-  <Tooltip.Provider defaultOpen={defaultOpen}>
-    <div role='none' className='is-32'>
-      {tooltips.map(({ label, content }, i) => (
-        <Tooltip.Trigger asChild key={i} content={content} side='right'>
-          <Button classNames='block is-full'>{label}</Button>
-        </Tooltip.Trigger>
-      ))}
-    </div>
-  </Tooltip.Provider>
-);
+const DefaultStory = ({ tooltips, defaultOpen }: StoryProps) => {
+  return (
+    <Tooltip.Provider defaultOpen={defaultOpen}>
+      <div role='none' className='w-32'>
+        {tooltips.map(({ label, content }, i) => (
+          <Tooltip.Trigger asChild key={i} content={content} side='right'>
+            <Button classNames='block w-full'>{label}</Button>
+          </Tooltip.Trigger>
+        ))}
+      </div>
+    </Tooltip.Provider>
+  );
+};
 
 const meta = {
-  title: 'ui/react-ui-core/Tooltip',
+  title: 'ui/react-ui-core/components/Tooltip',
   component: Tooltip as any,
   render: DefaultStory,
-  decorators: [withTheme],
+  decorators: [withTheme()],
 } satisfies Meta<typeof DefaultStory>;
 
 export default meta;

package/src/components/Tooltip/Tooltip.tsx

@@ -3,6 +3,7 @@
 //
 
 // This is based upon `@radix-ui/react-tooltip` fetched 17 March 2025 at https://github.com/radix-ui/primitives at commit 6e75e11.
+// TODO(burdon): Replace with https://ui.shadcn.com/docs/components/radix/tooltip
 
 import { composeEventHandlers } from '@radix-ui/primitive';
 import { useComposedRefs } from '@radix-ui/react-compose-refs';
@@ -41,9 +42,9 @@ type TooltipScopedProps<P = {}> = P & { __scopeTooltip?: Scope };
 const [createTooltipContext, createTooltipScope] = createContextScope('Tooltip', [createPopperScope]);
 const usePopperScope = createPopperScope();
 
-/* -------------------------------------------------------------------------------------------------
- * Tooltip
- * ----------------------------------------------------------------------------------------------- */
+//
+// Tooltip
+//
 
 const DEFAULT_DELAY_DURATION = 700;
 const TOOLTIP_OPEN = 'tooltip.open';
@@ -215,9 +216,9 @@ const TooltipProvider: FC<TooltipProviderProps> = (props: TooltipScopedProps<Too
           isPointerInTransitRef.current = inTransit;
         }, [])}
       >
-        <TooltipContent side={side} className={tx('tooltip.content', 'tooltip', { elevation })}>
+        <TooltipContent side={side} className={tx('tooltip.content', { elevation })}>
           {content}
-          <TooltipArrow className={tx('tooltip.arrow', 'tooltip__arrow')} />
+          <TooltipArrow className={tx('tooltip.arrow')} />
         </TooltipContent>
         <TooltipVirtualTrigger virtualRef={triggerRef as RefObject<HTMLButtonElement>} />
         {children}
@@ -228,9 +229,9 @@ const TooltipProvider: FC<TooltipProviderProps> = (props: TooltipScopedProps<Too
 
 TooltipProvider.displayName = TOOLTIP_NAME;
 
-/* -------------------------------------------------------------------------------------------------
- * TooltipVirtualTrigger
- * ----------------------------------------------------------------------------------------------- */
+//
+// TooltipVirtualTrigger
+//
 
 const TooltipVirtualTrigger = ({
   virtualRef,
@@ -240,9 +241,9 @@ const TooltipVirtualTrigger = ({
   return <PopperPrimitive.Anchor asChild {...popperScope} virtualRef={virtualRef} />;
 };
 
-/* -------------------------------------------------------------------------------------------------
- * TooltipTrigger
- * ----------------------------------------------------------------------------------------------- */
+//
+// TooltipTrigger
+//
 
 const TRIGGER_NAME = 'TooltipTrigger';
 
@@ -322,9 +323,9 @@ const TooltipTrigger = forwardRef<TooltipTriggerElement, TooltipTriggerProps>(
 
 TooltipTrigger.displayName = TRIGGER_NAME;
 
-/* -------------------------------------------------------------------------------------------------
- * TooltipPortal
- * ----------------------------------------------------------------------------------------------- */
+//
+// TooltipPortal
+//
 
 const PORTAL_NAME = 'TooltipPortal';
 
@@ -363,9 +364,9 @@ const TooltipPortal: FC<TooltipPortalProps> = (props: TooltipScopedProps<Tooltip
 
 TooltipPortal.displayName = PORTAL_NAME;
 
-/* -------------------------------------------------------------------------------------------------
- * TooltipContent
- * ----------------------------------------------------------------------------------------------- */
+//
+// TooltipContent
+//
 
 const CONTENT_NAME = 'TooltipContent';
 
@@ -574,9 +575,9 @@ const TooltipContentImpl = forwardRef<TooltipContentImplElement, TooltipContentI
 
 TooltipContent.displayName = CONTENT_NAME;
 
-/* -------------------------------------------------------------------------------------------------
- * TooltipArrow
- * ----------------------------------------------------------------------------------------------- */
+//
+// TooltipArrow
+//
 
 const ARROW_NAME = 'TooltipArrow';
 
@@ -599,8 +600,6 @@ const TooltipArrow = forwardRef<TooltipArrowElement, TooltipArrowProps>(
 
 TooltipArrow.displayName = ARROW_NAME;
 
-/* ----------------------------------------------------------------------------------------------- */
-
 type TooltipSide = NonNullable<TooltipContentProps['side']>;
 
 const getExitSideFromRect = (point: Point, rect: DOMRect): TooltipSide => {
@@ -755,6 +754,10 @@ const getHullPresorted = <P extends Point>(points: Readonly<Array<P>>): Array<P>
   }
 };
 
+//
+// Tooltip
+//
+
 export const Tooltip = {
   Provider: TooltipProvider,
   Trigger: TooltipTrigger,

package/src/components/index.ts

@@ -2,29 +2,34 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './AnchoredOverflow';
+export * from './DensityProvider';
+export * from './ElevationProvider';
+export * from './ThemeProvider';
+
 export * from './Avatars';
 export * from './Breadcrumb';
-export * from './Buttons';
+export * from './Button';
+export * from './Card';
 export * from './Clipboard';
-export * from './Dialogs';
+export * from './Dialog';
+export * from './ErrorFallback';
 export * from './Icon';
+export * from './Image';
 export * from './Input';
 export * from './Link';
-export * from './Lists';
+export * from './List';
 export * from './Main';
-export * from './Menus';
+export * from './Menu';
 export * from './Message';
 export * from './Popover';
 export * from './Status';
 export * from './ScrollArea';
+export * from './ScrollContainer';
 export * from './Select';
 export * from './Separator';
+export * from './Skeleton';
+export * from './Splitter';
 export * from './Tag';
 export * from './Toast';
 export * from './Toolbar';
 export * from './Tooltip';
-
-export * from './DensityProvider';
-export * from './ElevationProvider';
-export * from './ThemeProvider';

package/src/exemplars/generics.stories.tsx

@@ -0,0 +1,49 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { type ReactElement, type Ref, forwardRef } from 'react';
+
+import { type SlottableProps } from '@dxos/ui-types';
+
+import { withTheme } from '../testing';
+
+const ComponentInner = forwardRef<HTMLDivElement, ComponentProps>(({ children, ...props }, forwardedRef) => {
+  return (
+    <div {...props} ref={forwardedRef}>
+      {children}
+    </div>
+  );
+});
+
+ComponentInner.displayName = 'Component';
+
+/**
+ * Generic component pattern.
+ */
+type ComponentProps<P extends HTMLElement = any> = SlottableProps<P>;
+
+const Component = ComponentInner as <P extends HTMLElement>(
+  props: SlottableProps<P> & { ref?: Ref<P> },
+) => ReactElement;
+
+const meta = {
+  title: 'ui/react-ui-core/exemplars/generics',
+  component: Component,
+  render: (props) => <Component<HTMLDivElement> {...props} />,
+  decorators: [withTheme()],
+  parameters: {
+    layout: 'centered',
+  },
+} satisfies Meta;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    children: 'Hello',
+  },
+};