react-aria 3.46.0 → 3.48.0

package/dist/types/src/disclosure/useDisclosure.d.ts

@@ -0,0 +1,26 @@
+import { AriaButtonProps } from '../button/useButton';
+import { DisclosureState } from 'react-stately/useDisclosureState';
+import { HTMLAttributes, RefObject } from 'react';
+export interface AriaDisclosureProps {
+    /** Whether the disclosure is disabled. */
+    isDisabled?: boolean;
+    /** Handler that is called when the disclosure's expanded state changes. */
+    onExpandedChange?: (isExpanded: boolean) => void;
+    /** Whether the disclosure is expanded (controlled). */
+    isExpanded?: boolean;
+    /** Whether the disclosure is expanded by default (uncontrolled). */
+    defaultExpanded?: boolean;
+}
+export interface DisclosureAria {
+    /** Props for the disclosure button. */
+    buttonProps: AriaButtonProps;
+    /** Props for the disclosure panel. */
+    panelProps: HTMLAttributes<HTMLElement>;
+}
+/**
+ * Provides the behavior and accessibility implementation for a disclosure component.
+ * @param props - Props for the disclosure.
+ * @param state - State for the disclosure, as returned by `useDisclosureState`.
+ * @param ref - A ref for the disclosure panel.
+ */
+export declare function useDisclosure(props: AriaDisclosureProps, state: DisclosureState, ref: RefObject<HTMLElement | null>): DisclosureAria;

package/dist/types/src/dnd/DragManager.d.ts

@@ -0,0 +1,67 @@
+import { DragEndEvent, DragItem, DropActivateEvent, DropEnterEvent, DropEvent, DropExitEvent, DropOperation, DropTarget as DroppableCollectionTarget, FocusableElement } from '@react-types/shared';
+import type { LocalizedStringFormatter } from '@internationalized/string';
+import { RefObject } from 'react';
+interface DropTarget {
+    element: FocusableElement;
+    preventFocusOnDrop?: boolean;
+    getDropOperation?: (types: Set<string>, allowedOperations: DropOperation[]) => DropOperation;
+    onDropEnter?: (e: DropEnterEvent, dragTarget: DragTarget) => void;
+    onDropExit?: (e: DropExitEvent) => void;
+    onDropTargetEnter?: (target: DroppableCollectionTarget | null) => void;
+    onDropActivate?: (e: DropActivateEvent, target: DroppableCollectionTarget | null) => void;
+    onDrop?: (e: DropEvent, target: DroppableCollectionTarget | null) => void;
+    onKeyDown?: (e: KeyboardEvent, dragTarget: DragTarget) => void;
+    activateButtonRef?: RefObject<FocusableElement | null>;
+}
+export declare function registerDropTarget(target: DropTarget): () => void;
+interface DroppableItem {
+    element: FocusableElement;
+    target: DroppableCollectionTarget;
+    getDropOperation?: (types: Set<string>, allowedOperations: DropOperation[]) => DropOperation;
+    activateButtonRef?: RefObject<FocusableElement | null>;
+}
+export declare function registerDropItem(item: DroppableItem): () => void;
+interface DragTarget {
+    element: FocusableElement;
+    items: DragItem[];
+    allowedDropOperations: DropOperation[];
+    onDragEnd?: (e: DragEndEvent) => void;
+}
+export declare function beginDragging(target: DragTarget, stringFormatter: LocalizedStringFormatter): void;
+export declare function useDragSession(): DragSession | null;
+/** @private */
+export declare function isVirtualDragging(): boolean;
+export declare function isValidDropTarget(element: Element): boolean;
+declare class DragSession {
+    dragTarget: DragTarget;
+    validDropTargets: DropTarget[];
+    currentDropTarget: DropTarget | null;
+    currentDropItem: DroppableItem | null;
+    dropOperation: DropOperation | null;
+    private mutationObserver;
+    private restoreAriaHidden;
+    private stringFormatter;
+    private isVirtualClick;
+    private initialFocused;
+    constructor(target: DragTarget, stringFormatter: LocalizedStringFormatter);
+    setup(): void;
+    teardown(): void;
+    onKeyDown(e: KeyboardEvent): void;
+    onKeyUp(e: KeyboardEvent): void;
+    getCurrentActivateButton(): FocusableElement | null;
+    onFocus(e: FocusEvent): void;
+    onBlur(e: FocusEvent): void;
+    onClick(e: MouseEvent): void;
+    onPointerDown(e: PointerEvent): void;
+    cancelEvent(e: Event): void;
+    updateValidDropTargets(): void;
+    next(): void;
+    previous(): void;
+    findNearestDropTarget(): number;
+    setCurrentDropTarget(dropTarget: DropTarget | null, item?: DroppableItem): void;
+    end(): void;
+    cancel(): void;
+    drop(item?: DroppableItem): void;
+    activate(dropTarget: DropTarget | null, dropItem: DroppableItem | null | undefined): void;
+}
+export {};

