@cronus-ui/ui 0.6.0

package/dist/components/timeline.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { Children, cloneElement, forwardRef, isValidElement, } from "react";
+import { cn } from "../lib/cn.js";
+/* ------------------------------------------------------------------ *
+ * Timeline (root)
+ * ------------------------------------------------------------------ */
+/**
+ * Vertical activity / history feed. Renders an ordered list (`<ol>`) of
+ * {@link TimelineItem}s, each with a dot on a left rail and a connector line
+ * running down to the next event. Purely presentational and SSR-safe — there
+ * is no state or effects. Compose items inside it:
+ *
+ * ```tsx
+ * <Timeline>
+ *   <TimelineItem>
+ *     <TimelineDot tone="success" />
+ *     <TimelineContent>
+ *       <TimelineTitle>Order shipped</TimelineTitle>
+ *       <TimelineTime dateTime="2026-06-23">Jun 23</TimelineTime>
+ *       <TimelineDescription>Left the warehouse.</TimelineDescription>
+ *     </TimelineContent>
+ *   </TimelineItem>
+ * </Timeline>
+ * ```
+ */
+export const Timeline = forwardRef(({ className, children, ...props }, ref) => {
+    // Find the index of the last real `TimelineItem` so its trailing connector
+    // can be suppressed (the rail should stop at the final dot). Done here —
+    // synchronously, no effects — so it is correct on the first server render.
+    const items = Children.toArray(children);
+    let lastItemIndex = -1;
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const child = items[i];
+        if (isValidElement(child) && child.type === TimelineItem) {
+            lastItemIndex = i;
+            break;
+        }
+    }
+    return (_jsx("ol", { ref: ref, 
+        // biome-ignore lint/a11y/noRedundantRoles: Safari/VoiceOver drops list semantics from an <ol> styled `list-style: none`; the explicit role="list" is the documented workaround so the feed still reads as a list.
+        role: "list", "data-slot": "timeline", className: cn("flex w-full min-w-0 flex-col", className), ...props, children: items.map((child, index) => {
+            if (index === lastItemIndex &&
+                isValidElement(child) &&
+                // Respect an explicit `connector` on the item; only auto-suppress
+                // when the consumer left it to the default.
+                child.props.connector === undefined) {
+                return cloneElement(child, { connector: false });
+            }
+            return child;
+        }) }));
+});
+Timeline.displayName = "Timeline";
+/**
+ * A single event row. Lays out as a two-column grid — a left rail holding the
+ * {@link TimelineDot} plus the vertical {@link TimelineConnector}, and the
+ * content column. The connector is rendered automatically (no trailing line on
+ * the last item); pass `connector={false}` to drop it explicitly. Any
+ * {@link TimelineDot} child is hoisted onto the rail, so the common markup is
+ * just the dot followed by the content.
+ */
+export const TimelineItem = forwardRef(({ connector = true, className, children, ...props }, ref) => {
+    // Split the dot (rail) out from the rest (content column) so a consumer can
+    // write `<TimelineItem><TimelineDot/><TimelineContent/></TimelineItem>` and
+    // still get the correct two-column layout.
+    let dot = null;
+    const rest = [];
+    Children.forEach(children, (child) => {
+        if (dot === null && isValidElement(child) && child.type === TimelineDot) {
+            dot = child;
+            return;
+        }
+        rest.push(child);
+    });
+    return (_jsxs("li", { ref: ref, "data-slot": "timeline-item", className: cn("group/timeline-item relative grid grid-cols-[auto_minmax(0,1fr)] gap-x-3", 
+        // Reserve room for the next item's connector to reach this one, unless
+        // this is the last item (no trailing line).
+        connector ? "pb-6 last:pb-0" : "pb-0", className), ...props, children: [_jsxs("div", { "data-slot": "timeline-rail", className: "relative flex flex-col items-center", children: [dot ?? _jsx(TimelineDot, {}), connector ? _jsx(TimelineConnector, {}) : null] }), _jsx("div", { "data-slot": "timeline-body", className: "min-w-0 pt-0.5", children: rest })] }));
+});
+TimelineItem.displayName = "TimelineItem";
+/* ------------------------------------------------------------------ *
+ * Timeline dot
+ * ------------------------------------------------------------------ */
+const timelineDotVariants = cva(cn("relative z-10 flex shrink-0 items-center justify-center rounded-full", "[&_svg]:size-3 [&_svg]:shrink-0"), {
+    variants: {
+        tone: {
+            default: "bg-fg-tertiary",
+            primary: "bg-primary",
+            success: "bg-success",
+            warning: "bg-warning",
+            error: "bg-error",
+        },
+        // A bare dot is a small disc; with an icon it becomes a ring-bordered
+        // chip that holds the glyph.
+        withIcon: {
+            true: "size-7 border bg-surface-raised",
+            false: "size-2.5",
+        },
+    },
+    compoundVariants: [
+        { withIcon: true, tone: "default", className: "border-border text-fg-secondary" },
+        { withIcon: true, tone: "primary", className: "border-primary/30 text-primary" },
+        { withIcon: true, tone: "success", className: "border-success/30 text-success" },
+        { withIcon: true, tone: "warning", className: "border-warning/30 text-warning" },
+        { withIcon: true, tone: "error", className: "border-error/30 text-error" },
+    ],
+    defaultVariants: { tone: "default", withIcon: false },
+});
+/**
+ * The marker on a {@link TimelineItem}'s rail. Without an `icon` it is a small
+ * solid disc colored by `tone` (default = muted, primary/success/warning/error
+ * map to the matching token); with an `icon` it renders as a ring-bordered chip
+ * holding the glyph. Decorative styling only — the event's meaning lives in the
+ * adjacent {@link TimelineTitle}.
+ */
+export const TimelineDot = forwardRef(({ tone, icon, className, children, ...props }, ref) => {
+    const withIcon = icon != null;
+    return (_jsxs("span", { ref: ref, "data-slot": "timeline-dot", "data-tone": tone ?? "default", className: cn(timelineDotVariants({ tone, withIcon }), className), ...props, children: [icon, children] }));
+});
+TimelineDot.displayName = "TimelineDot";
+/* ------------------------------------------------------------------ *
+ * Timeline connector
+ * ------------------------------------------------------------------ */
+/**
+ * The vertical line linking one event to the next. Normally rendered for you by
+ * {@link TimelineItem} (which omits it on the last item); exposed for manual
+ * composition. Stretches to fill the rail below the dot and is decorative, so
+ * it is hidden from assistive tech.
+ */
+export const TimelineConnector = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, "data-slot": "timeline-connector", "aria-hidden": "true", className: cn("mt-1 w-px flex-1 rounded-full bg-border", className), ...props }));
+});
+TimelineConnector.displayName = "TimelineConnector";
+/* ------------------------------------------------------------------ *
+ * Timeline content
+ * ------------------------------------------------------------------ */
+/** Wrapper for an item's text column. Stacks the title, time and description. */
+export const TimelineContent = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, "data-slot": "timeline-content", className: cn("flex min-w-0 flex-col gap-1", className), ...props }));
+});
+TimelineContent.displayName = "TimelineContent";
+/* ------------------------------------------------------------------ *
+ * Timeline title / time / description
+ * ------------------------------------------------------------------ */
+/** The event's headline. */
+export const TimelineTitle = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, "data-slot": "timeline-title", className: cn("text-sm font-medium leading-none text-fg", className), ...props }));
+});
+TimelineTitle.displayName = "TimelineTitle";
+/**
+ * The muted timestamp for an event. Renders a real `<time>` element — pass
+ * `dateTime` for the machine-readable value when the visible text is a friendly
+ * label.
+ */
+export const TimelineTime = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("time", { ref: ref, "data-slot": "timeline-time", className: cn("text-xs leading-none text-fg-tertiary", className), ...props }));
+});
+TimelineTime.displayName = "TimelineTime";
+/** Optional supporting copy under the title. */
+export const TimelineDescription = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, "data-slot": "timeline-description", className: cn("text-sm text-fg-secondary", className), ...props }));
+});
+TimelineDescription.displayName = "TimelineDescription";
+export { timelineDotVariants };
+//# sourceMappingURL=timeline.js.map

