@primitiv-ui/react 0.1.0 → 0.1.2

package/src/Tabs/types.ts

@@ -1,9 +1,16 @@
 import { ComponentProps, Ref } from "react";
 
+/** Layout axis of the tab list. `"horizontal"` arranges triggers in a row and
+ * binds ArrowLeft/ArrowRight; `"vertical"` stacks them and binds
+ * ArrowUp/ArrowDown. */
 export type TabsOrientation = "horizontal" | "vertical";
 
+/** Reading direction of the tab list. In `"rtl"` the horizontal arrow keys are
+ * mirrored so navigation follows the visual order. */
 export type TabsReadingDirection = "ltr" | "rtl";
 
+/** When a focused trigger becomes active. `"automatic"` activates a tab as soon
+ * as it receives focus via the arrow keys; `"manual"` requires Enter/Space. */
 export type TabsActivationMode = "automatic" | "manual";
 
 /**
@@ -17,22 +24,34 @@ export type TabsActivationMode = "automatic" | "manual";
  */
 export type TabMetadata = { index: number; name: string };
 
+/** Props common to both controlled and uncontrolled `Tabs.Root` usage. */
 export type BaseTabsRootProps = {
+  /** Fired on every user-driven activation with the activated tab's metadata. */
   onChange?: ({ index, name }: TabMetadata) => void;
 };
 
+/** Uncontrolled `Tabs.Root` props: the component owns the active tab, seeded by
+ * an optional `defaultValue`. Mutually exclusive with the controlled props. */
 export type UncontrolledTabsRootProps = {
+  /** Value of the tab active on first render. */
   defaultValue?: string;
   value?: never;
   onValueChange?: never;
 };
 