package/dist/types/src/dnd/DragPreview.d.ts

@@ -0,0 +1,15 @@
+import { DragItem, DragPreviewRenderer } from '@react-types/shared';
+import React, { JSX } from 'react';
+export interface DragPreviewProps {
+    /**
+     * A render function which returns a preview element, or an object containing the element
+     * and a custom offset. If an object is returned, the provided `x` and `y` values will be
+     * used as the drag preview offset instead of the default calculation.
+     */
+    children: (items: DragItem[]) => JSX.Element | {
+        element: JSX.Element;
+        x: number;
+        y: number;
+    } | null;
+}
+export declare const DragPreview: React.ForwardRefExoticComponent<DragPreviewProps & React.RefAttributes<DragPreviewRenderer | null>>;

package/dist/types/src/dnd/DropTargetKeyboardNavigation.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DropTarget, KeyboardDelegate, Node } from '@react-types/shared';
+export declare function navigate(keyboardDelegate: KeyboardDelegate, collection: Collection<Node<unknown>>, target: DropTarget | null | undefined, direction: 'left' | 'right' | 'up' | 'down', rtl?: boolean, wrap?: boolean): DropTarget | null;

package/dist/types/src/dnd/ListDropTargetDelegate.d.ts

@@ -0,0 +1,36 @@
+import { Direction, DropTarget, DropTargetDelegate, Node, Orientation, RefObject } from '@react-types/shared';
+interface ListDropTargetDelegateOptions {
+    /**
+     * Whether the items are arranged in a stack or grid.
+     * @default 'stack'
+     */
+    layout?: 'stack' | 'grid';
+    /**
+     * The primary orientation of the items. Usually this is the
+     * direction that the collection scrolls.
+     * @default 'vertical'
+     */
+    orientation?: Orientation;
+    /**
+     * The horizontal layout direction.
+     * @default 'ltr'
+     */
+    direction?: Direction;
+}
+export declare class ListDropTargetDelegate implements DropTargetDelegate {
+    private collection;
+    private ref;
+    private layout;
+    private orientation;
+    protected direction: Direction;
+    constructor(collection: Iterable<Node<unknown>>, ref: RefObject<HTMLElement | null>, options?: ListDropTargetDelegateOptions);
+    private getPrimaryStart;
+    private getPrimaryEnd;
+    private getSecondaryStart;
+    private getSecondaryEnd;
+    private getFlowStart;
+    private getFlowEnd;
+    private getFlowSize;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget;
+}
+export {};

package/dist/types/src/dnd/constants.d.ts