package/dist/components/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import type { VariantProps } from "class-variance-authority";
+import { type ComponentPropsWithoutRef } from "react";
+export declare const ToggleGroup: import("react").ForwardRefExoticComponent<(ComponentPropsWithoutRef<import("react").ForwardRefExoticComponent<(ToggleGroupPrimitive.ToggleGroupSingleProps | ToggleGroupPrimitive.ToggleGroupMultipleProps) & import("react").RefAttributes<HTMLDivElement>>> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string>) & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToggleGroupItem: import("react").ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & import("react").RefAttributes<HTMLButtonElement>>;
+//# sourceMappingURL=toggle-group.d.ts.map

package/dist/components/toggle-group.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { createContext, forwardRef, useContext, } from "react";
+import { cn } from "../lib/cn.js";
+import { toggleVariants } from "./toggle.js";
+const ToggleGroupContext = createContext({
+    variant: "default",
+    size: "md",
+});
+export const ToggleGroup = forwardRef(({ className, variant, size, children, ...props }, ref) => {
+    return (_jsx(ToggleGroupPrimitive.Root, { ref: ref, "data-slot": "toggle-group", className: cn("flex items-center gap-1", className), ...props, children: _jsx(ToggleGroupContext.Provider, { value: { variant, size }, children: children }) }));
+});
+ToggleGroup.displayName = "ToggleGroup";
+export const ToggleGroupItem = forwardRef(({ className, variant, size, ...props }, ref) => {
+    const context = useContext(ToggleGroupContext);
+    return (_jsx(ToggleGroupPrimitive.Item, { ref: ref, "data-slot": "toggle-group-item", className: cn(toggleVariants({
+            variant: variant ?? context.variant,
+            size: size ?? context.size,
+        }), className), ...props }));
+});
+ToggleGroupItem.displayName = "ToggleGroupItem";
+//# sourceMappingURL=toggle-group.js.map

