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

package/src/components/Toolbar/Toolbar.tsx

@@ -2,12 +2,20 @@
 // 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, { forwardRef } from 'react';
+import React, { type MouseEventHandler, forwardRef } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { type SlottableProps } from '@dxos/ui-types';
+
+import { translationKey } from '#translations';
 
 import { useThemeContext } from '../../hooks';
-import { type ThemedClassName } from '../../util';
+import { type ToolbarStyleProps } from '../../theme';
+import { composable, composableProps, slottable } from '../../util';
 import {
   Button,
   ButtonGroup,
@@ -18,19 +26,30 @@ 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';
 
-type ToolbarRootProps = ThemedClassName<ToolbarPrimitive.ToolbarProps> & { layoutManaged?: boolean };
+//
+// Root
+//
+
+type ToolbarRootProps = ToolbarPrimitive.ToolbarProps & ToolbarStyleProps;
 
-const ToolbarRoot = forwardRef<HTMLDivElement, ToolbarRootProps>(
-  ({ classNames, children, layoutManaged, ...props }, forwardedRef) => {
+const ToolbarRoot = composable<HTMLDivElement, ToolbarRootProps>(
+  ({ children, density, disabled, layoutManaged, orientation, ...props }, forwardedRef) => {
+    const { className, role, ...rest } = composableProps(props);
     const { tx } = useThemeContext();
+
     return (
       <ToolbarPrimitive.Root
-        {...props}
-        className={tx('toolbar.root', 'toolbar', { layoutManaged }, classNames)}
+        {...rest}
+        // Only pass role when explicitly set; radix provides role="toolbar" by default.
+        {...(role !== 'none' && { role })}
+        orientation={orientation}
+        data-arrow-keys={orientation === 'vertical' ? 'up down' : 'left right'}
+        className={tx('toolbar.root', { density, disabled, layoutManaged }, className)}
         ref={forwardedRef}
       >
         {children}
@@ -39,6 +58,31 @@ const ToolbarRoot = forwardRef<HTMLDivElement, ToolbarRootProps>(
   },
 );
 
+ToolbarRoot.displayName = 'Toolbar.Root';
+
+//
+// Text
+//
+
+type ToolbarTextProps = SlottableProps;
+
+const ToolbarText = slottable<HTMLDivElement>(({ 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>
+  );
+});
+
+ToolbarText.displayName = 'Toolbar.Text';
+
+//
+// Button
+//
+
 type ToolbarButtonProps = ButtonProps;
 
 const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>((props, forwardedRef) => {
@@ -49,6 +93,12 @@ const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>((props,
   );
 });
 
+ToolbarButton.displayName = 'Toolbar.Button';
+
+//
+// IconButton
+//
+
 type ToolbarIconButtonProps = IconButtonProps;
 
 const ToolbarIconButton = forwardRef<HTMLButtonElement, ToolbarIconButtonProps>((props, forwardedRef) => {
@@ -59,6 +109,8 @@ const ToolbarIconButton = forwardRef<HTMLButtonElement, ToolbarIconButtonProps>(
   );
 });
 
+ToolbarIconButton.displayName = 'Toolbar.IconButton';
+
 type ToolbarToggleProps = ToggleProps;
 
 const ToolbarToggle = forwardRef<HTMLButtonElement, ToolbarToggleProps>((props, forwardedRef) => {
@@ -69,6 +121,12 @@ const ToolbarToggle = forwardRef<HTMLButtonElement, ToolbarToggleProps>((props,
   );
 });
 
+ToolbarToggle.displayName = 'Toolbar.Toggle';
+
+//
+// Link
+//
+
 type ToolbarLinkProps = LinkProps;
 
 const ToolbarLink = forwardRef<HTMLAnchorElement, ToolbarLinkProps>((props, forwardedRef) => {
@@ -79,12 +137,18 @@ const ToolbarLink = forwardRef<HTMLAnchorElement, ToolbarLinkProps>((props, forw
   );
 });
 
+ToolbarLink.displayName = 'Toolbar.Link';
+
 type ToolbarToggleGroupProps = (
   | Omit<ToolbarPrimitive.ToolbarToggleGroupSingleProps, 'className'>
   | Omit<ToolbarPrimitive.ToolbarToggleGroupMultipleProps, 'className'>
 ) &
   ButtonGroupProps;
 
+//
+// ToggleGroup
+//
+
 const ToolbarToggleGroup = forwardRef<HTMLDivElement, ToolbarToggleGroupProps>(
   ({ classNames, children, elevation, ...props }, forwardedRef) => {
     return (
@@ -95,6 +159,8 @@ const ToolbarToggleGroup = forwardRef<HTMLDivElement, ToolbarToggleGroupProps>(
   },
 );
 
+ToolbarToggleGroup.displayName = 'Toolbar.ToggleGroup';
+
 type ToolbarToggleGroupItemProps = ToggleGroupItemProps;
 
 const ToolbarToggleGroupItem = forwardRef<HTMLButtonElement, ToolbarToggleGroupItemProps>(
@@ -107,25 +173,45 @@ const ToolbarToggleGroupItem = forwardRef<HTMLButtonElement, ToolbarToggleGroupI
   },
 );
 
+ToolbarToggleGroupItem.displayName = 'Toolbar.ToggleGroupItem';
+
 type ToolbarToggleGroupIconItemProps = Omit<ToggleGroupItemPrimitiveProps, 'className'> & IconButtonProps;
 
 const ToolbarToggleGroupIconItem = forwardRef<HTMLButtonElement, ToolbarToggleGroupIconItemProps>(
-  ({ variant, density, elevation, classNames, icon, label, iconOnly, ...props }, forwardedRef) => {
+  ({ variant, density, elevation, classNames, icon, label, iconOnly, iconClassNames, ...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,
+            iconClassNames,
+          }}
+          ref={forwardedRef}
+        />
       </ToolbarPrimitive.ToolbarToggleItem>
     );
   },
 );
 
+ToolbarToggleGroupIconItem.displayName = 'Toolbar.ToggleGroupIconItem';
+
+//
+// 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} />
+        <Separator orientation='vertical' {...props} ref={forwardedRef} />
       </ToolbarPrimitive.Separator>
     ) : (
       <ToolbarPrimitive.Separator className='grow' ref={forwardedRef} />
@@ -133,8 +219,139 @@ const ToolbarSeparator = forwardRef<HTMLDivElement, ToolbarSeparatorProps>(
   },
 );
 
+ToolbarSeparator.displayName = 'Toolbar.Separator';
+
+//
+// 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}
+        tabIndex={-1}
+        noTooltip
+        iconOnly
+        icon='ph--dots-six-vertical--regular'
+        variant='ghost'
+        label={label ?? t('toolbar-drag-handle.label')}
+        classNames='dx-focus-ring-none cursor-pointer'
+        disabled={!forwardedRef}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+ToolbarDragHandle.displayName = 'Toolbar.DragHandle';
+
+//
+// ActionIconButton
+//
+
+/**
+ * Known semantic actions a toolbar icon-button can represent. Each action
+ * picks its own phosphor icon + default translation key so call sites just
+ * declare intent (`action='delete'`) rather than re-specifying the icon /
+ * label every time.
+ */
+type ToolbarActionIconButtonAction = 'close' | 'delete';
+
+type ToolbarActionIconButtonProps = {
+  action: ToolbarActionIconButtonAction;
+  onClick?: MouseEventHandler<HTMLButtonElement>;
+  label?: string;
+};
+
+const TOOLBAR_ACTION_ICONS: Record<ToolbarActionIconButtonAction, string> = {
+  close: 'ph--x--regular',
+  delete: 'ph--trash--regular',
+};
+
+const TOOLBAR_ACTION_LABEL_KEYS: Record<ToolbarActionIconButtonAction, string> = {
+  close: 'toolbar-close.label',
+  delete: 'toolbar-delete.label',
+};
+
+const ToolbarActionIconButton = forwardRef<HTMLButtonElement, ToolbarActionIconButtonProps>(
+  ({ action, onClick, label }, forwardedRef) => {
+    const { t } = useTranslation(translationKey);
+
+    return (
+      <ToolbarIconButton
+        iconOnly
+        icon={TOOLBAR_ACTION_ICONS[action]}
+        variant='ghost'
+        label={label ?? t(TOOLBAR_ACTION_LABEL_KEYS[action])}
+        classNames='cursor-pointer'
+        onClick={onClick}
+        ref={forwardedRef}
+      />
+    );
+  },
+);
+
+ToolbarActionIconButton.displayName = 'Toolbar.ActionIconButton';
+
+//
+// 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.
+function 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>
+  );
+}
+
+ToolbarMenu.displayName = 'Toolbar.Menu';
+
+//
+// Toolbar
+//
+
 export const Toolbar = {
   Root: ToolbarRoot,
+  Text: ToolbarText,
   Button: ToolbarButton,
   IconButton: ToolbarIconButton,
   Link: ToolbarLink,
@@ -143,10 +360,14 @@ export const Toolbar = {
   ToggleGroupItem: ToolbarToggleGroupItem,
   ToggleGroupIconItem: ToolbarToggleGroupIconItem,
   Separator: ToolbarSeparator,
+  DragHandle: ToolbarDragHandle,
+  ActionIconButton: ToolbarActionIconButton,
+  Menu: ToolbarMenu,
 };
 
 export type {
   ToolbarRootProps,
+  ToolbarTextProps,
   ToolbarButtonProps,
   ToolbarIconButtonProps,
   ToolbarLinkProps,
@@ -155,4 +376,9 @@ export type {
   ToolbarToggleGroupItemProps,
   ToolbarToggleGroupIconItemProps,
   ToolbarSeparatorProps,
+  ToolbarDragHandleProps,
+  ToolbarActionIconButtonAction,
+  ToolbarActionIconButtonProps,
+  ToolbarMenuItem,
+  ToolbarMenuProps,
 };

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

@@ -2,42 +2,46 @@
 // Copyright 2022 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 
 import { withTheme } from '../../testing';
-import { Button } from '../Buttons';
-
+import { Button } from '../Button';
 import { Tooltip } from './Tooltip';
 
-type StoryProps = {
+type DefaultStoryProps = {
   tooltips: { label: string; content: string }[];
   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 }: DefaultStoryProps) => {
+  return (
+    <Tooltip.Provider defaultOpen={defaultOpen}>
+      <div 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>
+  );
+};
 
-export default {
-  title: 'ui/react-ui-core/Tooltip',
-  component: Tooltip,
+const meta = {
+  title: 'ui/react-ui-core/components/Tooltip',
+  component: Tooltip as any,
   render: DefaultStory,
-  decorators: [withTheme],
-  parameters: { chromatic: { disableSnapshot: false } },
-};
+  decorators: [withTheme()],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
 
-export const Default = {
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
   args: {
     tooltips: [
       {
@@ -46,14 +50,11 @@ export const Default = {
       },
     ],
   },
-  parameters: {
-    chromatic: { delay: 500 },
-  },
 };
 
-export const DefaultOpen = {
+export const DefaultOpen: Story = {
   args: {
-    defaultOption: true,
+    defaultOpen: true,
     tooltips: [
       {
         label: 'Tooltip trigger',
@@ -61,23 +62,17 @@ export const DefaultOpen = {
       },
     ],
   },
-  parameters: {
-    chromatic: { delay: 500 },
-  },
 };
 
-export const StressTest = {
+export const StressTest: Story = {
   args: {
-    defaultOption: true,
-    tooltips: faker.helpers.multiple(
+    defaultOpen: true,
+    tooltips: random.helpers.multiple(
       () => ({
-        label: faker.lorem.words(2),
-        content: faker.lorem.words(5),
+        label: random.lorem.words(2),
+        content: random.lorem.words(5),
       }),
       { count: 32 },
     ),
   },
-  parameters: {
-    chromatic: { disableSnapshot: true },
-  },
 };

package/src/components/Tooltip/Tooltip.theme.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { mx } from '@dxos/ui-theme';
+import { type ComponentFunction, type Elevation, type Theme } from '@dxos/ui-types';
+
+import { tooltipContent } from './tooltipContent';
+
+export type TooltipStyleProps = Partial<{
+  elevation: Elevation;
+}>;
+
+const arrow: ComponentFunction<TooltipStyleProps> = (_props, ...etc) => mx('fill-inverse-surface', ...etc);
+
+export const tooltipTheme: Theme<TooltipStyleProps> = {
+  content: tooltipContent,
+  arrow,
+};