@@ -0,0 +1,47 @@
+import { DropOperation } from '@react-types/shared';
+export interface IDropOperation {
+    readonly none: 0;
+    readonly cancel: 0;
+    readonly move: number;
+    readonly copy: number;
+    readonly link: number;
+    readonly all: number;
+}
+export declare enum DROP_OPERATION {
+    none = 0,
+    cancel = 0,
+    move = 1,
+    copy = 2,
+    link = 4,
+    all = 7
+}
+interface DropOperationAllowed extends IDropOperation {
+    readonly copyMove: number;
+    readonly copyLink: number;
+    readonly linkMove: number;
+    readonly all: number;
+    readonly uninitialized: number;
+}
+export declare const DROP_OPERATION_ALLOWED: DropOperationAllowed;
+interface EffectAllowed {
+    0: 'none' | 'cancel';
+    1: 'move';
+    2: 'copy';
+    3: 'copyMove';
+    4: 'link';
+    5: 'linkMove';
+    6: 'copyLink';
+    7: 'all';
+}
+export declare const EFFECT_ALLOWED: EffectAllowed;
+type DropEffect = 'none' | 'link' | 'copy' | 'move';
+export declare const DROP_EFFECT_TO_DROP_OPERATION: {
+    [K in DropEffect]: DropOperation;
+};
+export declare const DROP_OPERATION_TO_DROP_EFFECT: {
+    [K in DropOperation]: DropEffect;
+};
+export declare const NATIVE_DRAG_TYPES: Set<string>;
+export declare const CUSTOM_DRAG_TYPE = "application/vnd.react-aria.items+json";
+export declare const GENERIC_TYPE = "application/octet-stream";
+export {};

package/dist/types/src/dnd/useAutoScroll.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from '@react-types/shared';
+interface AutoScrollAria {
+    move(x: number, y: number): void;
+    stop(): void;
+}
+export declare function useAutoScroll(ref: RefObject<Element | null>): AutoScrollAria;
+export {};

package/dist/types/src/dnd/useClipboard.d.ts

@@ -0,0 +1,24 @@
+import { DOMAttributes, DragItem, DropItem } from '@react-types/shared';
+export interface ClipboardProps {
+    /** A function that returns the items to copy. */
+    getItems?: (details: {
+        action: 'cut' | 'copy';
+    }) => DragItem[];
+    /** Handler that is called when the user triggers a copy interaction. */
+    onCopy?: () => void;
+    /** Handler that is called when the user triggers a cut interaction. */
+    onCut?: () => void;
+    /** Handler that is called when the user triggers a paste interaction. */
+    onPaste?: (items: DropItem[]) => void;
+    /** Whether the clipboard is disabled. */
+    isDisabled?: boolean;
+}
+export interface ClipboardResult {
+    /** Props for the element that will handle clipboard events. */
+    clipboardProps: DOMAttributes;
+}
+/**
+ * Handles clipboard interactions for a focusable element. Supports items of multiple
+ * data types, and integrates with the operating system native clipboard.
+ */
+export declare function useClipboard(options: ClipboardProps): ClipboardResult;

package/dist/types/src/dnd/useDrag.d.ts

