@vellira-ui/react 2.126.9 → 2.126.11

package/dist/components/Tooltip/Root/types.d.ts

@@ -0,0 +1,26 @@
+import { BaseTooltipProps } from '@vellira-ui/types';
+import { ReactNode } from 'react';
+export interface TooltipRootProps extends Omit<BaseTooltipProps, 'delay' | 'onOpenChange'> {
+    /** Compound tooltip children. */
+    children: ReactNode;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Initial uncontrolled open state. */
+    defaultOpen?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Open delay in milliseconds, or explicit open/close delays. */
+    delay?: number | Partial<BaseTooltipProps['delay']>;
+    /** Delay window for future sibling tooltip delay skipping. */
+    skipDelay?: number;
+    /** Distance between trigger and content in pixels. */
+    offset?: number;
+    /** Allows pointer interaction inside tooltip content. */
+    interactive?: boolean;
+    /** Reserved for automatic portal rendering in higher-level helpers. */
+    portal?: boolean;
+    /** Allows the tooltip to flip or shift to stay visible. */
+    avoidCollisions?: boolean;
+    /** Matches tooltip content width to the trigger width. */
+    matchTriggerWidth?: boolean;
+}

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,15 @@
+export declare const Tooltip: {
+    ({ children, open: openProp, defaultOpen, onOpenChange, placement, offset, delay, skipDelay, disabled, interactive, avoidCollisions, matchTriggerWidth, }: import('./Root').TooltipRootProps): import('react').JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        ({ asChild, children, disabled, className, ...props }: import('./Trigger').TooltipTriggerProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Content: import('react').ForwardRefExoticComponent<import('./Content').TooltipContentProps & import('react').RefAttributes<HTMLDivElement>>;
+    Provider: ({ children, delay, skipDelay, }: {
+        children: React.ReactNode;
+        delay?: number | import('./internal/types').TooltipDelayConfig;
+        skipDelay?: number;
+    }) => import('react').JSX.Element;
+};

package/dist/components/Tooltip/Trigger/TooltipTrigger.d.ts

@@ -0,0 +1,5 @@
+import { TooltipTriggerProps } from './types';
+export declare const TooltipTrigger: {
+    ({ asChild, children, disabled, className, ...props }: TooltipTriggerProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Tooltip/Trigger/index.d.ts

@@ -0,0 +1,2 @@
+export { TooltipTrigger } from './TooltipTrigger';
+export type { TooltipTriggerProps } from './types';

package/dist/components/Tooltip/Trigger/types.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, ReactElement, ReactNode, Ref } from 'react';
+export interface TooltipTriggerProps extends HTMLAttributes<HTMLElement> {
+    /** Composes trigger behavior onto a single child element. */
+    asChild?: boolean;
+    /** Trigger content. */
+    children: ReactNode;
+    /** Disables tooltip interaction for this trigger. */
+    disabled?: boolean;
+}
+export type TooltipTriggerElement = ReactElement<HTMLAttributes<HTMLElement> & {
+    /** Disables tooltip interaction on the composed child. */
+    disabled?: boolean;
+    /** Ref forwarded to the composed trigger child. */
+    ref?: Ref<HTMLElement>;
+}>;

package/dist/components/Tooltip/index.d.ts

@@ -0,0 +1,8 @@
+export type { TooltipContentProps } from './Content';
+export { TooltipContent } from './Content';
+export type { TooltipRootProps } from './Root';
+export { TooltipRoot } from './Root';
+export { Tooltip } from './Tooltip';
+export type { TooltipTriggerProps } from './Trigger';
+export { TooltipTrigger } from './Trigger';
+export type { TooltipProps } from './types';

package/dist/components/Tooltip/internal/TooltipContext.d.ts

@@ -0,0 +1,12 @@
+import { TooltipContextValue, TooltipDelayConfig } from './types';
+export declare const TooltipRootProvider: import('react').Provider<TooltipContextValue | null>;
+export declare const TooltipProvider: ({ children, delay, skipDelay, }: {
+    children: React.ReactNode;
+    delay?: number | TooltipDelayConfig;
+    skipDelay?: number;
+}) => import('react').JSX.Element;
+export declare function useTooltipContext(): TooltipContextValue;
+export declare function useTooltipProviderContext(): {
+    delay: TooltipDelayConfig;
+    skipDelay: number;
+};

package/dist/components/Tooltip/internal/composeEventHandlers.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'react';
+export declare function composeEventHandlers<TEvent extends {
+    defaultPrevented?: boolean;
+}>(userHandler: ((event: TEvent) => void) | undefined, ownHandler: ((event: TEvent) => void) | undefined): (event: TEvent) => void;
+export declare function composeRefs<T>(...refs: Array<Ref<T> | undefined>): (node: T | null) => void;

package/dist/components/Tooltip/internal/types.d.ts

@@ -0,0 +1,23 @@
+import { Placement } from '@floating-ui/react';
+import { CSSProperties, HTMLAttributes, MutableRefObject, RefCallback, RefObject } from 'react';
+export type TooltipDelayConfig = {
+    open: number;
+    close: number;
+};
+export type TooltipContextValue = {
+    contentId: string;
+    open: boolean;
+    disabled: boolean;
+    interactive: boolean;
+    contentRef: RefObject<HTMLDivElement | null>;
+    arrowRef: MutableRefObject<HTMLDivElement | null>;
+    arrowX?: number | null;
+    arrowY?: number | null;
+    placement: Placement;
+    floatingStyles: CSSProperties;
+    setOpen: (open: boolean) => void;
+    setTriggerRef: RefCallback<HTMLElement>;
+    setContentRef: RefCallback<HTMLDivElement>;
+    getTriggerProps: (userProps?: HTMLAttributes<HTMLElement>) => HTMLAttributes<HTMLElement>;
+    getContentProps: (userProps?: HTMLAttributes<HTMLElement>) => HTMLAttributes<HTMLElement>;
+};

package/dist/components/Tooltip/internal/useTooltipDelay.d.ts

@@ -0,0 +1,3 @@
+import { TooltipDelay } from '@vellira-ui/types';
+import { TooltipDelayConfig } from './types';
+export declare function useTooltipDelay(delay?: number | Partial<TooltipDelay>, _skipDelay?: number): TooltipDelayConfig;

package/dist/components/Tooltip/internal/useTooltipInteractions.d.ts

@@ -0,0 +1,8 @@
+import { TooltipDelayConfig } from './types';
+import { UseFloatingPositionReturn } from '../../../managers/FloatingManager/index';
+export declare function useTooltipInteractions({ context, delay, disabled, interactive, }: {
+    context: UseFloatingPositionReturn['context'];
+    delay: TooltipDelayConfig;
+    disabled: boolean;
+    interactive: boolean;
+}): import('@floating-ui/react').UseInteractionsReturn;

package/dist/components/Tooltip/internal/useTooltipPosition.d.ts

@@ -0,0 +1,20 @@
+import { TooltipRootProps } from '../Root/types';
+export declare function useTooltipPosition({ open, onOpenChange, placement, offset, avoidCollisions, matchTriggerWidth, }: Pick<TooltipRootProps, 'placement' | 'offset' | 'avoidCollisions' | 'matchTriggerWidth'> & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): {
+    arrowRef: import('react').RefObject<HTMLDivElement | null>;
+    arrowX: number | undefined;
+    arrowY: number | undefined;
+    animationStyle: import('react').CSSProperties | undefined;
+    presentation: "floating" | "inline" | "modal";
+    context: ReturnType<typeof import('@floating-ui/react').useFloating>["context"];
+    placement: import('@floating-ui/utils').Placement;
+    middlewareData: ReturnType<typeof import('@floating-ui/react').useFloating>["middlewareData"];
+    floatingStyles: ReturnType<typeof import('@floating-ui/react').useFloating>["floatingStyles"];
+    isPositioned: boolean;
+    isMobileSheet: boolean;
+    setRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setReference"];
+    setFloatingRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setFloating"];
+    updatePosition: ReturnType<typeof import('@floating-ui/react').useFloating>["update"];
+};

package/dist/components/Tooltip/types.d.ts

@@ -0,0 +1,5 @@
+import { TooltipRootProps } from './Root';
+export type { TooltipContentProps } from './Content';
+export type { TooltipRootProps } from './Root';
+export type { TooltipTriggerProps } from './Trigger';
+export type TooltipProps = TooltipRootProps;

package/dist/components/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Accordion';
+export * from './Dropdown';
+export * from './Modal';
+export * from './Popover';
+export * from './RadioGroup';
+export * from './Select';
+export * from './Tabs';
+export * from './Tooltip';

package/dist/docs-examples.typecheck.d.ts

@@ -0,0 +1,8 @@
+export declare function WebInputValueChangeExample(): import('react').JSX.Element;
+export declare function WebCheckboxCheckedChangeExample(): import('react').JSX.Element;
+export declare function WebRadioCheckedChangeExample(): import('react').JSX.Element;
+export declare function WebRadioGroupValueChangeExample(): import('react').JSX.Element;
+export declare function WebFormFieldBindControlExample(): import('react').JSX.Element;
+export declare function WebSelectValueChangeExample(): import('react').JSX.Element;
+export declare function WebSelectMultipleValueChangeExample(): import('react').JSX.Element;
+export declare function WebSelectAdvancedContractExample(): import('react').JSX.Element;

package/dist/hooks/behavior/focus/index.d.ts

@@ -0,0 +1,3 @@
+export type { AriaIsolationOptions, FocusScopeOptions, OverlayAutoFocusEvent, } from '../types.js';
+export { useAriaIsolation } from './useAriaIsolation.js';
+export { useFocusScope } from './useFocusScope.js';

package/dist/hooks/behavior/focus/useAriaIsolation.d.ts

@@ -0,0 +1,2 @@
+import { AriaIsolationOptions } from '../types.js';
+export declare const useAriaIsolation: ({ active, enabled, content, }: AriaIsolationOptions) => void;

package/dist/hooks/behavior/focus/useFocusScope.d.ts

@@ -0,0 +1,2 @@
+import { FocusScopeOptions } from '../types.js';
+export declare const useFocusScope: ({ active, contentRef, enabled, initialFocus, finalFocus, restoreFocus, onOpenAutoFocus, onCloseAutoFocus, }: FocusScopeOptions) => void;

package/dist/hooks/behavior/index.d.ts

@@ -0,0 +1,6 @@
+export * from './focus/index.js';
+export * from './overlay/index.js';
+export * from './portal/index.js';
+export * from './select/index.js';
+export type { OverlayDismissReason } from './types.js';
+export * from './utils/index.js';

package/dist/hooks/behavior/overlay/index.d.ts

@@ -0,0 +1,10 @@
+export type { OverlayDismissOptions, OverlayOutsideEvent } from '../types.js';
+export { useOverlayDismiss } from './useOverlayDismiss.js';
+export type { OverlayFocusRestoreOptions } from './useOverlayFocusRestore.js';
+export { useOverlayFocusRestore } from './useOverlayFocusRestore.js';
+export type { OverlayPresentation, OverlayPresentationOptions, } from './useOverlayPresentation.js';
+export { useOverlayPresentation } from './useOverlayPresentation.js';
+export type { OverlayRegistrationOptions } from './useOverlayRegistration.js';
+export { useOverlayRegistration } from './useOverlayRegistration.js';
+export type { ScrollLockOptions } from './useScrollLock.js';
+export { useScrollLock } from './useScrollLock.js';

package/dist/hooks/behavior/overlay/useOverlayDismiss.d.ts

@@ -0,0 +1,7 @@
+import { OverlayDismissOptions } from '../types.js';
+export declare const useOverlayDismiss: ({ active, id, zIndexLevel, registrationActive, registered, zIndex, contentRef, ignoreRefs, closeOnEscape, closeOnOutsidePress, onEscapeKeyDown, onPointerDownOutside, onInteractOutside, requestClose, }: OverlayDismissOptions) => {
+    isTopOverlay: () => boolean;
+    isTopmost: boolean;
+    order: number | undefined;
+    zIndex: number | undefined;
+};

package/dist/hooks/behavior/overlay/useOverlayFocusRestore.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { OverlayAutoFocusEvent } from '../types.js';
+export type OverlayFocusRestoreOptions = {
+    active: boolean;
+    enabled?: boolean;
+    finalFocus?: RefObject<HTMLElement | null>;
+    onCloseAutoFocus?: (event: OverlayAutoFocusEvent) => void;
+};
+export declare const useOverlayFocusRestore: ({ active, enabled, finalFocus, onCloseAutoFocus, }: OverlayFocusRestoreOptions) => {
+    restoreFocus: () => void;
+    restoreFocusAfterClose: (event?: OverlayAutoFocusEvent) => void;
+    saveFocusSnapshot: () => void;
+};

package/dist/hooks/behavior/overlay/useOverlayPresentation.d.ts

@@ -0,0 +1,36 @@
+import { Middleware, Placement, Strategy } from '@floating-ui/react';
+import { CSSProperties } from 'react';
+import { useFloatingPosition } from '../../../managers/FloatingManager/index';
+export type OverlayPresentation = 'floating' | 'inline' | 'modal';
+export type OverlayPresentationResult = ReturnType<typeof useFloatingPosition> & {
+    animationStyle?: CSSProperties;
+    presentation: OverlayPresentation;
+};
+export type OverlayPresentationOptions = {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    strategy?: Strategy;
+    portal?: boolean;
+    presentation?: OverlayPresentation;
+    animationStyle?: CSSProperties;
+    offset?: number;
+    collisionPadding?: number;
+    matchTriggerWidth?: boolean;
+    avoidCollisions?: boolean;
+    mobileSheetBreakpoint?: number;
+    middleware?: Middleware[];
+};
+export declare const useOverlayPresentation: ({ open, onOpenChange, placement, strategy, portal, presentation, animationStyle, offset, collisionPadding, matchTriggerWidth, avoidCollisions, mobileSheetBreakpoint, middleware, }?: OverlayPresentationOptions) => {
+    animationStyle: CSSProperties | undefined;
+    presentation: "floating" | "inline" | "modal";
+    context: ReturnType<typeof import('@floating-ui/react').useFloating>["context"];
+    placement: Placement;
+    middlewareData: ReturnType<typeof import('@floating-ui/react').useFloating>["middlewareData"];
+    floatingStyles: ReturnType<typeof import('@floating-ui/react').useFloating>["floatingStyles"];
+    isPositioned: boolean;
+    isMobileSheet: boolean;
+    setRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setReference"];
+    setFloatingRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setFloating"];
+    updatePosition: ReturnType<typeof import('@floating-ui/react').useFloating>["update"];
+};

package/dist/hooks/behavior/overlay/useOverlayRegistration.d.ts

@@ -0,0 +1,13 @@
+import { OverlayZIndexLevel } from '../../../managers/index';
+export type OverlayRegistrationOptions = {
+    active: boolean;
+    id: string;
+    zIndexLevel?: OverlayZIndexLevel;
+    zIndex?: number;
+};
+export declare const useOverlayRegistration: ({ active, id, zIndexLevel, zIndex: explicitZIndex, }: OverlayRegistrationOptions) => {
+    isTopOverlay: () => boolean;
+    isTopmost: boolean;
+    order: number | undefined;
+    zIndex: number | undefined;
+};

package/dist/hooks/behavior/overlay/useScrollLock.d.ts

@@ -0,0 +1,5 @@
+export type ScrollLockOptions = {
+    active: boolean;
+    enabled?: boolean;
+};
+export declare const useScrollLock: ({ active, enabled, }: ScrollLockOptions) => void;

package/dist/hooks/behavior/portal/index.d.ts

@@ -0,0 +1,2 @@
+export type { PortalOptions } from './usePortal.js';
+export { defaultPortalTarget, usePortal } from './usePortal.js';

package/dist/hooks/behavior/portal/usePortal.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultPortalTarget: () => HTMLElement | null;
+export type PortalOptions = {
+    container?: Element | DocumentFragment | null;
+};
+export declare const usePortal: ({ container }?: PortalOptions) => Element | DocumentFragment | null;

package/dist/hooks/behavior/select/index.d.ts

@@ -0,0 +1 @@
+export { useSelectPosition } from './useSelectPosition.js';

package/dist/hooks/behavior/select/useSelectPosition.d.ts

@@ -0,0 +1,22 @@
+type SelectFloatingPlacement = 'bottom' | 'top' | 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+interface UseSelectPositionParams {
+    avoidCollisions: boolean;
+    isOpen: boolean;
+    matchTriggerWidth: boolean;
+    onOpenChange: (open: boolean) => void;
+    placement: SelectFloatingPlacement;
+}
+export declare function useSelectPosition({ avoidCollisions, isOpen, matchTriggerWidth, onOpenChange, placement, }: UseSelectPositionParams): {
+    animationStyle: import('react').CSSProperties | undefined;
+    presentation: "floating" | "inline" | "modal";
+    context: ReturnType<typeof import('@floating-ui/react').useFloating>["context"];
+    placement: import('@floating-ui/utils').Placement;
+    middlewareData: ReturnType<typeof import('@floating-ui/react').useFloating>["middlewareData"];
+    floatingStyles: ReturnType<typeof import('@floating-ui/react').useFloating>["floatingStyles"];
+    isPositioned: boolean;
+    isMobileSheet: boolean;
+    setRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setReference"];
+    setFloatingRef: ReturnType<typeof import('@floating-ui/react').useFloating>["refs"]["setFloating"];
+    updatePosition: ReturnType<typeof import('@floating-ui/react').useFloating>["update"];
+};
+export {};

package/dist/hooks/behavior/types.d.ts

@@ -0,0 +1,43 @@
+import { RefObject } from 'react';
+import { OverlayZIndexLevel } from '../../managers/index';
+export type OverlayAutoFocusEvent = {
+    preventDefault: () => void;
+    readonly defaultPrevented: boolean;
+};
+export type OverlayOutsideEvent<TOriginalEvent = PointerEvent> = {
+    originalEvent: TOriginalEvent;
+    preventDefault: () => void;
+    readonly defaultPrevented: boolean;
+};
+export type FocusScopeOptions = {
+    active: boolean;
+    contentRef: RefObject<HTMLElement | null>;
+    enabled: boolean;
+    initialFocus?: RefObject<HTMLElement | null>;
+    finalFocus?: RefObject<HTMLElement | null>;
+    restoreFocus: boolean;
+    onOpenAutoFocus?: (event: OverlayAutoFocusEvent) => void;
+    onCloseAutoFocus?: (event: OverlayAutoFocusEvent) => void;
+};
+export type OverlayDismissReason = 'escape-key' | 'outside-press';
+export type OverlayDismissOptions = {
+    active: boolean;
+    id: string;
+    zIndexLevel?: OverlayZIndexLevel;
+    registrationActive?: boolean;
+    registered?: boolean;
+    zIndex?: number;
+    contentRef: RefObject<HTMLElement | null>;
+    ignoreRefs?: Array<RefObject<HTMLElement | null>>;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: OverlayOutsideEvent) => void;
+    onInteractOutside?: (event: OverlayOutsideEvent) => void;
+    requestClose: (reason: OverlayDismissReason, event: KeyboardEvent | PointerEvent) => void;
+};
+export type AriaIsolationOptions = {
+    active: boolean;
+    enabled: boolean;
+    content: HTMLElement | null;
+};

package/dist/hooks/behavior/utils/events.d.ts

@@ -0,0 +1 @@
+export { createAutoFocusEvent, createOutsideEvent } from '@vellira-ui/core';

package/dist/hooks/behavior/utils/focusUtils.d.ts

@@ -0,0 +1 @@
+export { focusableSelector, focusFirstElement, getFocusableElements, } from '@vellira-ui/core';

package/dist/hooks/behavior/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { createAutoFocusEvent, createOutsideEvent } from './events.js';
+export { focusableSelector, focusFirstElement, getFocusableElements, } from './focusUtils.js';

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './behavior/index.js';
+export * from './behavior/index.js';
+export * from './useControllableState.js';
+export * from './useDropdown.js';
+export * from './useKeyboardNavigation.js';
+export * from './useModal.js';
+export * from './useSelect.js';
+export * from './useTabs.js';

package/dist/hooks/useControllableState.d.ts

@@ -0,0 +1,7 @@
+interface UseControllableStateProps<T> {
+    value?: T;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}
+export declare const useControllableState: <T>({ value, defaultValue, onChange, }: UseControllableStateProps<T>) => readonly [T, (next: T) => void];
+export {};

package/dist/hooks/useDropdown.d.ts

@@ -0,0 +1,28 @@
+import { KeyboardNavigationEvent, NavigableItem } from './useKeyboardNavigation.js';
+export interface UseDropdownParams<TItem extends NavigableItem> {
+    items: TItem[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (value: string) => void;
+    getItemValue: (item: TItem, index: number) => string;
+    getItemText?: (item: TItem) => string;
+    loop?: boolean;
+}
+export declare const useDropdown: <TItem extends NavigableItem>({ items, open, defaultOpen, disabled, onOpenChange, onSelect, getItemValue, getItemText, loop, }: UseDropdownParams<TItem>) => {
+    activeIndex: number;
+    setActiveIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+    isOpen: boolean;
+    open: boolean;
+    setOpen: (nextOpen: boolean, initialIndex?: number) => void;
+    openDropdown: (initialIndex?: number) => void;
+    closeDropdown: () => void;
+    toggleDropdown: () => void;
+    selectItem: (item: TItem) => void;
+    select: (item: TItem) => void;
+    selectActiveItem: () => void;
+    onKeyDown: (event: KeyboardNavigationEvent) => void;
+    getFirstEnabledIndex: () => number;
+    getLastEnabledIndex: () => number;
+};

package/dist/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,24 @@
+export interface NavigableItem {
+    disabled?: boolean;
+}
+export interface KeyboardNavigationEvent {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    preventDefault: () => void;
+}
+export interface UseKeyboardNavigationParams<TItem extends NavigableItem> {
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+    items: TItem[];
+    isOpen: boolean;
+    onOpen: (event: KeyboardNavigationEvent) => void;
+    onSelect?: () => void;
+    onClose?: () => void;
+    getItemText?: (item: TItem) => string;
+    loop?: boolean;
+}
+export declare const useKeyboardNavigation: <TItem extends NavigableItem>({ activeIndex, setActiveIndex, items, isOpen, onOpen, onSelect, onClose, getItemText, loop, }: UseKeyboardNavigationParams<TItem>) => {
+    onKeyDown: (event: KeyboardNavigationEvent) => void;
+};

package/dist/hooks/useModal.d.ts

@@ -0,0 +1,18 @@
+export interface UseModalParams {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnEscape?: boolean;
+    closeOnOutsidePress?: boolean;
+}
+export declare const useModal: ({ open, defaultOpen, onOpenChange, closeOnEscape, closeOnOutsidePress, }: UseModalParams) => {
+    open: boolean;
+    shouldRender: boolean;
+    setOpen: (next: boolean) => void;
+    requestClose: () => void;
+    closeOnOutsidePress: boolean;
+    closeOnEscape: boolean;
+    contentId: string;
+    titleId: string;
+    descriptionId: string;
+};

package/dist/hooks/useSelect.d.ts

@@ -0,0 +1,43 @@
+import { NavigableItem } from './useKeyboardNavigation.js';
+export interface SelectOptionLike extends NavigableItem {
+    label: string;
+    value: string;
+}
+export type SelectStateValue = string | string[];
+type SelectValueChangeHandler<TValue extends SelectStateValue = SelectStateValue> = {
+    onValueChange(value: TValue): void;
+}['onValueChange'];
+export interface UseSelectParams<TOption extends SelectOptionLike> {
+    value?: SelectStateValue;
+    defaultValue?: SelectStateValue;
+    onValueChange?: SelectValueChangeHandler;
+    options: TOption[];
+    multiple?: boolean;
+    maxSelected?: number;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare const useSelect: <TOption extends SelectOptionLike>({ value, defaultValue, onValueChange, options, multiple, maxSelected, closeOnSelect, disabled, open, defaultOpen, onOpenChange, }: UseSelectParams<TOption>) => {
+    selectedValue: SelectStateValue;
+    selectedValues: string[];
+    setSelectedValue: (next: SelectStateValue) => void;
+    selectedOption: TOption | undefined;
+    selectedOptions: TOption[];
+    isOpen: boolean;
+    open: boolean;
+    setIsOpen: (next: boolean) => void;
+    activeIndex: number;
+    setActiveIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+    getInitialActiveIndex: () => number;
+    openDropdown: () => void;
+    closeDropdown: () => void;
+    toggleDropdown: () => void;
+    selectValue: (nextValue: string) => void;
+    select: (nextValue: string) => void;
+    selectActiveOption: () => void;
+    onKeyDown: (event: import('./useKeyboardNavigation.js').KeyboardNavigationEvent) => void;
+};
+export {};

package/dist/hooks/useTabs.d.ts

@@ -0,0 +1,9 @@
+export interface UseTabsParams {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+export declare const useTabs: ({ value: controlledValue, defaultValue, onValueChange, }: UseTabsParams) => {
+    value: string;
+    setValue: (next: string) => void;
+};

package/dist/managers/FloatingManager/index.d.ts

@@ -0,0 +1,2 @@
+export type { UseFloatingPositionReturn } from './useFloatingPosition';
+export { useFloatingPosition, useMaxWidthMatch } from './useFloatingPosition';

package/dist/managers/FloatingManager/useFloatingPosition.d.ts

@@ -0,0 +1,27 @@
+import { Middleware, Placement, Strategy, useFloating } from '@floating-ui/react';
+interface UseFloatingPositionProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    strategy?: Strategy;
+    offset?: number;
+    collisionPadding?: number;
+    matchTriggerWidth?: boolean;
+    avoidCollisions?: boolean;
+    mobileSheetBreakpoint?: number;
+    middleware?: Middleware[];
+}
+export interface UseFloatingPositionReturn {
+    context: ReturnType<typeof useFloating>['context'];
+    placement: Placement;
+    middlewareData: ReturnType<typeof useFloating>['middlewareData'];
+    floatingStyles: ReturnType<typeof useFloating>['floatingStyles'];
+    isPositioned: boolean;
+    isMobileSheet: boolean;
+    setRef: ReturnType<typeof useFloating>['refs']['setReference'];
+    setFloatingRef: ReturnType<typeof useFloating>['refs']['setFloating'];
+    updatePosition: ReturnType<typeof useFloating>['update'];
+}
+export declare const useMaxWidthMatch: (maxWidth?: number) => boolean;
+export declare const useFloatingPosition: ({ open, onOpenChange, placement: initialPlacement, strategy, offset: offsetValue, collisionPadding, matchTriggerWidth, avoidCollisions, mobileSheetBreakpoint, middleware: customMiddleware, }?: UseFloatingPositionProps) => UseFloatingPositionReturn;
+export {};

package/dist/managers/OverlayManager/OverlayManagerProvider.d.ts

@@ -0,0 +1,3 @@
+import { OverlayManager, OverlayManagerProviderProps } from './types';
+export declare const OverlayManagerProvider: ({ children, manager, }: OverlayManagerProviderProps) => import('react').JSX.Element;
+export declare const useOverlayManager: () => OverlayManager;

package/dist/managers/OverlayManager/WebOverlayManager.d.ts

@@ -0,0 +1,3 @@
+import { OverlayManager } from './types';
+export declare function createOverlayManager(): OverlayManager;
+export declare const overlayManager: OverlayManager;

package/dist/managers/OverlayManager/index.d.ts

@@ -0,0 +1,3 @@
+export { OverlayManagerProvider, useOverlayManager, } from './OverlayManagerProvider';
+export type { OverlayEntry, OverlayManager, OverlayManagerProviderProps, OverlayRegistration, OverlaySnapshot, OverlayZIndexLevel, } from './types';
+export { createOverlayManager, overlayManager } from './WebOverlayManager';