package/dist/components/toggle.d.ts

@@ -0,0 +1,12 @@
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { type VariantProps } from "class-variance-authority";
+import { type ComponentPropsWithoutRef } from "react";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ToggleProps extends ComponentPropsWithoutRef<typeof TogglePrimitive.Root>, VariantProps<typeof toggleVariants> {
+}
+export declare const Toggle: import("react").ForwardRefExoticComponent<ToggleProps & import("react").RefAttributes<HTMLButtonElement>>;
+export { toggleVariants };
+//# sourceMappingURL=toggle.d.ts.map

package/dist/components/toggle.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { cva } from "class-variance-authority";
+import { forwardRef } from "react";
+import { cn } from "../lib/cn.js";
+const toggleVariants = cva("inline-flex items-center justify-center gap-2 rounded-lg text-sm font-medium transition-colors outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-surface-base disabled:opacity-50 disabled:pointer-events-none data-[state=on]:bg-surface-overlay data-[state=on]:text-fg text-fg-secondary hover:bg-surface-overlay/60 [&_svg]:size-4 [&_svg]:shrink-0", {
+    variants: {
+        variant: {
+            default: "",
+            outline: "border border-border",
+        },
+        size: {
+            sm: "h-8 px-2",
+            md: "h-10 px-3",
+            lg: "h-11 px-4",
+        },
+    },
+    defaultVariants: { variant: "default", size: "md" },
+});
+export const Toggle = forwardRef(({ className, variant, size, ...props }, ref) => {
+    return (_jsx(TogglePrimitive.Root, { ref: ref, "data-slot": "toggle", className: cn(toggleVariants({ variant, size }), className), ...props }));
+});
+Toggle.displayName = "Toggle";
+export { toggleVariants };
+//# sourceMappingURL=toggle.js.map

