@wow-two-beta/ui 0.0.3 → 0.0.5

package/dist/forms/index.d.ts

@@ -1,2 +1,218 @@
+import * as react from 'react';
+import { LabelHTMLAttributes, ComponentPropsWithoutRef, FieldsetHTMLAttributes, HTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+import * as tailwind_variants_dist_config_js from 'tailwind-variants/dist/config.js';
 
-export {  }
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    /** Show a `*` indicator. Auto-derived from `FormControl.isRequired` when present. */
+    required?: boolean;
+}
+/**
+ * `<label>` wired to `FormControl` context — when wrapped in a `FormControl`
+ * it auto-fills `htmlFor` and `id`. Standalone use: pass `htmlFor` directly.
+ */
+declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLLabelElement>>;
+
+type FormHelperTextProps = ComponentPropsWithoutRef<'p'>;
+/**
+ * Helper / hint text below a form control. Reads `helperId` from
+ * `FormControl` so the input can reference it via `aria-describedby`.
+ */
+declare const FormHelperText: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+type FormErrorMessageProps = ComponentPropsWithoutRef<'p'>;
+/**
+ * Error copy under a form control. Renders only when the surrounding
+ * `FormControl` is `isInvalid`. `id={errorId}` for `aria-describedby` wiring.
+ */
+declare const FormErrorMessage: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+type FieldsetProps = FieldsetHTMLAttributes<HTMLFieldSetElement>;
+/**
+ * Semantic `<fieldset>` for grouping related controls. Pair with `Legend`
+ * for the group label.
+ */
+declare const Fieldset: react.ForwardRefExoticComponent<FieldsetProps & react.RefAttributes<HTMLFieldSetElement>>;
+
+type LegendProps = HTMLAttributes<HTMLLegendElement>;
+/**
+ * `<legend>` styled to match `Label`. Pair with `Fieldset`.
+ */
+declare const Legend: react.ForwardRefExoticComponent<LegendProps & react.RefAttributes<HTMLLegendElement>>;
+
+declare const inputBaseVariants: tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}, undefined, "flex w-full rounded-md border bg-white text-neutral-900 placeholder:text-neutral-400 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-brand-500 disabled:cursor-not-allowed disabled:opacity-60 read-only:bg-neutral-50", tailwind_variants_dist_config_js.TVConfig<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}, {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}>, {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}, undefined, "flex w-full rounded-md border bg-white text-neutral-900 placeholder:text-neutral-400 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-brand-500 disabled:cursor-not-allowed disabled:opacity-60 read-only:bg-neutral-50", tailwind_variants_dist_config_js.TVConfig<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}, {
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    state: {
+        default: string;
+        invalid: string;
+    };
+}>, unknown, unknown, undefined>>;
+type InputBaseVariants = VariantProps<typeof inputBaseVariants>;
+
+interface TextInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+}
+/**
+ * Single-line text input. For email/tel/url/number/password/search variants
+ * use the dedicated input component (each carries only the props/buttons it
+ * actually needs).
+ */
+declare const TextInput: react.ForwardRefExoticComponent<TextInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface EmailInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+}
+/** `<input type="email">` with sensible defaults (autocomplete, inputmode). */
+declare const EmailInput: react.ForwardRefExoticComponent<EmailInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TelInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+}
+/** `<input type="tel">` with `inputmode="tel"` and `autocomplete="tel"`. */
+declare const TelInput: react.ForwardRefExoticComponent<TelInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface UrlInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+}
+/** `<input type="url">` with `inputmode="url"` and `autocomplete="url"`. */
+declare const UrlInput: react.ForwardRefExoticComponent<UrlInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface NumberInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+    step?: number;
+}
+/**
+ * Numeric input with stepper buttons. Steppers are raw `<button>` elements
+ * (not `IconButton`) to keep the strict atom rule.
+ */
+declare const NumberInput: react.ForwardRefExoticComponent<NumberInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface PasswordInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+    /** Whether to render the visibility-toggle button. Default true. */
+    toggleable?: boolean;
+}
+/**
+ * Password input with optional visibility toggle. Toggle is a raw `<button>`
+ * to keep the strict atom rule.
+ */
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'>, InputBaseVariants {
+    /** Show a clear (×) button when the input has a value. Default true. */
+    clearable?: boolean;
+    onClear?: () => void;
+}
+/**
+ * Search input with leading search icon and optional clear button.
+ * Buttons are raw `<button>` elements to keep the strict atom rule.
+ */
+declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'>, InputBaseVariants {
+}
+/**
+ * Multi-line text input. Inherits the input visual base. For autosize, pair
+ * with a sibling-domain hook in v1 — kept simple at L3.
+ */
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    size?: 'sm' | 'md' | 'lg';
+    /** Tristate visual — input is `checked={false}` but rendered as a dash. */
+    indeterminate?: boolean;
+}
+/**
+ * Native checkbox with custom visual. Renders the input visually hidden but
+ * accessible — wrap in a `<label>` (or pair with `Label` via `FormControl`).
+ */
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    size?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Native radio button with custom visual. Use multiple with the same `name`
+ * to form a mutually exclusive group; for arrow-key nav, wrap in
+ * `RadioGroup` (L4).
+ */
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    size?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Toggle switch — native checkbox styled as an iOS-style track + thumb.
+ * Strict atom: no built-in label; pair via `FormControl` or wrap manually.
+ */
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    size?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Single-value range slider — native `<input type="range">` styled across
+ * browsers. Multi-thumb / range slider lives at L5.
+ */
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+export { Checkbox, type CheckboxProps, EmailInput, type EmailInputProps, Fieldset, type FieldsetProps, FormErrorMessage, type FormErrorMessageProps, FormHelperText, type FormHelperTextProps, Label, type LabelProps, Legend, type LegendProps, NumberInput, type NumberInputProps, PasswordInput, type PasswordInputProps, Radio, type RadioProps, SearchInput, type SearchInputProps, Slider, type SliderProps, Switch, type SwitchProps, TelInput, type TelInputProps, TextInput, type TextInputProps, Textarea, type TextareaProps, UrlInput, type UrlInputProps };

