@wow-two-beta/ui 0.0.2 → 0.0.4

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

package/dist/index-PAuwodyY.d.ts

@@ -0,0 +1,103 @@
+import { RefObject } from 'react';
+
+/**
+ * Wraps React 19's `useId`. Optionally accepts a stable prefix so generated
+ * IDs are easier to spot in DevTools (e.g. `useId('checkbox')` → `:r2:-checkbox`).
+ */
+declare function useId(prefix?: string): string;
+
+interface UseControlledOptions<T> {
+    controlled: T | undefined;
+    default: T;
+    onChange?: (value: T) => void;
+}
+/**
+ * Standard controlled/uncontrolled pattern.
+ *
+ * - If `controlled` is defined, the component is controlled — internal state is
+ *   ignored, `setValue` only fires `onChange`.
+ * - Otherwise the component owns its state, `setValue` updates it, and `onChange`
+ *   still fires for consumers that want to observe changes.
+ */
+declare function useControlled<T>({ controlled, default: defaultValue, onChange, }: UseControlledOptions<T>): [T, (value: T) => void];
+
+interface DisclosureControls {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setOpen: (next: boolean) => void;
+}
+/**
+ * Minimal open/close state with stable callbacks. The standard backbone for
+ * Modal, Drawer, Popover, Menu, Accordion, etc. Use `useControlled` underneath
+ * when the consumer may also pass a controlled `open` prop.
+ */
+declare function useDisclosure(initial?: boolean): DisclosureControls;
+
+type Target = Window | Document | HTMLElement | null;
+/**
+ * Add an event listener and clean it up automatically. Handler is read from
+ * a ref so consumers don't need to memoize it.
+ */
+declare function useEventListener<K extends string>(event: K, handler: (event: Event) => void, target?: Target, options?: boolean | AddEventListenerOptions): void;
+
+/**
+ * Fire `handler` when the user clicks outside any of the provided refs.
+ * Uses `pointerdown` so it fires before focus shifts (avoids losing focus
+ * inside an overlay before a click on a trigger registers).
+ */
+declare function useOutsideClick(refs: RefObject<HTMLElement | null> | RefObject<HTMLElement | null>[], handler: (event: PointerEvent) => void, enabled?: boolean): void;
+
+/**
+ * Fire `handler` when the Escape key is pressed at the document level.
+ * For nested overlays, the topmost should call `event.stopPropagation()` in
+ * its handler — `DismissableLayer` handles this stack-style.
+ */
+declare function useEscape(handler: (event: KeyboardEvent) => void, enabled?: boolean): void;
+
+/**
+ * Trap Tab / Shift+Tab focus inside the referenced element. On mount, focuses
+ * the first focusable child (unless already focused inside). On unmount,
+ * returns focus to the element that had it before mounting.
+ *
+ * For richer behavior (sentinels, nested traps), wrap `FocusScope` instead —
+ * this hook is the lower primitive.
+ */
+declare function useFocusTrap(ref: RefObject<HTMLElement | null>, enabled?: boolean): void;
+
+/**
+ * Prevent body scroll while at least one consumer has the lock active.
+ * Internally counted — multiple overlays may lock; only the last unlock restores.
+ * Compensates for scrollbar width to avoid layout shift.
+ */
+declare function useScrollLock(enabled?: boolean): void;
+
+/**
+ * Run `callback` whenever the referenced element's size changes. Returns
+ * synchronously after layout, before paint. Cleans up automatically.
+ */
+declare function useResizeObserver<T extends HTMLElement>(ref: RefObject<T | null>, callback: (entry: ResizeObserverEntry) => void, enabled?: boolean): void;
+
+/**
+ * Reactively follow a CSS media query. Pass a query string like
+ * `'(min-width: 768px)'` or `'(prefers-reduced-motion: reduce)'`.
+ */
+declare function useMediaQuery(query: string): boolean;
+
+type index_DisclosureControls = DisclosureControls;
+declare const index_useControlled: typeof useControlled;
+declare const index_useDisclosure: typeof useDisclosure;
+declare const index_useEscape: typeof useEscape;
+declare const index_useEventListener: typeof useEventListener;
+declare const index_useFocusTrap: typeof useFocusTrap;
+declare const index_useId: typeof useId;
+declare const index_useMediaQuery: typeof useMediaQuery;
+declare const index_useOutsideClick: typeof useOutsideClick;
+declare const index_useResizeObserver: typeof useResizeObserver;
+declare const index_useScrollLock: typeof useScrollLock;
+declare namespace index {
+  export { type index_DisclosureControls as DisclosureControls, index_useControlled as useControlled, index_useDisclosure as useDisclosure, index_useEscape as useEscape, index_useEventListener as useEventListener, index_useFocusTrap as useFocusTrap, index_useId as useId, index_useMediaQuery as useMediaQuery, index_useOutsideClick as useOutsideClick, index_useResizeObserver as useResizeObserver, index_useScrollLock as useScrollLock };
+}
+
+export { type DisclosureControls as D, useDisclosure as a, useEscape as b, useEventListener as c, useFocusTrap as d, useId as e, useMediaQuery as f, useOutsideClick as g, useResizeObserver as h, index as i, useScrollLock as j, useControlled as u };