@@ -0,0 +1,39 @@
+import { AriaButtonProps } from '../button/useButton';
+import { DragEndEvent, DragItem, DragMoveEvent, DragPreviewRenderer, DragStartEvent, DropOperation, RefObject } from '@react-types/shared';
+import { HTMLAttributes } from 'react';
+export interface DragOptions {
+    /** Handler that is called when a drag operation is started. */
+    onDragStart?: (e: DragStartEvent) => void;
+    /** Handler that is called when the drag is moved. */
+    onDragMove?: (e: DragMoveEvent) => void;
+    /** Handler that is called when the drag operation is ended, either as a result of a drop or a cancellation. */
+    onDragEnd?: (e: DragEndEvent) => void;
+    /** A function that returns the items being dragged. */
+    getItems: () => DragItem[];
+    /** The ref of the element that will be rendered as the drag preview while dragging. */
+    preview?: RefObject<DragPreviewRenderer | null>;
+    /** Function that returns the drop operations that are allowed for the dragged items. If not provided, all drop operations are allowed. */
+    getAllowedDropOperations?: () => DropOperation[];
+    /**
+     * Whether the item has an explicit focusable drag affordance to initiate accessible drag and drop mode.
+     * If true, the dragProps will omit these event handlers, and they will be applied to dragButtonProps instead.
+     */
+    hasDragButton?: boolean;
+    /**
+     * Whether the drag operation is disabled. If true, the element will not be draggable.
+     */
+    isDisabled?: boolean;
+}
+export interface DragResult {
+    /** Props for the draggable element. */
+    dragProps: HTMLAttributes<HTMLElement>;
+    /** Props for the explicit drag button affordance, if any. */
+    dragButtonProps: AriaButtonProps;
+    /** Whether the element is currently being dragged. */
+    isDragging: boolean;
+}
+/**
+ * Handles drag interactions for an element, with support for traditional mouse and touch
+ * based drag and drop, in addition to full parity for keyboard and screen reader users.
+ */
+export declare function useDrag(options: DragOptions): DragResult;

package/dist/types/src/dnd/useDraggableCollection.d.ts

@@ -0,0 +1,9 @@
+import { DraggableCollectionState } from 'react-stately/useDraggableCollectionState';
+import { RefObject } from '@react-types/shared';
+export interface DraggableCollectionOptions {
+}
+/**
+ * Handles drag interactions for a collection component, with support for traditional mouse and touch
+ * based drag and drop, in addition to full parity for keyboard and screen reader users.
+ */
+export declare function useDraggableCollection(props: DraggableCollectionOptions, state: DraggableCollectionState, ref: RefObject<HTMLElement | null>): void;

package/dist/types/src/dnd/useDraggableItem.d.ts

@@ -0,0 +1,30 @@
+import { AriaButtonProps } from '../button/useButton';
+import { DraggableCollectionState } from 'react-stately/useDraggableCollectionState';
+import { HTMLAttributes } from 'react';
+import { Key } from '@react-types/shared';
+export interface DraggableItemProps {
+    /** The key of the draggable item within the collection. */
+    key: Key;
+    /**
+     * Whether the item has an explicit focusable drag affordance to initiate accessible drag and drop mode.
+     * If true, the dragProps will omit these event handlers, and they will be applied to dragButtonProps instead.
+     */
+    hasDragButton?: boolean;
+    /**
+     * Whether the item has a primary action (e.g. Enter key or long press) that would
+     * conflict with initiating accessible drag and drop. If true, the Alt key must be held to
+     * start dragging with a keyboard, and long press is disabled until selection mode is entered.
+     * This should be passed from the associated collection item hook (e.g. useOption, useGridListItem, etc.).
+     */
+    hasAction?: boolean;
+}
+export interface DraggableItemResult {
+    /** Props for the draggable item. */
+    dragProps: HTMLAttributes<HTMLElement>;
+    /** Props for the explicit drag button affordance, if any. */
+    dragButtonProps: AriaButtonProps;
+}
+/**
+ * Handles drag interactions for an item within a draggable collection.
+ */
+export declare function useDraggableItem(props: DraggableItemProps, state: DraggableCollectionState): DraggableItemResult;

package/dist/types/src/dnd/useDrop.d.ts