package/dist/forms/index.js

@@ -1,3 +1,10 @@
-import '../chunk-YP4MAZRQ.js';
+export { Checkbox, EmailInput, Fieldset, FormErrorMessage, FormHelperText, Label, Legend, NumberInput, PasswordInput, Radio, SearchInput, Slider, Switch, TelInput, TextInput, Textarea, UrlInput } from '../chunk-KSJE3JAI.js';
+import '../chunk-TDX22OWF.js';
+import '../chunk-Q27NAHVB.js';
+import '../chunk-JTJEI6MF.js';
+import '../chunk-BMBIZLO4.js';
+import '../chunk-DN7WBRIV.js';
+import '../chunk-KZ4VFY2T.js';
+import '../chunk-PZ5AY32C.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/hooks/index.d.ts

@@ -1,5 +1,2 @@
-declare namespace index {
-  export {  };
-}
-
-export { index as i };
+export { D as DisclosureControls, u as useControlled, a as useDisclosure, b as useEscape, c as useEventListener, d as useFocusTrap, e as useId, f as useMediaQuery, g as useOutsideClick, h as useResizeObserver, j as useScrollLock } from '../index-PAuwodyY.js';
+import 'react';

package/dist/hooks/index.js

@@ -1,3 +1,6 @@
-import '../chunk-CTVGU35H.js';
+export { useControlled, useDisclosure, useEscape, useEventListener, useFocusTrap, useMediaQuery, useOutsideClick, useResizeObserver } from '../chunk-6NYTRHP7.js';
+export { useScrollLock } from '../chunk-77WSI427.js';
+export { useId } from '../chunk-JTJEI6MF.js';
+import '../chunk-PZ5AY32C.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/icons/index.d.ts

@@ -1,5 +1,2 @@
-declare namespace index {
-  export {  };
-}
-
-export { index as i };
+export { I as Icon, a as IconAdapter, b as IconAdapterProps, c as IconProps } from '../index-CEAM9LLM.js';
+import 'react';

package/dist/icons/index.js

@@ -1,3 +1,5 @@
-import '../chunk-U4JXXIE2.js';
+export { Icon } from '../chunk-TDX22OWF.js';
+import '../chunk-KZ4VFY2T.js';
+import '../chunk-PZ5AY32C.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index-Bk6CuDNT.d.ts

