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

package/src/components/Toolbar/Toolbar.tsx

@@ -2,14 +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, { Fragment, forwardRef } from 'react';
+import React, { type MouseEventHandler, forwardRef } from 'react';
+import { useTranslation } from 'react-i18next';
 
-import { type ToolbarStyleProps } from '@dxos/ui-theme';
+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,
@@ -22,43 +28,61 @@ import {
   type ToggleProps,
 } from '../Button';
 import { Link, type LinkProps } from '../Link';
+import { DropdownMenu } from '../Menu';
 import { Separator, type SeparatorProps } from '../Separator';
 
-type ToolbarRootProps = ThemedClassName<
-  ToolbarPrimitive.ToolbarProps &
-    ToolbarStyleProps & {
-      textBlockWidth?: boolean;
-    }
->;
-
-// TODO(burdon): Implement asChild property.
-const ToolbarRoot = forwardRef<HTMLDivElement, ToolbarRootProps>(
-  (
-    { classNames, children, density, disabled, layoutManaged, textBlockWidth: textBlockWidthProp, ...props },
-    forwardedRef,
-  ) => {
+//
+// Root
+//
+
+type ToolbarRootProps = ToolbarPrimitive.ToolbarProps & ToolbarStyleProps;
+
+const ToolbarRoot = composable<HTMLDivElement, ToolbarRootProps>(
+  ({ children, density, disabled, layoutManaged, orientation, ...props }, forwardedRef) => {
+    const { className, role, ...rest } = composableProps(props);
     const { tx } = useThemeContext();
-    const InnerRoot = textBlockWidthProp ? 'div' : Fragment;
-    const innerRootProps = textBlockWidthProp
-      ? {
-          role: 'none',
-          className: tx('toolbar.inner', 'toolbar', { layoutManaged }, classNames),
-        }
-      : {};
 
     return (
       <ToolbarPrimitive.Root
-        {...props}
-        data-arrow-keys={props.orientation === 'vertical' ? 'up down' : 'left right'}
-        className={tx('toolbar.root', 'toolbar', { density, disabled, 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}
       >
-        <InnerRoot {...innerRootProps}>{children}</InnerRoot>
+        {children}
       </ToolbarPrimitive.Root>
     );
   },
 );
 
+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) => {
@@ -69,6 +93,12 @@ const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>((props,
   );
 });
 
+ToolbarButton.displayName = 'Toolbar.Button';
+
+//
+// IconButton
+//
+
 type ToolbarIconButtonProps = IconButtonProps;
 
 const ToolbarIconButton = forwardRef<HTMLButtonElement, ToolbarIconButtonProps>((props, forwardedRef) => {
@@ -79,6 +109,8 @@ const ToolbarIconButton = forwardRef<HTMLButtonElement, ToolbarIconButtonProps>(
   );
 });
 
+ToolbarIconButton.displayName = 'Toolbar.IconButton';
+
 type ToolbarToggleProps = ToggleProps;
 
 const ToolbarToggle = forwardRef<HTMLButtonElement, ToolbarToggleProps>((props, forwardedRef) => {
@@ -89,6 +121,12 @@ const ToolbarToggle = forwardRef<HTMLButtonElement, ToolbarToggleProps>((props,
   );
 });
 
+ToolbarToggle.displayName = 'Toolbar.Toggle';
+
+//
+// Link
+//
+
 type ToolbarLinkProps = LinkProps;
 
 const ToolbarLink = forwardRef<HTMLAnchorElement, ToolbarLinkProps>((props, forwardedRef) => {
@@ -99,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 (
@@ -115,6 +159,8 @@ const ToolbarToggleGroup = forwardRef<HTMLDivElement, ToolbarToggleGroupProps>(
   },
 );
 
+ToolbarToggleGroup.displayName = 'Toolbar.ToggleGroup';
+
 type ToolbarToggleGroupItemProps = ToggleGroupItemProps;
 
 const ToolbarToggleGroupItem = forwardRef<HTMLButtonElement, ToolbarToggleGroupItemProps>(
@@ -127,10 +173,12 @@ 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
@@ -142,6 +190,7 @@ const ToolbarToggleGroupIconItem = forwardRef<HTMLButtonElement, ToolbarToggleGr
             icon,
             label,
             iconOnly,
+            iconClassNames,
           }}
           ref={forwardedRef}
         />
@@ -150,13 +199,19 @@ const ToolbarToggleGroupIconItem = forwardRef<HTMLButtonElement, ToolbarToggleGr
   },
 );
 
+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} />
@@ -164,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,
@@ -174,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,
@@ -186,4 +376,9 @@ export type {
   ToolbarToggleGroupItemProps,
   ToolbarToggleGroupIconItemProps,
   ToolbarSeparatorProps,
+  ToolbarDragHandleProps,
+  ToolbarActionIconButtonAction,
+  ToolbarActionIconButtonProps,
+  ToolbarMenuItem,
+  ToolbarMenuProps,
 };

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

@@ -5,29 +5,30 @@
 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 '../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>
+  );
+};
 
 const meta = {
   title: 'ui/react-ui-core/components/Tooltip',
@@ -72,10 +73,10 @@ export const DefaultOpen: Story = {
 export const StressTest: Story = {
   args: {
     defaultOpen: true,
-    tooltips: faker.helpers.multiple(
+    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 },
     ),

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,
+};

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';
@@ -21,9 +22,8 @@ import { useControllableState } from '@radix-ui/react-use-controllable-state';
 import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
 import React, {
   type ComponentPropsWithoutRef,
-  type ElementRef,
+  type ComponentRef,
   type FC,
-  type MutableRefObject,
   type ReactNode,
   type RefObject,
   type SyntheticEvent,
@@ -54,19 +54,19 @@ type TooltipContextValue = {
   open: boolean;
   stateAttribute: 'closed' | 'delayed-open' | 'instant-open';
   trigger: TooltipTriggerElement | null;
-  onTriggerChange(trigger: TooltipTriggerElement | null): void;
+  onTriggerChange(trigger: TooltipTriggerElement | null, content?: ReactNode, side?: TooltipSide): void;
   onTriggerEnter(): void;
   onTriggerLeave(): void;
   onOpen(): void;
   onClose(): void;
   onPointerInTransitChange(inTransit: boolean): void;
-  isPointerInTransitRef: MutableRefObject<boolean>;
+  isPointerInTransitRef: RefObject<boolean>;
   disableHoverableContent: boolean;
 };
 
 const [TooltipContextProvider, useTooltipContext] = createTooltipContext<TooltipContextValue>(TOOLTIP_NAME);
 
-interface TooltipProviderProps {
+type TooltipProviderProps = {
   children?: ReactNode;
   open?: boolean;
   defaultOpen?: boolean;
@@ -87,7 +87,7 @@ interface TooltipProviderProps {
    * @defaultValue 300
    */
   skipDelayDuration?: number;
-}
+};
 
 const TooltipProvider: FC<TooltipProviderProps> = (props: TooltipScopedProps<TooltipProviderProps>) => {
   const {
@@ -111,15 +111,18 @@ const TooltipProvider: FC<TooltipProviderProps> = (props: TooltipScopedProps<Too
 
   const popperScope = usePopperScope(__scopeTooltip);
   const [trigger, setTrigger] = useState<HTMLButtonElement | null>(null);
-  const [content, setContent] = useState<string>('');
+  const [content, setContent] = useState<ReactNode>(null);
   const [side, setSide] = useState<TooltipSide | undefined>(undefined);
   const triggerRef = useRef<HTMLButtonElement | null>(trigger);
-  const handleTriggerChange = useCallback((nextTrigger: HTMLButtonElement | null) => {
-    setTrigger(nextTrigger);
-    triggerRef.current = nextTrigger;
-    setContent(nextTrigger?.getAttribute('data-tooltip-content') ?? '');
-    setSide((nextTrigger?.getAttribute('data-tooltip-side') as TooltipSide | null) ?? undefined);
-  }, []);
+  const handleTriggerChange = useCallback(
+    (nextTrigger: HTMLButtonElement | null, nextContent?: ReactNode, nextSide?: TooltipSide) => {
+      setTrigger(nextTrigger);
+      triggerRef.current = nextTrigger;
+      setContent(nextContent ?? null);
+      setSide(nextSide);
+    },
+    [],
+  );
   const contentId = useId();
   const openTimerRef = useRef(0);
   const wasOpenDelayedRef = useRef(false);
@@ -215,9 +218,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}
@@ -244,13 +247,13 @@ const TooltipVirtualTrigger = ({
 // TooltipTrigger
 //
 
-const TRIGGER_NAME = 'TooltipTrigger';
+const TRIGGER_NAME = 'Tooltip.Trigger';
 
-type TooltipTriggerElement = ElementRef<typeof Primitive.button>;
+type TooltipTriggerElement = ComponentRef<typeof Primitive.button>;
 type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
-type TooltipTriggerProps = PrimitiveButtonProps &
+type TooltipTriggerProps = Omit<PrimitiveButtonProps, 'content'> &
   Pick<TooltipProps, 'delayDuration'> & {
-    content?: string;
+    content?: ReactNode;
     side?: TooltipSide;
     onInteract?: (event: SyntheticEvent) => void;
   };
@@ -283,8 +286,6 @@ const TooltipTrigger = forwardRef<TooltipTriggerElement, TooltipTriggerProps>(
         // commonly anchors and the anchor `type` attribute signifies MIME type.
         aria-describedby={context.open ? context.contentId : undefined}
         data-state={context.stateAttribute}
-        data-tooltip-content={content}
-        data-tooltip-side={side}
         {...triggerProps}
         ref={composedRefs}
         onPointerMove={composeEventHandlers(props.onPointerMove, (event) => {
@@ -296,7 +297,7 @@ const TooltipTrigger = forwardRef<TooltipTriggerElement, TooltipTriggerProps>(
             if (event.defaultPrevented) {
               return;
             }
-            context.onTriggerChange(ref.current);
+            context.onTriggerChange(ref.current, content, side);
             context.onTriggerEnter();
             hasPointerMoveOpenedRef.current = true;
           }
@@ -326,7 +327,7 @@ TooltipTrigger.displayName = TRIGGER_NAME;
 // TooltipPortal
 //
 
-const PORTAL_NAME = 'TooltipPortal';
+const PORTAL_NAME = 'Tooltip.Portal';
 
 type PortalContextValue = { forceMount?: true };
 const [PortalProvider, usePortalContext] = createTooltipContext<PortalContextValue>(PORTAL_NAME, {
@@ -334,7 +335,7 @@ const [PortalProvider, usePortalContext] = createTooltipContext<PortalContextVal
 });
 
 type PortalProps = ComponentPropsWithoutRef<typeof PortalPrimitive>;
-interface TooltipPortalProps {
+type TooltipPortalProps = {
   children?: ReactNode;
   /**
    * Specify a container element to portal the content into.
@@ -345,7 +346,7 @@ interface TooltipPortalProps {
    * controlling animation with React animation libraries.
    */
   forceMount?: true;
-}
+};
 
 const TooltipPortal: FC<TooltipPortalProps> = (props: TooltipScopedProps<TooltipPortalProps>) => {
   const { __scopeTooltip, forceMount, children, container } = props;
@@ -367,16 +368,16 @@ TooltipPortal.displayName = PORTAL_NAME;
 // TooltipContent
 //
 
-const CONTENT_NAME = 'TooltipContent';
+const CONTENT_NAME = 'Tooltip.Content';
 
 type TooltipContentElement = TooltipContentImplElement;
-interface TooltipContentProps extends TooltipContentImplProps {
+type TooltipContentProps = TooltipContentImplProps & {
   /**
    * Used to force mounting when more control is needed. Useful when
    * controlling animation with React animation libraries.
    */
   forceMount?: true;
-}
+};
 
 const TooltipContent = forwardRef<TooltipContentElement, TooltipContentProps>(
   (props: TooltipScopedProps<TooltipContentProps>, forwardedRef) => {
@@ -400,7 +401,7 @@ type Point = { x: number; y: number };
 type Polygon = Point[];
 
 type TooltipContentHoverableElement = TooltipContentImplElement;
-interface TooltipContentHoverableProps extends TooltipContentImplProps {}
+type TooltipContentHoverableProps = TooltipContentImplProps;
 
 const TooltipContentHoverable = forwardRef<TooltipContentHoverableElement, TooltipContentHoverableProps>(
   (props: TooltipScopedProps<TooltipContentHoverableProps>, forwardedRef) => {
@@ -479,10 +480,10 @@ const [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] =
   isInside: false,
 });
 
-type TooltipContentImplElement = ElementRef<typeof PopperPrimitive.Content>;
+type TooltipContentImplElement = ComponentRef<typeof PopperPrimitive.Content>;
 type DismissableLayerProps = ComponentPropsWithoutRef<typeof DismissableLayer>;
 type PopperContentProps = ComponentPropsWithoutRef<typeof PopperPrimitive.Content>;
-interface TooltipContentImplProps extends Omit<PopperContentProps, 'onPlaced'> {
+type TooltipContentImplProps = Omit<PopperContentProps, 'onPlaced'> & {
   /**
    * A more descriptive label for accessibility purpose
    */
@@ -498,7 +499,7 @@ interface TooltipContentImplProps extends Omit<PopperContentProps, 'onPlaced'> {
    * Can be prevented.
    */
   onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];
-}
+};
 
 const TooltipContentImpl = forwardRef<TooltipContentImplElement, TooltipContentImplProps>(
   (props: TooltipScopedProps<TooltipContentImplProps>, forwardedRef) => {
@@ -578,11 +579,11 @@ TooltipContent.displayName = CONTENT_NAME;
 // TooltipArrow
 //
 
-const ARROW_NAME = 'TooltipArrow';
+const ARROW_NAME = 'Tooltip.Arrow';
 
-type TooltipArrowElement = ElementRef<typeof PopperPrimitive.Arrow>;
+type TooltipArrowElement = ComponentRef<typeof PopperPrimitive.Arrow>;
 type PopperArrowProps = ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>;
-interface TooltipArrowProps extends PopperArrowProps {}
+type TooltipArrowProps = PopperArrowProps;
 
 const TooltipArrow = forwardRef<TooltipArrowElement, TooltipArrowProps>(
   (props: TooltipScopedProps<TooltipArrowProps>, forwardedRef) => {

package/src/components/Tooltip/index.ts

@@ -3,3 +3,4 @@
 //
 
 export * from './Tooltip';
+export * from './tooltipContent';