@@ -0,0 +1,48 @@
+import { AriaButtonProps } from '../button/useButton';
+import { DOMAttributes, DropActivateEvent, DropEnterEvent, DropEvent, DropExitEvent, DropMoveEvent, DropOperation, FocusableElement, DragTypes as IDragTypes, RefObject } from '@react-types/shared';
+export interface DropOptions {
+    /** A ref for the droppable element. */
+    ref: RefObject<FocusableElement | null>;
+    /**
+     * A function returning the drop operation to be performed when items matching the given types are dropped
+     * on the drop target.
+     */
+    getDropOperation?: (types: IDragTypes, allowedOperations: DropOperation[]) => DropOperation;
+    /** A function that returns the drop operation for a specific point within the target. */
+    getDropOperationForPoint?: (types: IDragTypes, allowedOperations: DropOperation[], x: number, y: number) => DropOperation;
+    /** Handler that is called when a valid drag enters the drop target. */
+    onDropEnter?: (e: DropEnterEvent) => void;
+    /** Handler that is called when a valid drag is moved within the drop target. */
+    onDropMove?: (e: DropMoveEvent) => void;
+    /**
+     * Handler that is called after a valid drag is held over the drop target for a period of time.
+     * This typically opens the item so that the user can drop within it.
+     */
+    onDropActivate?: (e: DropActivateEvent) => void;
+    /** Handler that is called when a valid drag exits the drop target. */
+    onDropExit?: (e: DropExitEvent) => void;
+    /** Handler that is called when a valid drag is dropped on the drop target. */
+    onDrop?: (e: DropEvent) => void;
+    /**
+     * Whether the item has an explicit focusable drop affordance to initiate accessible drag and drop mode.
+     * If true, the dropProps will omit these event handlers, and they will be applied to dropButtonProps instead.
+     */
+    hasDropButton?: boolean;
+    /**
+     * Whether the drop target is disabled. If true, the drop target will not accept any drops.
+     */
+    isDisabled?: boolean;
+}
+export interface DropResult {
+    /** Props for the droppable element. */
+    dropProps: DOMAttributes;
+    /** Whether the drop target is currently focused or hovered. */
+    isDropTarget: boolean;
+    /** Props for the explicit drop button affordance, if any. */
+    dropButtonProps?: AriaButtonProps;
+}
+/**
+ * Handles drop interactions for an element, with support for traditional mouse and touch
+ * based drag and drop, in addition to full parity for keyboard and screen reader users.
+ */
+export declare function useDrop(options: DropOptions): DropResult;

package/dist/types/src/dnd/useDropIndicator.d.ts

@@ -0,0 +1,24 @@
+import { DroppableCollectionState } from 'react-stately/useDroppableCollectionState';
+import { DropTarget, FocusableElement, RefObject } from '@react-types/shared';
+import { HTMLAttributes } from 'react';
+export interface DropIndicatorProps {
+    /** The drop target that the drop indicator represents. */
+    target: DropTarget;
+    /** The ref to the activate button. */
+    activateButtonRef?: RefObject<FocusableElement | null>;
+}
+export interface DropIndicatorAria {
+    /** Props for the drop indicator element. */
+    dropIndicatorProps: HTMLAttributes<HTMLElement>;
+    /** Whether the drop indicator is currently the active drop target. */
+    isDropTarget: boolean;
+    /**
+     * Whether the drop indicator is hidden, both visually and from assistive technology.
+     * Use this to determine whether to omit the element from the DOM entirely.
+     */
+    isHidden: boolean;
+}
+/**
+ * Handles drop interactions for a target within a droppable collection.
+ */
+export declare function useDropIndicator(props: DropIndicatorProps, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>): DropIndicatorAria;

package/dist/types/src/dnd/useDroppableCollection.d.ts