-type ControlledTabsRootProps = {
+/** Controlled `Tabs.Root` props: the caller owns the active tab via `value` and
+ * is notified of activation requests through `onValueChange`. */
+export type ControlledTabsRootProps = {
+  /** Value of the currently active tab. */
   value: string;
+  /** Called with the requested value when the user activates a tab. */
   onValueChange: (value: string) => void;
   defaultValue?: never;
 };
 
+/** Props for `Tabs.Root` — the state owner and context provider. Extends the
+ * native `<div>` props (minus `onChange`) and resolves to either the
+ * controlled or uncontrolled prop shape. */
 export type TabsRootProps = Omit<ComponentProps<"div">, "onChange"> & {
   orientation?: TabsOrientation;
   dir?: TabsReadingDirection;
@@ -46,6 +65,9 @@ export type TabsRootProps = Omit<ComponentProps<"div">, "onChange"> & {
 } & BaseTabsRootProps &
   (UncontrolledTabsRootProps | ControlledTabsRootProps);
 
+/** The value shared by `Tabs.Root` with its descendants through context:
+ * resolved configuration, the active tab and its setter, and the registry of
+ * triggers used for roving focus and keyboard navigation. */
 export type TabsContextValue = {
   orientation: TabsOrientation;
   dir: TabsReadingDirection;
@@ -67,6 +89,9 @@ export type TabsContextValue = {
   focusTrigger: (value: string) => void;
 };
 
+/** Props for `Tabs.List` — the `role="tablist"` container. Requires exactly one
+ * accessible name source: either an inline `label` or an `ariaLabelledBy` id
+ * referencing existing label text. */
 export type TabsListProps = Omit<
   ComponentProps<"div">,
   "label" | "aria-labelledby"
@@ -75,6 +100,10 @@ export type TabsListProps = Omit<
     | { label: string; ariaLabelledBy?: never }
     | { label?: never; ariaLabelledBy: string }
   );
+/** Props for `Tabs.Trigger` — an individual `role="tab"` button. Identified by
+ * its required `value`, which links it to the `Tabs.Content` of the same value.
+ * The element type defaults to `HTMLButtonElement` and can be overridden via
+ * `asChild` and the `ref` type parameter. */
 export type TabsTriggerProps<T extends HTMLElement = HTMLButtonElement> = Omit<
   ComponentProps<"button">,
   "ref"
@@ -90,10 +119,15 @@ export type TabsTriggerProps<T extends HTMLElement = HTMLButtonElement> = Omit<
   ref?: Ref<T>;
 };
 
+/** Props for `Tabs.Content` — a `role="tabpanel"`. Its required `value` links
+ * it to the `Tabs.Trigger` of the same value. */
 export type TabsContentProps = ComponentProps<"div"> & {
+  /** Value of the trigger this panel belongs to. */
   value: string;
 };
 
+/** Imperative handle exposed on the `Tabs.Root` ref for programmatic control. */
 export type TabsImperativeApi = {
+  /** Activate the tab with the given value. */
   setActiveTab: (value: string) => void;
 };

package/src/Tabs/utils.ts

@@ -1,4 +1,4 @@
-import { deriveId } from "../utils";
+import { deriveId } from "../utils/index.ts";
 
 export function getTriggerAndPanelIds(tabsId: string, value: string) {
   return {

package/src/Textarea/Textarea.tsx

@@ -1,5 +1,7 @@
-import { useFieldProps } from "../Field/hooks";
-import { Slot } from "../Slot";
+import type { ReactElement } from "react";
+
+import { useFieldProps } from "../Field/hooks/index.ts";
+import { Slot } from "../Slot/index.ts";
 import { TextareaProps } from "./types";
 
 /**
@@ -74,7 +76,7 @@ export function Textarea({
   children,
   ref,
   ...consumer
-}: TextareaProps) {
+}: TextareaProps): ReactElement {
   const merged = useFieldProps(consumer);
 
   const rootProps = {
@@ -90,4 +92,5 @@ export function Textarea({
   return <textarea {...rootProps} />;
 }
 
+/** @internal */
 Textarea.displayName = "Textarea";

package/src/Textarea/__tests__/Textarea.field-integration.test.tsx

@@ -1,6 +1,6 @@
 import { render, screen } from "@testing-library/react";
 
-import { Field } from "../../Field";
+import { Field } from "../../Field/index.ts";
 import { Textarea } from "../Textarea";
 
 describe("Textarea — Field integration", () => {

package/src/Textarea/types.ts

@@ -1,5 +1,9 @@
 import { ComponentProps, ReactNode, Ref } from "react";
 
+/**
+ * Props for {@link Textarea} — all native `<textarea>` attributes plus the
+ * `asChild` escape hatch and a typed `ref`.
+ */
 export type TextareaProps = ComponentProps<"textarea"> & {
   asChild?: boolean;
   ref?: Ref<HTMLTextAreaElement>;

package/src/Toggle/Toggle.tsx

@@ -1,5 +1,7 @@
-import { useControllableState } from "../hooks";
-import { Slot, composeEventHandlers } from "../Slot";
+import type { ReactElement } from "react";
+
+import { useControllableState } from "../hooks/index.ts";
+import { Slot, composeEventHandlers } from "../Slot/index.ts";
 
 import { ToggleProps } from "./types";
 
@@ -50,7 +52,7 @@ function Toggle({
   children,
   ref,
   ...rest
-}: ToggleProps) {
+}: ToggleProps): ReactElement {
   const [pressed, setPressed] = useControllableState<boolean>(
     controlledPressed,
     defaultPressed ?? false,
@@ -73,9 +75,14 @@ function Toggle({
   };
 
   if (asChild) return <Slot {...toggleProps}>{children}</Slot>;
-  return <button type="button" {...toggleProps}>{children}</button>;
+  return (
+    <button type="button" {...toggleProps}>
+      {children}
+    </button>
+  );
 }
 
+/** @internal */
 Toggle.displayName = "Toggle";
 
 export { Toggle };

package/src/Toggle/types.ts

@@ -1,23 +1,27 @@
 import { ButtonHTMLAttributes, ReactNode, Ref } from "react";
 
-type UncontrolledToggleProps = {
+/** Uncontrolled `Toggle` props: seed with `defaultPressed`; `pressed`/`onPressedChange` are disallowed. */
+export type UncontrolledToggleProps = {
   defaultPressed?: boolean;
   pressed?: never;
   onPressedChange?: never;
 };
 
-type ControlledToggleProps = {
+/** Controlled `Toggle` props: drive with `pressed` and `onPressedChange`; `defaultPressed` is disallowed. */
+export type ControlledToggleProps = {
   pressed: boolean;
   onPressedChange: (pressed: boolean) => void;
   defaultPressed?: never;
 };
 
-type ToggleBaseProps = {
+/** Props common to both `Toggle` modes: `disabled`, `asChild`, `children`, `ref`, and the native `<button>` attributes (minus `type`). */
+export type ToggleBaseProps = {
   disabled?: boolean;
   asChild?: boolean;
   children?: ReactNode;
   ref?: Ref<HTMLButtonElement>;
 } & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type">;
 
+/** Props for the `Toggle` button — base props combined with the controlled/uncontrolled discriminated union. */
 export type ToggleProps = ToggleBaseProps &
   (UncontrolledToggleProps | ControlledToggleProps);

package/src/ToggleGroup/ToggleGroup.tsx

@@ -1,11 +1,12 @@
 import { useEffect, useMemo, useRef } from "react";
+import type { ReactElement } from "react";
 
-import { useDirection } from "../DirectionProvider";
-import { useRovingTabindex } from "../hooks";
-import { Slot, composeEventHandlers, composeRefs } from "../Slot";
+import { useDirection } from "../DirectionProvider/index.ts";
+import { useRovingTabindex } from "../hooks/index.ts";
+import { Slot, composeEventHandlers, composeRefs } from "../Slot/index.ts";
 
 import { ToggleGroupContext } from "./ToggleGroupContext";
-import { useToggleGroupRoot, useToggleGroupContext } from "./hooks";
+import { useToggleGroupRoot, useToggleGroupContext } from "./hooks/index.ts";
 import { ToggleGroupItemProps, ToggleGroupRootProps } from "./types";
 
 /**
@@ -62,7 +63,7 @@ import { ToggleGroupItemProps, ToggleGroupRootProps } from "./types";
  * </ToggleGroup.Root>
  * ```
  */
-function ToggleGroupRoot({
+export function ToggleGroupRoot({
   type,
   defaultValue,
   value: controlledValue,
@@ -73,7 +74,7 @@ function ToggleGroupRoot({
   children,
   ref,
   ...rest
-}: ToggleGroupRootProps) {
+}: ToggleGroupRootProps): ReactElement {
   const resolvedDir = dir ?? useDirection();
   const {
     value,
@@ -138,6 +139,7 @@ function ToggleGroupRoot({
   );
 }
 
+/** @internal */
 ToggleGroupRoot.displayName = "ToggleGroupRoot";
 
 /**
@@ -167,7 +169,7 @@ ToggleGroupRoot.displayName = "ToggleGroupRoot";
  *
  * @throws if rendered outside a `ToggleGroup.Root`.
  */
-function ToggleGroupItem({
+export function ToggleGroupItem({
   value,
   disabled,
   asChild = false,
@@ -177,7 +179,7 @@ function ToggleGroupItem({
   children,
   ref,
   ...rest
-}: ToggleGroupItemProps) {
+}: ToggleGroupItemProps): ReactElement {
   const {
     value: groupValue,
     toggle,
@@ -250,9 +252,14 @@ function ToggleGroupItem({
   );
 }
 
+/** @internal */
 ToggleGroupItem.displayName = "ToggleGroupItem";
 
-type TToggleGroupCompound = typeof ToggleGroupRoot & {
+/**
+ * The shape of the exported `ToggleGroup` value — callable as
+ * `ToggleGroup.Root` and carrying `Root` and `Item` as static properties.
+ */
+export type TToggleGroupCompound = typeof ToggleGroupRoot & {
   Root: typeof ToggleGroupRoot;
   Item: typeof ToggleGroupItem;
 };
@@ -288,10 +295,13 @@ type TToggleGroupCompound = typeof ToggleGroupRoot & {
  * @see {@link ToggleGroupRoot} for type modes, state, and ARIA.
  * @see {@link ToggleGroupItem} for selection, roving tabindex, and keyboard navigation.
  */
-const ToggleGroupCompound: TToggleGroupCompound = Object.assign(ToggleGroupRoot, {
-  Root: ToggleGroupRoot,
-  Item: ToggleGroupItem,
-});
+const ToggleGroupCompound: TToggleGroupCompound = Object.assign(
+  ToggleGroupRoot,
+  {
+    Root: ToggleGroupRoot,
+    Item: ToggleGroupItem,
+  },
+);
 
 ToggleGroupCompound.displayName = "ToggleGroup";
 

package/src/ToggleGroup/ToggleGroupContext.ts

@@ -1,4 +1,4 @@
-import { createStrictContext } from "../utils";
+import { createStrictContext } from "../utils/index.ts";
 
 import { ToggleGroupContextValue } from "./types";
 

package/src/ToggleGroup/__tests__/ToggleGroup.reading-direction.test.tsx

@@ -1,7 +1,7 @@
 import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 
-import { DirectionProvider } from "../../DirectionProvider";
+import { DirectionProvider } from "../../DirectionProvider/index.ts";
 import { ToggleGroup } from "../ToggleGroup";
 
 describe("ToggleGroup reading direction", () => {

package/src/ToggleGroup/hooks/useToggleGroupRoot.ts

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, useState } from "react";
 
-import { useCollection, useControllableState } from "../../hooks";
+import { useCollection, useControllableState } from "../../hooks/index.ts";
 
 type ItemMeta = { element: HTMLButtonElement; disabled: boolean };
 

package/src/ToggleGroup/types.ts

@@ -1,6 +1,14 @@
 import { HTMLAttributes, ButtonHTMLAttributes, ReactNode, Ref } from "react";
 
-type ToggleGroupRootBaseProps = Omit<HTMLAttributes<HTMLDivElement>, "dir"> & {
+/**
+ * Mode-independent props shared by every `ToggleGroup.Root` variant —
+ * orientation, direction, `asChild`, children, and the ref. Combined with
+ * a mode-specific arm to form {@link ToggleGroupRootProps}.
+ */
+export type ToggleGroupRootBaseProps = Omit<
+  HTMLAttributes<HTMLDivElement>,
+  "dir"
+> & {
   orientation?: "horizontal" | "vertical";
   dir?: "ltr" | "rtl";
   asChild?: boolean;
@@ -8,34 +16,56 @@ type ToggleGroupRootBaseProps = Omit<HTMLAttributes<HTMLDivElement>, "dir"> & {
   ref?: Ref<HTMLDivElement>;
 };
 
-type SingleUncontrolledProps = {
+/**
+ * Single-selection mode, uncontrolled — at most one item pressed, with the
+ * initial value supplied via `defaultValue`.
+ */
+export type SingleUncontrolledProps = {
   type: "single";
   defaultValue?: string;
   value?: never;
   onValueChange?: never;
 };
 
-type SingleControlledProps = {
+/**
+ * Single-selection mode, controlled — the pressed value is owned by the
+ * caller via `value` / `onValueChange`.
+ */
+export type SingleControlledProps = {
   type: "single";
   value: string | undefined;
   onValueChange: (value: string | undefined) => void;
   defaultValue?: never;
 };
 
-type MultipleUncontrolledProps = {
+/**
+ * Multiple-selection mode, uncontrolled — items toggle independently, with
+ * the initial set supplied via `defaultValue`.
+ */
+export type MultipleUncontrolledProps = {
   type: "multiple";
   defaultValue?: string[];
   value?: never;
   onValueChange?: never;
 };
 
-type MultipleControlledProps = {
+/**
+ * Multiple-selection mode, controlled — the set of pressed values is owned
+ * by the caller via `value` / `onValueChange`.
+ */
+export type MultipleControlledProps = {
   type: "multiple";
   value: string[];
   onValueChange: (value: string[]) => void;
   defaultValue?: never;
 };
 
+/**
+ * Props for `ToggleGroup.Root`. Combines the shared
+ * {@link ToggleGroupRootBaseProps} with one mode-specific arm — single or
+ * multiple, controlled or uncontrolled — so the `value` / `defaultValue` /
+ * `onValueChange` shape is enforced per `type`.
+ */
 export type ToggleGroupRootProps = ToggleGroupRootBaseProps &
   (
     | SingleUncontrolledProps
@@ -44,6 +74,11 @@ export type ToggleGroupRootProps = ToggleGroupRootBaseProps &
     | MultipleControlledProps
   );
 
+/**
+ * Props for `ToggleGroup.Item` — a pressable toggle button. `value`
+ * identifies the item within the group; `asChild` merges the behaviour
+ * onto a custom child element.
+ */
 export type ToggleGroupItemProps = Omit<
   ButtonHTMLAttributes<HTMLButtonElement>,
   "type"
@@ -54,6 +89,11 @@ export type ToggleGroupItemProps = Omit<
   ref?: Ref<HTMLButtonElement>;
 };
 
+/**
+ * Context shared from `ToggleGroup.Root` to its items — the pressed
+ * values, the toggle action, item registration for roving tabindex, and
+ * the resolved orientation / direction.
+ */
 export type ToggleGroupContextValue = {
   value: string[];
   toggle: (itemValue: string) => void;

package/src/Tooltip/Tooltip.tsx

@@ -1,5 +1,7 @@
-import { Portal } from "../Portal";
-import { Slot, composeRefs } from "../Slot";
+import type { ReactElement } from "react";
+
+import { Portal } from "../Portal/index.ts";
+import { Slot, composeRefs } from "../Slot/index.ts";
 
 import {
   TooltipProvider,
@@ -11,7 +13,7 @@ import {
   useTooltipProvider,
   useTooltipRoot,
   useTooltipTrigger,
-} from "./hooks";
+} from "./hooks/index.ts";
 import type {
   TooltipArrowProps,
   TooltipContentProps,
@@ -33,12 +35,15 @@ import type {
  * </Tooltip.Provider>
  * ```
  */
-function TooltipProviderComponent({
+export function TooltipProviderComponent({
   children,
   delayDuration = 700,
   skipDelayDuration = 300,
-}: TooltipProviderProps) {
-  const { contextValue } = useTooltipProvider({ delayDuration, skipDelayDuration });
+}: TooltipProviderProps): ReactElement {
+  const { contextValue } = useTooltipProvider({
+    delayDuration,
+    skipDelayDuration,
+  });
   return (
     <TooltipProviderProvider value={contextValue}>
       {children}
@@ -46,6 +51,7 @@ function TooltipProviderComponent({
   );
 }
 
+/** @internal */
 TooltipProviderComponent.displayName = "TooltipProvider";
 
 /**
@@ -65,14 +71,14 @@ TooltipProviderComponent.displayName = "TooltipProvider";
  * </Tooltip.Root>
  * ```
  */
-function TooltipRoot({
+export function TooltipRoot({
   children,
   defaultOpen,
   open,
   onOpenChange,
   delayDuration,
   disableHoverableContent,
-}: TooltipRootProps) {
+}: TooltipRootProps): ReactElement {
   const { contextValue } = useTooltipRoot({
     defaultOpen,
     open,
@@ -84,6 +90,7 @@ function TooltipRoot({
   return <TooltipProvider value={contextValue}>{children}</TooltipProvider>;
 }
 
+/** @internal */
 TooltipRoot.displayName = "TooltipRoot";
 
 /**
@@ -104,7 +111,7 @@ TooltipRoot.displayName = "TooltipRoot";
  * </Tooltip.Trigger>
  * ```
  */
-function TooltipTrigger({
+export function TooltipTrigger({
   ref,
   asChild = false,
   onPointerEnter,
@@ -114,7 +121,7 @@ function TooltipTrigger({
   onKeyDown,
   type,
   ...rest
-}: TooltipTriggerProps) {
+}: TooltipTriggerProps): ReactElement {
   const { getTriggerProps } = useTooltipTrigger({
     onPointerEnter,
     onPointerLeave,
@@ -131,6 +138,7 @@ function TooltipTrigger({
   return <button ref={ref} type={type ?? "button"} {...getTriggerProps()} />;
 }
 
+/** @internal */
 TooltipTrigger.displayName = "TooltipTrigger";
 
 /**
@@ -149,7 +157,11 @@ TooltipTrigger.displayName = "TooltipTrigger";
  * </Tooltip.Portal>
  * ```
  */
-function TooltipPortal({ children, container, forceMount }: TooltipPortalProps) {
+export function TooltipPortal({
+  children,
+  container,
+  forceMount,
+}: TooltipPortalProps): ReactElement | null {
   const { open } = useTooltipContext();
 
   if (!open && !forceMount) return null;
@@ -157,6 +169,7 @@ function TooltipPortal({ children, container, forceMount }: TooltipPortalProps)
   return <Portal container={container}>{children}</Portal>;
 }
 
+/** @internal */
 TooltipPortal.displayName = "TooltipPortal";
 
 /**
@@ -187,7 +200,7 @@ TooltipPortal.displayName = "TooltipPortal";
  * </Tooltip.Content>
  * ```
  */
-function TooltipContent({
+export function TooltipContent({
   ref,
   forceMount,
   onEscapeKeyDown,
@@ -195,7 +208,7 @@ function TooltipContent({
   onPointerEnter,
   onPointerLeave,
   ...rest
-}: TooltipContentProps) {
+}: TooltipContentProps): ReactElement | null {
   const { open } = useTooltipContext();
   const { getContentProps, internalRef } = useTooltipContent({
     onEscapeKeyDown,
@@ -210,6 +223,7 @@ function TooltipContent({
   return <div ref={composeRefs(internalRef, ref)} {...getContentProps()} />;
 }
 
+/** @internal */
 TooltipContent.displayName = "TooltipContent";
 
 /**
@@ -227,7 +241,11 @@ TooltipContent.displayName = "TooltipContent";
  * </Tooltip.Content>
  * ```
  */
-function TooltipArrow({ ref, asChild = false, ...rest }: TooltipArrowProps) {
+export function TooltipArrow({
+  ref,
+  asChild = false,
+  ...rest
+}: TooltipArrowProps): ReactElement {
   if (asChild) {
     return <Slot ref={ref} {...rest} />;
   }
@@ -235,9 +253,11 @@ function TooltipArrow({ ref, asChild = false, ...rest }: TooltipArrowProps) {
   return <span ref={ref} {...rest} />;
 }
 
+/** @internal */
 TooltipArrow.displayName = "TooltipArrow";
 
-type TooltipCompound = typeof TooltipRoot & {
+/** Type of the {@link Tooltip} compound: the root callable plus its attached sub-components. */
+export type TooltipCompound = typeof TooltipRoot & {
   Provider: typeof TooltipProviderComponent;
   Root: typeof TooltipRoot;
   Trigger: typeof TooltipTrigger;
@@ -246,6 +266,16 @@ type TooltipCompound = typeof TooltipRoot & {
   Arrow: typeof TooltipArrow;
 };
 
+/**
+ * Headless, accessible **Tooltip** — a compound component implementing the
+ * [WAI-ARIA tooltip pattern](https://www.w3.org/WAI/ARIA/apg/patterns/tooltip/):
+ * a deferred, hoverable label anchored to a trigger, with a shared
+ * {@link Tooltip.Provider} governing open / skip delays across a group. Zero
+ * styles ship.
+ *
+ * The default export is the `Root`; sub-components are attached as static
+ * properties (`Tooltip.Provider`, `Tooltip.Trigger`, `Tooltip.Content`, …).
+ */
 const TooltipCompound: TooltipCompound = Object.assign(TooltipRoot, {
   Provider: TooltipProviderComponent,
   Root: TooltipRoot,
@@ -255,6 +285,7 @@ const TooltipCompound: TooltipCompound = Object.assign(TooltipRoot, {
   Arrow: TooltipArrow,
 });
 
+/** @internal */
 TooltipCompound.displayName = "Tooltip";
 
 export { TooltipCompound as Tooltip };

package/src/Tooltip/TooltipContext.ts

@@ -1,4 +1,4 @@
-import { createStrictContext } from "../utils";
+import { createStrictContext } from "../utils/index.ts";
 
 import type { TooltipContextValue, TooltipProviderContextValue } from "./types";
 

package/src/Tooltip/hooks/useTooltipContent.ts

@@ -1,6 +1,6 @@
 import { useEffect, useRef } from "react";
 
-import { composeEventHandlers } from "../../Slot";
+import { composeEventHandlers } from "../../Slot/index.ts";
 import { useTooltipContext } from "../TooltipContext";
 import type { TooltipContentProps } from "../types";
 

package/src/Tooltip/hooks/useTooltipRoot.ts

@@ -1,6 +1,6 @@
 import { useCallback, useId, useMemo, useRef } from "react";
 
-import { useControllableState } from "../../hooks";
+import { useControllableState } from "../../hooks/index.ts";
 import { useTooltipProviderContext } from "../TooltipContext";
 import type { TooltipContextValue, TooltipRootProps } from "../types";
 

package/src/Tooltip/hooks/useTooltipTrigger.ts

@@ -1,6 +1,6 @@
 import { KeyboardEvent } from "react";
 
-import { composeEventHandlers } from "../../Slot";
+import { composeEventHandlers } from "../../Slot/index.ts";
 import { useTooltipContext } from "../TooltipContext";
 import type { TooltipTriggerProps } from "../types";
 

package/src/Tooltip/index.ts

@@ -1 +1,2 @@
 export * from "./Tooltip";
+export * from "./types";