@@ -0,0 +1,247 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ReactElement, KeyboardEvent as KeyboardEvent$1, Context } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _radix_ui_react_focus_scope from '@radix-ui/react-focus-scope';
+import { FocusScope as FocusScope$1 } from '@radix-ui/react-focus-scope';
+import { Placement } from '@floating-ui/react';
+
+interface SlotProps extends HTMLAttributes<HTMLElement> {
+    children?: React.ReactNode;
+}
+/**
+ * Polymorphic slot — renders the single child element with the parent's props
+ * merged in (className concatenated, handlers chained, refs composed).
+ *
+ * Use to enable an `asChild` API on a component:
+ * ```tsx
+ * <Button asChild><a href="/x">Open</a></Button>
+ * ```
+ */
+declare const Slot: react.ForwardRefExoticComponent<SlotProps & react.RefAttributes<HTMLElement>>;
+
+interface PortalProps {
+    children: ReactNode;
+    /** Container to render into. Default: `document.body`. */
+    container?: HTMLElement | null;
+    /** Optional named layer — sets `data-portal-name` on the wrapper. */
+    name?: string;
+}
+/**
+ * Render children into a different DOM node (default `document.body`).
+ * Client-only — package targets pure CSR consumers.
+ */
+declare function Portal({ children, container, name }: PortalProps): ReactNode;
+
+type VisuallyHiddenProps = HTMLAttributes<HTMLSpanElement>;
+/**
+ * Visually hidden span — content removed from the visual layout but still
+ * announced to screen readers. Use for accessible labels on icon-only
+ * affordances and live-region announcements.
+ */
+declare const VisuallyHidden: react.ForwardRefExoticComponent<VisuallyHiddenProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface PresenceProps {
+    /** Whether the content should be present. Toggle false to trigger exit. */
+    present: boolean;
+    /** Single React element child — receives `ref` and `data-state` ("open" | "closed"). */
+    children: ReactElement;
+}
+/**
+ * Defer unmount until the child's exit animation/transition finishes.
+ * Pass `present={false}` to start the exit; the child stays mounted with
+ * `data-state="closed"` until `animationend`/`transitionend` fires.
+ */
+declare function Presence({ present, children }: PresenceProps): ReactElement | null;
+
+type Direction = 'ltr' | 'rtl';
+interface DirectionProviderProps {
+    dir: Direction;
+    children: ReactNode;
+}
+/**
+ * Provide reading direction to descendants. Components that mirror in RTL
+ * (Tabs arrow keys, Slider, Carousel, etc.) read this via `useDirection()`.
+ */
+declare function DirectionProvider({ dir, children }: DirectionProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDirection(): Direction;
+
+interface AccessibleIconProps {
+    /** Required accessible label for the icon. */
+    label: string;
+    /** Single icon element — will receive `aria-hidden` so SR reads only the label. */
+    children: ReactElement;
+}
+/**
+ * Wrap an icon-only element with an accessible label. The icon is hidden
+ * from assistive tech and a `VisuallyHidden` sibling provides the label.
+ */
+declare function AccessibleIcon({ label, children }: AccessibleIconProps): react_jsx_runtime.JSX.Element;
+
+type FocusScopeProps = React.ComponentProps<typeof FocusScope$1>;
+/**
+ * Trap focus within children. On unmount, returns focus to the previously
+ * focused element. Pass `loop` to wrap Tab navigation; `trapped` to enable
+ * the trap (default true while mounted).
+ *
+ * Wraps `@radix-ui/react-focus-scope` — battle-tested implementation.
+ */
+declare const FocusScope: react.ForwardRefExoticComponent<_radix_ui_react_focus_scope.FocusScopeProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DismissableLayerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Called when Escape is pressed and this is the topmost layer. */
+    onEscape?: (event: KeyboardEvent) => void;
+    /** Called when a pointerdown lands outside this layer's DOM and this is topmost. */
+    onOutsidePointerDown?: (event: PointerEvent) => void;
+    /** Disable the Escape listener for this layer. */
+    disableEscape?: boolean;
+    /** Disable the outside-pointer-down listener for this layer. */
+    disableOutsideClick?: boolean;
+}
+/**
+ * Stack-aware dismissal layer. Multiple layers may stack (modal > popover);
+ * only the topmost reacts to Escape / outside click. Used as the base of
+ * Modal, Drawer, Popover, Menu, HoverCard, ContextMenu.
+ */
+declare const DismissableLayer: react.ForwardRefExoticComponent<DismissableLayerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface AnchoredPositionerProps extends HTMLAttributes<HTMLDivElement> {
+    /** The element the floating layer should be anchored to. */
+    anchor: HTMLElement | null;
+    /** Floating UI placement. Default `bottom`. */
+    placement?: Placement;
+    /** Distance between anchor and floating element in px. Default 8. */
+    offset?: number;
+    /** Render the floating element only when open. */
+    open?: boolean;
+    children: ReactNode;
+}
+/**
+ * Position children relative to an anchor element using Floating UI.
+ * Auto-flips and shifts to stay in viewport. Use as the positioning surface
+ * for Tooltip, Popover, Menu, HoverCard.
+ */
+declare const AnchoredPositioner: react.ForwardRefExoticComponent<AnchoredPositionerProps & react.RefAttributes<HTMLDivElement>>;
+
+type Orientation = 'horizontal' | 'vertical' | 'both';
+interface RovingFocusGroupProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: Orientation;
+    loop?: boolean;
+    children: ReactNode;
+}
+/**
+ * Provide arrow-key navigation for a group of focusable children. Children
+ * call `useRovingFocusItem()` to register and receive `tabIndex` / event
+ * handlers. Used by Tabs, ToggleGroup, RadioGroup, Menu.
+ */
+declare function RovingFocusGroup({ orientation, loop, children, ...props }: RovingFocusGroupProps): react_jsx_runtime.JSX.Element;
+interface UseRovingFocusItemReturn {
+    ref: (node: HTMLElement | null) => void;
+    tabIndex: 0 | -1;
+    onKeyDown: (event: KeyboardEvent$1) => void;
+    onFocus: () => void;
+    'data-roving-focus-item': boolean;
+}
+/**
+ * Inside a `RovingFocusGroup`, returns props to spread onto a focusable item.
+ * Outside, returns inert props (tabIndex 0).
+ */
+declare function useRovingFocusItem(): UseRovingFocusItemReturn;
+
+interface CollectionContextValue<T> {
+    items: T[];
+    register: (item: T) => void;
+    unregister: (item: T) => void;
+}
+/**
+ * Factory for a typed children-registry context. Compound components
+ * (Menu, Tabs, Listbox) use this so the parent can iterate ordered children
+ * without prop-drilling.
+ */
+declare function createCollection<T>(): {
+    Provider: (props: {
+        children: ReactNode;
+    }) => ReactNode;
+    useCollection: () => CollectionContextValue<T>;
+    Context: Context<CollectionContextValue<T> | null>;
+};
+
+interface FormControlContextValue {
+    id: string;
+    labelId: string;
+    helperId: string;
+    errorId: string;
+    isInvalid: boolean;
+    isDisabled: boolean;
+    isRequired: boolean;
+    isReadOnly: boolean;
+}
+interface FormControlProviderProps {
+    /** Override the auto-generated id (also used as control's `id`). */
+    id?: string;
+    isInvalid?: boolean;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    isReadOnly?: boolean;
+    children: ReactNode;
+}
+/**
+ * Wires Label ↔ control ↔ HelperText/ErrorMessage via stable IDs and shared
+ * state flags. Used by `FormField` (L4) — atoms (Input, Label, etc.) read
+ * via `useFormControl()` to get the right `id`/`htmlFor`/`aria-describedby`.
+ */
+declare function FormControlProvider({ id: providedId, isInvalid, isDisabled, isRequired, isReadOnly, children, }: FormControlProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Read the surrounding form-control context. Returns `null` when used
+ * outside a provider — atoms gracefully degrade to standalone mode.
+ */
+declare function useFormControl(): FormControlContextValue | null;
+
+interface ScrollLockProviderProps {
+    enabled?: boolean;
+    children: ReactNode;
+}
+/**
+ * Component wrapper around `useScrollLock` — handy when scroll lock should
+ * follow a child's mount lifecycle (e.g. inside a Modal's portal).
+ * Multiple wrappers stack; lock releases when the count reaches zero.
+ */
+declare function ScrollLockProvider({ enabled, children }: ScrollLockProviderProps): react_jsx_runtime.JSX.Element;
+
+declare const index_AccessibleIcon: typeof AccessibleIcon;
+type index_AccessibleIconProps = AccessibleIconProps;
+declare const index_AnchoredPositioner: typeof AnchoredPositioner;
+type index_AnchoredPositionerProps = AnchoredPositionerProps;
+type index_CollectionContextValue<T> = CollectionContextValue<T>;
+type index_Direction = Direction;
+declare const index_DirectionProvider: typeof DirectionProvider;
+type index_DirectionProviderProps = DirectionProviderProps;
+declare const index_DismissableLayer: typeof DismissableLayer;
+type index_DismissableLayerProps = DismissableLayerProps;
+declare const index_FocusScope: typeof FocusScope;
+type index_FocusScopeProps = FocusScopeProps;
+type index_FormControlContextValue = FormControlContextValue;
+declare const index_FormControlProvider: typeof FormControlProvider;
+type index_FormControlProviderProps = FormControlProviderProps;
+type index_Orientation = Orientation;
+declare const index_Portal: typeof Portal;
+type index_PortalProps = PortalProps;
+declare const index_Presence: typeof Presence;
+type index_PresenceProps = PresenceProps;
+declare const index_RovingFocusGroup: typeof RovingFocusGroup;
+type index_RovingFocusGroupProps = RovingFocusGroupProps;
+declare const index_ScrollLockProvider: typeof ScrollLockProvider;
+type index_ScrollLockProviderProps = ScrollLockProviderProps;
+declare const index_Slot: typeof Slot;
+type index_SlotProps = SlotProps;
+type index_UseRovingFocusItemReturn = UseRovingFocusItemReturn;
+declare const index_VisuallyHidden: typeof VisuallyHidden;
+type index_VisuallyHiddenProps = VisuallyHiddenProps;
+declare const index_createCollection: typeof createCollection;
+declare const index_useDirection: typeof useDirection;
+declare const index_useFormControl: typeof useFormControl;
+declare const index_useRovingFocusItem: typeof useRovingFocusItem;
+declare namespace index {
+  export { index_AccessibleIcon as AccessibleIcon, type index_AccessibleIconProps as AccessibleIconProps, index_AnchoredPositioner as AnchoredPositioner, type index_AnchoredPositionerProps as AnchoredPositionerProps, type index_CollectionContextValue as CollectionContextValue, type index_Direction as Direction, index_DirectionProvider as DirectionProvider, type index_DirectionProviderProps as DirectionProviderProps, index_DismissableLayer as DismissableLayer, type index_DismissableLayerProps as DismissableLayerProps, index_FocusScope as FocusScope, type index_FocusScopeProps as FocusScopeProps, type index_FormControlContextValue as FormControlContextValue, index_FormControlProvider as FormControlProvider, type index_FormControlProviderProps as FormControlProviderProps, type index_Orientation as Orientation, index_Portal as Portal, type index_PortalProps as PortalProps, index_Presence as Presence, type index_PresenceProps as PresenceProps, index_RovingFocusGroup as RovingFocusGroup, type index_RovingFocusGroupProps as RovingFocusGroupProps, index_ScrollLockProvider as ScrollLockProvider, type index_ScrollLockProviderProps as ScrollLockProviderProps, index_Slot as Slot, type index_SlotProps as SlotProps, type index_UseRovingFocusItemReturn as UseRovingFocusItemReturn, index_VisuallyHidden as VisuallyHidden, type index_VisuallyHiddenProps as VisuallyHiddenProps, index_createCollection as createCollection, index_useDirection as useDirection, index_useFormControl as useFormControl, index_useRovingFocusItem as useRovingFocusItem };
+}
+
+export { AccessibleIcon as A, type CollectionContextValue as C, type Direction as D, FocusScope as F, type Orientation as O, Portal as P, RovingFocusGroup as R, ScrollLockProvider as S, type UseRovingFocusItemReturn as U, VisuallyHidden as V, type AccessibleIconProps as a, AnchoredPositioner as b, type AnchoredPositionerProps as c, DirectionProvider as d, type DirectionProviderProps as e, DismissableLayer as f, type DismissableLayerProps as g, type FocusScopeProps as h, index as i, type FormControlContextValue as j, FormControlProvider as k, type FormControlProviderProps as l, type PortalProps as m, Presence as n, type PresenceProps as o, type RovingFocusGroupProps as p, type ScrollLockProviderProps as q, Slot as r, type SlotProps as s, type VisuallyHiddenProps as t, createCollection as u, useDirection as v, useFormControl as w, useRovingFocusItem as x };

package/dist/index-C0IDphm_.d.ts

@@ -0,0 +1,61 @@
+import { ClassValue } from 'clsx';
+import { Ref, SyntheticEvent, ElementType, ComponentPropsWithRef, PropsWithoutRef } from 'react';
+import { VariantProps, tv } from 'tailwind-variants';
+
+/**
+ * Conditional class composer with Tailwind conflict-resolution.
+ * Use anywhere you'd otherwise concatenate class strings.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+type PossibleRef<T> = Ref<T> | undefined;
+/**
+ * Merge multiple React refs (callback or object) into a single callback ref.
+ * Use to forward a ref while also keeping a local ref to the same node.
+ */
+declare function composeRefs<T>(...refs: PossibleRef<T>[]): (node: T | null) => void;
+
+/**
+ * Chain two event handlers. The first handler runs, then the second — unless
+ * the first called `event.preventDefault()`, in which case the second is skipped.
+ * Use when overriding a default handler from a parent while still allowing
+ * the consumer to provide their own.
+ */
+declare function composeEventHandlers<E extends SyntheticEvent>(theirHandler: ((event: E) => void) | undefined, ourHandler: (event: E) => void, { checkForDefaultPrevented }?: {
+    checkForDefaultPrevented?: boolean;
+}): (event: E) => void;
+
+/**
+ * Returns `""` when the condition is true, `undefined` otherwise.
+ * Use for boolean `data-*` attributes — React strips the attr when value is undefined,
+ * so the DOM cleanly toggles `data-state` rather than `data-state="false"`.
+ */
+declare function dataAttr(condition: boolean | undefined): '' | undefined;
+
+/**
+ * Props for a polymorphic component (`as` prop). Use only when a component
+ * meaningfully changes its DOM element — most components should use `Slot`/`asChild`
+ * instead.
+ */
+type PolymorphicProps<C extends ElementType, P = object> = P & Omit<ComponentPropsWithRef<C>, keyof P | 'as'> & {
+    as?: C;
+};
+type PolymorphicPropsWithoutRef<C extends ElementType, P = object> = P & Omit<PropsWithoutRef<ComponentPropsWithRef<C>>, keyof P | 'as'> & {
+    as?: C;
+};
+type PolymorphicRef<C extends ElementType> = ComponentPropsWithRef<C>['ref'];
+
+type index_PolymorphicProps<C extends ElementType, P = object> = PolymorphicProps<C, P>;
+type index_PolymorphicPropsWithoutRef<C extends ElementType, P = object> = PolymorphicPropsWithoutRef<C, P>;
+type index_PolymorphicRef<C extends ElementType> = PolymorphicRef<C>;
+declare const index_VariantProps: typeof VariantProps;
+declare const index_cn: typeof cn;
+declare const index_composeEventHandlers: typeof composeEventHandlers;
+declare const index_composeRefs: typeof composeRefs;
+declare const index_dataAttr: typeof dataAttr;
+declare const index_tv: typeof tv;
+declare namespace index {
+  export { type index_PolymorphicProps as PolymorphicProps, type index_PolymorphicPropsWithoutRef as PolymorphicPropsWithoutRef, type index_PolymorphicRef as PolymorphicRef, index_VariantProps as VariantProps, index_cn as cn, index_composeEventHandlers as composeEventHandlers, index_composeRefs as composeRefs, index_dataAttr as dataAttr, index_tv as tv };
+}
+
+export { type PolymorphicProps as P, type PolymorphicPropsWithoutRef as a, type PolymorphicRef as b, cn as c, composeEventHandlers as d, composeRefs as e, dataAttr as f, index as i };

package/dist/index-CEAM9LLM.d.ts

@@ -0,0 +1,37 @@
+import * as react from 'react';
+import { SVGProps, ComponentType } from 'react';
+
+interface IconAdapterProps extends SVGProps<SVGSVGElement> {
+    size?: number | string;
+}
+type IconAdapter = ComponentType<IconAdapterProps>;
+interface IconProps extends Omit<SVGProps<SVGSVGElement>, 'aria-hidden'> {
+    /** Icon component — pass a `lucide-react` icon, custom SVG component, or any matching shape. */
+    icon: IconAdapter;
+    /** Pixel size of the rendered SVG. Default 20. */
+    size?: number | string;
+    /**
+     * Provide an aria-label when the icon stands alone (decorative siblings
+     * should pass it via parent). Sets `role="img"` and unhides from AT.
+     * Without it, the icon is `aria-hidden` and decorative.
+     */
+    'aria-label'?: string;
+}
+/**
+ * Generic icon wrapper. Accepts any icon component matching the lucide-react
+ * shape (`{ size, color, className, ...svgProps }`).
+ *
+ * - Without `aria-label` → decorative, `aria-hidden`.
+ * - With `aria-label` → semantic, `role="img"`.
+ */
+declare const Icon: react.ForwardRefExoticComponent<Omit<IconProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const index_Icon: typeof Icon;
+type index_IconAdapter = IconAdapter;
+type index_IconAdapterProps = IconAdapterProps;
+type index_IconProps = IconProps;
+declare namespace index {
+  export { index_Icon as Icon, type index_IconAdapter as IconAdapter, type index_IconAdapterProps as IconAdapterProps, type index_IconProps as IconProps };
+}
+
+export { Icon as I, type IconAdapter as a, type IconAdapterProps as b, type IconProps as c, index as i };