package/dist/components/toolbar.d.ts

@@ -0,0 +1,14 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes } from "react";
+export interface ToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Layout orientation; also drives which arrow keys move focus. */
+    orientation?: "horizontal" | "vertical";
+}
+export declare const Toolbar: import("react").ForwardRefExoticComponent<ToolbarProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ToolbarButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Toggle-button pressed state; reflected as aria-pressed. */
+    pressed?: boolean;
+}
+export declare const ToolbarButton: import("react").ForwardRefExoticComponent<ToolbarButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const ToolbarSeparator: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToolbarGroup: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=toolbar.d.ts.map

package/dist/components/toolbar.js

@@ -0,0 +1,89 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useCallback, useEffect, useRef, } from "react";
+import { cn } from "../lib/cn.js";
+function getButtons(container) {
+    return Array.from(container.querySelectorAll("[data-slot=toolbar-button]:not([disabled])"));
+}
+function setTabbable(buttons, active) {
+    for (const button of buttons) {
+        button.tabIndex = button === active ? 0 : -1;
+    }
+}
+export const Toolbar = forwardRef(({ className, orientation = "horizontal", onKeyDown, ...props }, ref) => {
+    const innerRef = useRef(null);
+    const mergedRef = useCallback((node) => {
+        innerRef.current = node;
+        if (typeof ref === "function")
+            ref(node);
+        else if (ref)
+            ref.current = node;
+    }, [ref]);
+    // Initialize roving tabindex so exactly one button is tabbable.
+    useEffect(() => {
+        const container = innerRef.current;
+        if (!container)
+            return;
+        const buttons = getButtons(container);
+        const first = buttons[0];
+        if (!first)
+            return;
+        const alreadyTabbable = buttons.some((button) => button.tabIndex === 0);
+        if (!alreadyTabbable)
+            setTabbable(buttons, first);
+    });
+    const handleKeyDown = useCallback((event) => {
+        onKeyDown?.(event);
+        if (event.defaultPrevented)
+            return;
+        const container = event.currentTarget;
+        const buttons = getButtons(container);
+        if (buttons.length === 0)
+            return;
+        const nextKey = orientation === "vertical" ? "ArrowDown" : "ArrowRight";
+        const prevKey = orientation === "vertical" ? "ArrowUp" : "ArrowLeft";
+        const active = document.activeElement;
+        const currentIndex = active ? buttons.indexOf(active) : -1;
+        let nextIndex = null;
+        if (event.key === nextKey) {
+            nextIndex = currentIndex < 0 ? 0 : (currentIndex + 1) % buttons.length;
+        }
+        else if (event.key === prevKey) {
+            nextIndex =
+                currentIndex < 0
+                    ? buttons.length - 1
+                    : (currentIndex - 1 + buttons.length) % buttons.length;
+        }
+        else if (event.key === "Home") {
+            nextIndex = 0;
+        }
+        else if (event.key === "End") {
+            nextIndex = buttons.length - 1;
+        }
+        if (nextIndex === null)
+            return;
+        const target = buttons[nextIndex];
+        if (!target)
+            return;
+        event.preventDefault();
+        setTabbable(buttons, target);
+        target.focus();
+    }, [onKeyDown, orientation]);
+    return (_jsx("div", { ref: mergedRef, role: "toolbar", "data-slot": "toolbar", "aria-orientation": orientation, onKeyDown: handleKeyDown, className: cn("inline-flex items-center gap-1 rounded-lg border border-border bg-surface-raised p-1", orientation === "vertical" && "flex-col", className), ...props }));
+});
+Toolbar.displayName = "Toolbar";
+export const ToolbarButton = forwardRef(({ className, pressed, type, tabIndex, ...props }, ref) => {
+    return (_jsx("button", { ref: ref, type: type ?? "button", "data-slot": "toolbar-button", tabIndex: tabIndex ?? -1, "aria-pressed": pressed, "data-state": pressed ? "on" : undefined, className: cn("inline-flex h-8 min-w-8 items-center justify-center gap-1.5 rounded-md px-2 text-sm font-medium text-fg-secondary outline-none transition-colors hover:bg-surface-overlay hover:text-fg focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1 focus-visible:ring-offset-surface-base disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-surface-overlay data-[state=on]:text-fg [&_svg]:size-4 [&_svg]:shrink-0", className), ...props }));
+});
+ToolbarButton.displayName = "ToolbarButton";
+export const ToolbarSeparator = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, 
+        // biome-ignore lint/a11y/useAriaPropsForRole: a static (non-resizable) separator carries no aria-valuenow
+        role: "separator", "data-slot": "toolbar-separator", "aria-orientation": "vertical", className: cn("mx-1 h-5 w-px shrink-0 bg-border", className), ...props }));
+});
+ToolbarSeparator.displayName = "ToolbarSeparator";
+export const ToolbarGroup = forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("div", { ref: ref, role: "group", "data-slot": "toolbar-group", className: cn("inline-flex items-center gap-1", className), ...props }));
+});
+ToolbarGroup.displayName = "ToolbarGroup";
+//# sourceMappingURL=toolbar.js.map