@@ -0,0 +1,20 @@
+import { DroppableCollectionProps, DropTargetDelegate, KeyboardDelegate, RefObject } from '@react-types/shared';
+import { DroppableCollectionState } from 'react-stately/useDroppableCollectionState';
+import { HTMLAttributes } from 'react';
+export interface DroppableCollectionOptions extends DroppableCollectionProps {
+    /** A delegate object that implements behavior for keyboard focus movement. */
+    keyboardDelegate: KeyboardDelegate;
+    /** A delegate object that provides drop targets for pointer coordinates within the collection. */
+    dropTargetDelegate: DropTargetDelegate;
+    /** A custom keyboard event handler for drop targets. */
+    onKeyDown?: (e: KeyboardEvent) => void;
+}
+export interface DroppableCollectionResult {
+    /** Props for the collection element. */
+    collectionProps: HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles drop interactions for a collection component, with support for traditional mouse and touch
+ * based drag and drop, in addition to full parity for keyboard and screen reader users.
+ */
+export declare function useDroppableCollection(props: DroppableCollectionOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>): DroppableCollectionResult;

package/dist/types/src/dnd/useDroppableItem.d.ts

@@ -0,0 +1,19 @@
+import { DroppableCollectionState } from 'react-stately/useDroppableCollectionState';
+import { DropTarget, FocusableElement, RefObject } from '@react-types/shared';
+import { HTMLAttributes } from 'react';
+export interface DroppableItemOptions {
+    /** The drop target represented by the item. */
+    target: DropTarget;
+    /** The ref to the activate button. */
+    activateButtonRef?: RefObject<FocusableElement | null>;
+}
+export interface DroppableItemResult {
+    /** Props for the droppable element. */
+    dropProps: HTMLAttributes<HTMLElement>;
+    /** Whether the item is currently the active drop target. */
+    isDropTarget: boolean;
+}
+/**
+ * Handles drop interactions for an item within a collection component.
+ */
+export declare function useDroppableItem(options: DroppableItemOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>): DroppableItemResult;

package/dist/types/src/dnd/useVirtualDrop.d.ts

@@ -0,0 +1,7 @@
+import { AriaButtonProps } from '../button/useButton';
+import { DOMAttributes } from 'react';
+interface VirtualDropResult {
+    dropProps: AriaButtonProps & DOMAttributes<HTMLDivElement>;
+}
+export declare function useVirtualDrop(): VirtualDropResult;
+export {};

package/dist/types/src/dnd/utils.d.ts

@@ -0,0 +1,49 @@
+import { DROP_OPERATION } from './constants';
+import { DirectoryDropItem, DragItem, DropItem, FileDropItem, DragTypes as IDragTypes, Key, RefObject, TextDropItem } from '@react-types/shared';
+import { DroppableCollectionState } from 'react-stately/useDroppableCollectionState';
+interface DroppableCollectionMap {
+    id: string;
+    ref: RefObject<HTMLElement | null>;
+}
+export declare const droppableCollectionMap: WeakMap<DroppableCollectionState, DroppableCollectionMap>;
+export declare const DIRECTORY_DRAG_TYPE: symbol;
+export declare function getDroppableCollectionId(state: DroppableCollectionState): string;
+export declare function getDroppableCollectionRef(state: DroppableCollectionState): RefObject<HTMLElement | null>;
+export declare function getTypes(items: DragItem[]): Set<string>;
+export declare function useDragModality(): string;
+export declare function getDragModality(): string;
+export declare function writeToDataTransfer(dataTransfer: DataTransfer, items: DragItem[]): void;
+export declare class DragTypes implements IDragTypes {
+    private types;
+    private includesUnknownTypes;
+    constructor(dataTransfer: DataTransfer);
+    has(type: string | symbol): boolean;
+}
+export declare function readFromDataTransfer(dataTransfer: DataTransfer): DropItem[];
+/** Returns whether a drop item contains text data. */
+export declare function isTextDropItem(dropItem: DropItem): dropItem is TextDropItem;
+/** Returns whether a drop item is a file. */
+export declare function isFileDropItem(dropItem: DropItem): dropItem is FileDropItem;
+/** Returns whether a drop item is a directory. */
+export declare function isDirectoryDropItem(dropItem: DropItem): dropItem is DirectoryDropItem;
+export interface DnDState {
+    /** A ref for the  of the drag items in the current drag session if any. */
+    draggingCollectionRef?: RefObject<HTMLElement | null>;
+    /** The set of currently dragged keys. */
+    draggingKeys: Set<Key>;
+    /** A ref for the collection that is targeted for a drop operation, if any. */
+    dropCollectionRef?: RefObject<HTMLElement | null>;
+}
+export declare let globalDndState: DnDState;
+export declare function setDraggingCollectionRef(ref: RefObject<HTMLElement | null>): void;
+export declare function setDraggingKeys(keys: Set<Key>): void;
+export declare function setDropCollectionRef(ref?: RefObject<HTMLElement | null>): void;
+export declare function clearGlobalDnDState(): void;
+export declare function setGlobalDnDState(state: DnDState): void;
+export declare function isInternalDropOperation(ref?: RefObject<HTMLElement | null>): boolean;
+type DropEffect = 'none' | 'copy' | 'link' | 'move';
+export declare let globalDropEffect: DropEffect | undefined;
+export declare function setGlobalDropEffect(dropEffect: DropEffect | undefined): void;
+export declare let globalAllowedDropOperations: DROP_OPERATION;
+export declare function setGlobalAllowedDropOperations(o: DROP_OPERATION): void;
+export {};

package/dist/types/src/focus/FocusRing.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactElement } from 'react';
+export interface FocusRingProps {
+    /** Child element to apply CSS classes to. */
+    children: ReactElement;
+    /** CSS class to apply when the element is focused. */
+    focusClass?: string;
+    /** CSS class to apply when the element has keyboard focus. */
+    focusRingClass?: string;
+    /**
+     * Whether to show the focus ring when something
+     * inside the container element has focus (true), or
+     * only if the container itself has focus (false).
+     * @default false
+     */
+    within?: boolean;
+    /** Whether the element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element will be auto focused. */
+    autoFocus?: boolean;
+}
+/**
+ * A utility component that applies a CSS class when an element has keyboard focus.
+ * Focus rings are visible only when the user is interacting with a keyboard,
+ * not with a mouse, touch, or other input methods.
+ */
+export declare function FocusRing(props: FocusRingProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;

package/dist/types/src/focus/FocusScope.d.ts

@@ -0,0 +1,91 @@
+import { ShadowTreeWalker } from '../utils/shadowdom/ShadowTreeWalker';
+import { FocusableElement, RefObject } from '@react-types/shared';
+import { JSX, ReactNode } from 'react';
+export interface FocusScopeProps {
+    /** The contents of the focus scope. */
+    children: ReactNode;
+    /**
+     * Whether to contain focus inside the scope, so users cannot
+     * move focus outside, for example in a modal dialog.
+     */
+    contain?: boolean;
+    /**
+     * Whether to restore focus back to the element that was focused
+     * when the focus scope mounted, after the focus scope unmounts.
+     */
+    restoreFocus?: boolean;
+    /** Whether to auto focus the first focusable element in the focus scope on mount. */
+    autoFocus?: boolean;
+}
+export interface FocusManagerOptions {
+    /** The element to start searching from. The currently focused element by default. */
+    from?: Element;
+    /** Whether to only include tabbable elements, or all focusable elements. */
+    tabbable?: boolean;
+    /** Whether focus should wrap around when it reaches the end of the scope. */
+    wrap?: boolean;
+    /** A callback that determines whether the given element is focused. */
+    accept?: (node: Element) => boolean;
+}
+export interface FocusManager {
+    /** Moves focus to the next focusable or tabbable element in the focus scope. */
+    focusNext(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the previous focusable or tabbable element in the focus scope. */
+    focusPrevious(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the first focusable or tabbable element in the focus scope. */
+    focusFirst(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the last focusable or tabbable element in the focus scope. */
+    focusLast(opts?: FocusManagerOptions): FocusableElement | null;
+}
+type ScopeRef = RefObject<Element[] | null> | null;
+/**
+ * A FocusScope manages focus for its descendants. It supports containing focus inside
+ * the scope, restoring focus to the previously focused element on unmount, and auto
+ * focusing children on mount. It also acts as a container for a programmatic focus
+ * management interface that can be used to move focus forward and back in response
+ * to user events.
+ */
+export declare function FocusScope(props: FocusScopeProps): JSX.Element;
+/**
+ * Returns a FocusManager interface for the parent FocusScope.
+ * A FocusManager can be used to programmatically move focus within
+ * a FocusScope, e.g. in response to user events like keyboard navigation.
+ */
+export declare function useFocusManager(): FocusManager | undefined;
+/** @private */
+export declare function isElementInChildOfActiveScope(element: Element): boolean;
+/**
+ * Create a [TreeWalker]{@link https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker}
+ * that matches all focusable/tabbable elements.
+ */
+export declare function getFocusableTreeWalker(root: Element, opts?: FocusManagerOptions, scope?: Element[]): ShadowTreeWalker | TreeWalker;
+/**
+ * Creates a FocusManager object that can be used to move focus within an element.
+ */
+export declare function createFocusManager(ref: RefObject<Element | null>, defaultOptions?: FocusManagerOptions): FocusManager;
+declare class Tree {
+    root: TreeNode;
+    private fastMap;
+    constructor();
+    get size(): number;
+    getTreeNode(data: ScopeRef): TreeNode | undefined;
+    addTreeNode(scopeRef: ScopeRef, parent: ScopeRef, nodeToRestore?: FocusableElement): void;
+    addNode(node: TreeNode): void;
+    removeTreeNode(scopeRef: ScopeRef): void;
+    traverse(node?: TreeNode): Generator<TreeNode>;
+    clone(): Tree;
+}
+declare class TreeNode {
+    scopeRef: ScopeRef;
+    nodeToRestore?: FocusableElement;
+    parent?: TreeNode;
+    children: Set<TreeNode>;
+    contain: boolean;
+    constructor(props: {
+        scopeRef: ScopeRef;
+    });
+    addChild(node: TreeNode): void;
+    removeChild(node: TreeNode): void;
+}
+export declare let focusScopeTree: Tree;
+export {};

package/dist/types/src/focus/useFocusRing.d.ts

@@ -0,0 +1,28 @@
+import { DOMAttributes } from '@react-types/shared';
+export interface AriaFocusRingProps {
+    /**
+     * Whether to show the focus ring when something
+     * inside the container element has focus (true), or
+     * only if the container itself has focus (false).
+     * @default 'false'
+     */
+    within?: boolean;
+    /** Whether the element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element will be auto focused. */
+    autoFocus?: boolean;
+}
+export interface FocusRingAria {
+    /** Whether the element is currently focused. */
+    isFocused: boolean;
+    /** Whether keyboard focus should be visible. */
+    isFocusVisible: boolean;
+    /** Props to apply to the container element with the focus ring. */
+    focusProps: DOMAttributes;
+}
+/**
+ * Determines whether a focus ring should be shown to indicate keyboard focus.
+ * Focus rings are visible only when the user is interacting with a keyboard,
+ * not with a mouse, touch, or other input methods.
+ */
+export declare function useFocusRing(props?: AriaFocusRingProps): FocusRingAria;

package/dist/types/src/focus/useHasTabbableChild.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from '@react-types/shared';
+interface AriaHasTabbableChildOptions {
+    isDisabled?: boolean;
+}
+/**
+ * Returns whether an element has a tabbable child, and updates as children change.
+ * @private
+ */
+export declare function useHasTabbableChild(ref: RefObject<Element | null>, options?: AriaHasTabbableChildOptions): boolean;
+export {};

package/dist/types/src/focus/virtualFocus.d.ts

@@ -0,0 +1,4 @@
+export declare function moveVirtualFocus(to: Element | null): void;
+export declare function dispatchVirtualBlur(from: Element, to: Element | null): void;
+export declare function dispatchVirtualFocus(to: Element, from: Element | null): void;
+export declare function getVirtuallyFocusedElement(document: Document): Element | null;