package/dist/components/tooltip.d.ts

@@ -0,0 +1,29 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { type ComponentPropsWithoutRef } from "react";
+/**
+ * App-level tooltip config — `delayDuration` (default 200ms),
+ * `skipDelayDuration`, and `disableHoverableContent` — shared by every
+ * <Tooltip> beneath it. Mount one near the app root: cross-tooltip skip-delay
+ * (instant re-open when moving between triggers) only works through a shared
+ * provider. Use this component, not the raw Radix provider — <Tooltip> only
+ * detects this one.
+ */
+export declare const TooltipProvider: {
+    ({ delayDuration, ...props }: ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider>): import("react").JSX.Element;
+    displayName: string;
+};
+/**
+ * Radix Tooltip.Root with Cronus defaults. Under a <TooltipProvider> it renders
+ * bare, so the provider's config genuinely applies; per-tooltip
+ * `delayDuration` / `disableHoverableContent` props go to the Root and win
+ * over the provider's values. Without a provider it mounts a private fallback
+ * (200ms delay) so standalone usage still works — but standalone tooltips
+ * cannot share skip-delay, so prefer one app-level <TooltipProvider>.
+ */
+export declare const Tooltip: {
+    (props: ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>): import("react").JSX.Element;
+    displayName: string;
+};
+export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const TooltipContent: import("react").ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/components/tooltip.js

@@ -0,0 +1,48 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { createContext, forwardRef, useContext, } from "react";
+import { cn } from "../lib/cn.js";
+/** Cronus house default open delay (ms) — snappier than Radix's 700ms. */
+const DEFAULT_DELAY_DURATION = 200;
+/**
+ * Marks that a Cronus <TooltipProvider> is mounted above, so <Tooltip> renders
+ * a bare Radix Root instead of mounting its provider-less fallback. Radix
+ * providers do not inherit from ancestors — nesting one would silently reset
+ * the app-level config — so detection is the only way to honor both contracts.
+ */
+const HasTooltipProviderContext = createContext(false);
+/**
+ * App-level tooltip config — `delayDuration` (default 200ms),
+ * `skipDelayDuration`, and `disableHoverableContent` — shared by every
+ * <Tooltip> beneath it. Mount one near the app root: cross-tooltip skip-delay
+ * (instant re-open when moving between triggers) only works through a shared
+ * provider. Use this component, not the raw Radix provider — <Tooltip> only
+ * detects this one.
+ */
+export const TooltipProvider = ({ delayDuration = DEFAULT_DELAY_DURATION, ...props }) => {
+    return (_jsx(HasTooltipProviderContext.Provider, { value: true, children: _jsx(TooltipPrimitive.Provider, { "data-slot": "tooltip-provider", delayDuration: delayDuration, ...props }) }));
+};
+TooltipProvider.displayName = "TooltipProvider";
+/**
+ * Radix Tooltip.Root with Cronus defaults. Under a <TooltipProvider> it renders
+ * bare, so the provider's config genuinely applies; per-tooltip
+ * `delayDuration` / `disableHoverableContent` props go to the Root and win
+ * over the provider's values. Without a provider it mounts a private fallback
+ * (200ms delay) so standalone usage still works — but standalone tooltips
+ * cannot share skip-delay, so prefer one app-level <TooltipProvider>.
+ */
+export const Tooltip = (props) => {
+    const hasProvider = useContext(HasTooltipProviderContext);
+    const root = _jsx(TooltipPrimitive.Root, { "data-slot": "tooltip", ...props });
+    if (hasProvider)
+        return root;
+    return (_jsx(TooltipPrimitive.Provider, { delayDuration: DEFAULT_DELAY_DURATION, children: root }));
+};
+Tooltip.displayName = "Tooltip";
+export const TooltipTrigger = TooltipPrimitive.Trigger;
+export const TooltipContent = forwardRef(({ className, sideOffset = 4, ...props }, ref) => {
+    return (_jsx(TooltipPrimitive.Portal, { children: _jsx(TooltipPrimitive.Content, { ref: ref, "data-slot": "tooltip-content", sideOffset: sideOffset, className: cn("z-50 overflow-hidden rounded-md border border-border bg-surface-floating px-2.5 py-1 text-xs text-fg shadow-md data-[state=open]:animate-[cronus-pop-in_150ms_var(--ease-out-quart)_both] data-[state=closed]:animate-[cronus-pop-out_110ms_var(--ease-out-quart)_both]", className), ...props }) }));
+});
+TooltipContent.displayName = "TooltipContent";
+//# sourceMappingURL=tooltip.js.map

package/dist/components/tree-view.d.ts

@@ -0,0 +1,45 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/**
+ * A single node in a {@link TreeView}. Branches are nodes with a `children`
+ * array (even an empty one renders an expandable branch); leaves omit it.
+ */
+export interface TreeNode {
+    /** Stable, unique id used for selection + expansion state. */
+    id: string;
+    /** Visible label (text and/or inline markup). */
+    label: ReactNode;
+    /** Optional leading icon rendered before the label. */
+    icon?: ReactNode;
+    /** Child nodes. Presence (including `[]`) marks the node as a branch. */
+    children?: TreeNode[];
+    /** Disable selection + skip the node in keyboard navigation. */
+    disabled?: boolean;
+}
+export interface TreeViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** The hierarchy to render. */
+    data: TreeNode[];
+    /** Controlled selected node id. */
+    value?: string;
+    /** Initial selected node id for the uncontrolled case. */
+    defaultValue?: string;
+    /** Called when the selection changes (controlled or not). */
+    onValueChange?: (id: string) => void;
+    /** Controlled set of expanded branch ids. */
+    expandedIds?: string[];
+    /** Initial expanded branch ids for the uncontrolled case. */
+    defaultExpandedIds?: string[];
+    /** Called whenever the expanded set changes (controlled or not). */
+    onExpandedChange?: (ids: string[]) => void;
+    /** Accessible label for the tree landmark. */
+    "aria-label"?: string;
+}
+/**
+ * A hierarchical, accessible tree (file-tree style). Data-driven via the
+ * `data` prop, with controllable selection (`value`) and expansion
+ * (`expandedIds`). Implements the WAI-ARIA tree pattern: `role="tree"` root,
+ * `role="treeitem"` nodes with `aria-expanded`/`aria-selected`/`aria-level`,
+ * `role="group"` child lists, a single roving tab stop, and full keyboard
+ * navigation. SSR-safe (no DOM reads during render).
+ */
+export declare const TreeView: import("react").ForwardRefExoticComponent<TreeViewProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=tree-view.d.ts.map