react-aria 3.47.0 → 3.48.0

package/dist/types/src/form/useFormValidation.d.ts

@@ -0,0 +1,8 @@
+import { FormValidationState } from 'react-stately/private/form/useFormValidationState';
+import { RefObject, Validation } from '@react-types/shared';
+type ValidatableElement = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+interface FormValidationProps<T> extends Validation<T> {
+    focus?: () => void;
+}
+export declare function useFormValidation<T>(props: FormValidationProps<T>, state: FormValidationState, ref: RefObject<ValidatableElement | null> | undefined): void;
+export {};

package/dist/types/src/grid/GridKeyboardDelegate.d.ts

@@ -0,0 +1,51 @@
+import { Direction, DisabledBehavior, Key, KeyboardDelegate, LayoutDelegate, Node, Rect, RefObject, Size } from '@react-types/shared';
+import { IGridCollection as GridCollection } from 'react-stately/private/grid/GridCollection';
+export interface GridKeyboardDelegateOptions<C> {
+    collection: C;
+    disabledKeys: Set<Key>;
+    disabledBehavior?: DisabledBehavior;
+    ref?: RefObject<HTMLElement | null>;
+    direction: Direction;
+    collator?: Intl.Collator;
+    layoutDelegate?: LayoutDelegate;
+    /** @deprecated - Use layoutDelegate instead. */
+    layout?: DeprecatedLayout;
+    focusMode?: 'row' | 'cell';
+}
+export declare class GridKeyboardDelegate<T, C extends GridCollection<T>> implements KeyboardDelegate {
+    collection: C;
+    protected disabledKeys: Set<Key>;
+    protected disabledBehavior: DisabledBehavior;
+    protected direction: Direction;
+    protected collator: Intl.Collator | undefined;
+    protected layoutDelegate: LayoutDelegate;
+    protected focusMode: 'row' | 'cell';
+    constructor(options: GridKeyboardDelegateOptions<C>);
+    protected isCell(node: Node<T>): boolean;
+    protected isRow(node: Node<T>): boolean;
+    private isDisabled;
+    protected findPreviousKey(fromKey?: Key, pred?: (item: Node<T>) => boolean): Key | null;
+    protected findNextKey(fromKey?: Key, pred?: (item: Node<T>) => boolean): Key | null;
+    protected getKeyForItemInRowByIndex(key: Key, index?: number): Key | null;
+    getKeyBelow(fromKey: Key): Key | null;
+    getKeyAbove(fromKey: Key): Key | null;
+    getKeyRightOf(key: Key): Key | null;
+    getKeyLeftOf(key: Key): Key | null;
+    getFirstKey(fromKey?: Key, global?: boolean): Key | null;
+    getLastKey(fromKey?: Key, global?: boolean): Key | null;
+    getKeyPageAbove(fromKey: Key): Key | null;
+    getKeyPageBelow(fromKey: Key): Key | null;
+    getKeyForSearch(search: string, fromKey?: Key): Key | null;
+}
+interface DeprecatedLayout {
+    getLayoutInfo(key: Key): DeprecatedLayoutInfo;
+    getContentSize(): Size;
+    virtualizer: DeprecatedVirtualizer;
+}
+interface DeprecatedLayoutInfo {
+    rect: Rect;
+}
+interface DeprecatedVirtualizer {
+    visibleRect: Rect;
+}
+export {};

package/dist/types/src/grid/useGrid.d.ts

@@ -0,0 +1,58 @@
+import { AriaLabelingProps, DOMAttributes, DOMProps, Key, KeyboardDelegate, RefObject } from '@react-types/shared';
+import { IGridCollection as GridCollection } from 'react-stately/private/grid/GridCollection';
+import { GridState } from 'react-stately/private/grid/useGridState';
+export interface GridProps extends DOMProps, AriaLabelingProps {
+    /** Whether the grid uses virtual scrolling. */
+    isVirtualized?: boolean;
+    /**
+     * Whether typeahead navigation is disabled.
+     * @default false
+     */
+    disallowTypeAhead?: boolean;
+    /**
+     * An optional keyboard delegate implementation for type to select,
+     * to override the default.
+     */
+    keyboardDelegate?: KeyboardDelegate;
+    /**
+     * Whether initial grid focus should be placed on the grid row or grid cell.
+     * @default 'row'
+     */
+    focusMode?: 'row' | 'cell';
+    /**
+     * A function that returns the text that should be announced by assistive technology when a row is added or removed from selection.
+     * @default (key) => state.collection.getItem(key)?.textValue
+     */
+    getRowText?: (key: Key) => string;
+    /**
+     * The ref attached to the scrollable body. Used to provided automatic scrolling on item focus for non-virtualized grids.
+     */
+    scrollRef?: RefObject<HTMLElement | null>;
+    /** Handler that is called when a user performs an action on the row. */
+    onRowAction?: (key: Key) => void;
+    /** Handler that is called when a user performs an action on the cell. */
+    onCellAction?: (key: Key) => void;
+    /**
+     * Whether pressing the escape key should clear selection in the grid or not.
+     *
+     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
+     * easily clear selection. Only use if the escape key is being handled externally or should not
+     * trigger selection clearing contextually.
+     * @default 'clearSelection'
+     */
+    escapeKeyBehavior?: 'clearSelection' | 'none';
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+}
+export interface GridAria {
+    /** Props for the grid element. */
+    gridProps: DOMAttributes;
+}
+/**
+ * Provides the behavior and accessibility implementation for a grid component.
+ * A grid displays data in one or more rows and columns and enables a user to navigate its contents via directional navigation keys.
+ * @param props - Props for the grid.
+ * @param state - State for the grid, as returned by `useGridState`.
+ * @param ref - The ref attached to the grid element.
+ */
+export declare function useGrid<T>(props: GridProps, state: GridState<T, GridCollection<T>>, ref: RefObject<HTMLElement | null>): GridAria;

package/dist/types/src/grid/useGridCell.d.ts

@@ -0,0 +1,33 @@
+import { DOMAttributes, FocusableElement, RefObject } from '@react-types/shared';
+import { IGridCollection as GridCollection, GridNode } from 'react-stately/private/grid/GridCollection';
+import { GridState } from 'react-stately/private/grid/useGridState';
+export interface GridCellProps {
+    /** An object representing the grid cell. Contains all the relevant information that makes up the grid cell. */
+    node: GridNode<unknown>;
+    /** Whether the grid cell is contained in a virtual scroller. */
+    isVirtualized?: boolean;
+    /** Whether the cell or its first focusable child element should be focused when the grid cell is focused. */
+    focusMode?: 'child' | 'cell';
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+    /** Indicates how many columns the data cell spans. */
+    colSpan?: number;
+    /**
+     * Handler that is called when a user performs an action on the cell.
+     * Please use onCellAction at the collection level instead.
+     * @deprecated
+     **/
+    onAction?: () => void;
+}
+export interface GridCellAria {
+    /** Props for the grid cell element. */
+    gridCellProps: DOMAttributes;
+    /** Whether the cell is currently in a pressed state. */
+    isPressed: boolean;
+}
+/**
+ * Provides the behavior and accessibility implementation for a cell in a grid.
+ * @param props - Props for the cell.
+ * @param state - State of the parent grid, as returned by `useGridState`.
+ */
+export declare function useGridCell<T, C extends GridCollection<T>>(props: GridCellProps, state: GridState<T, C>, ref: RefObject<FocusableElement | null>): GridCellAria;

package/dist/types/src/grid/useGridRow.d.ts

@@ -0,0 +1,30 @@
+import { DOMAttributes, FocusableElement, RefObject } from '@react-types/shared';
+import { IGridCollection as GridCollection, GridNode } from 'react-stately/private/grid/GridCollection';
+import { GridState } from 'react-stately/private/grid/useGridState';
+import { SelectableItemStates } from '../selection/useSelectableItem';
+export interface GridRowProps<T> {
+    /** An object representing the grid row. Contains all the relevant information that makes up the grid row. */
+    node: GridNode<T>;
+    /** Whether the grid row is contained in a virtual scroller. */
+    isVirtualized?: boolean;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+    /**
+     * Handler that is called when a user performs an action on the row.
+     * Please use onCellAction at the collection level instead.
+     * @deprecated
+     **/
+    onAction?: () => void;
+}
+export interface GridRowAria extends SelectableItemStates {
+    /** Props for the grid row element. */
+    rowProps: DOMAttributes;
+    /** Whether the row is currently in a pressed state. */
+    isPressed: boolean;
+}
+/**
+ * Provides the behavior and accessibility implementation for a row in a grid.
+ * @param props - Props for the row.
+ * @param state - State of the parent grid, as returned by `useGridState`.
+ */
+export declare function useGridRow<T, C extends GridCollection<T>, S extends GridState<T, C>>(props: GridRowProps<T>, state: S, ref: RefObject<FocusableElement | null>): GridRowAria;

package/dist/types/src/grid/useGridRowGroup.d.ts

@@ -0,0 +1,9 @@
+import { DOMAttributes } from '@react-types/shared';
+export interface GridRowGroupAria {
+    /** Props for the row group element. */
+    rowGroupProps: DOMAttributes;
+}
+/**
+ * Provides the accessibility implementation for a row group in a grid.
+ */
+export declare function useGridRowGroup(): GridRowGroupAria;

package/dist/types/src/grid/useGridSelectionAnnouncement.d.ts

@@ -0,0 +1,19 @@
+import { Collection, Key, Node } from '@react-types/shared';
+import { SelectionManager } from 'react-stately/private/selection/SelectionManager';
+export interface GridSelectionAnnouncementProps {
+    /**
+     * A function that returns the text that should be announced by assistive technology when a row is added or removed from selection.
+     * @default (key) => state.collection.getItem(key)?.textValue
+     */
+    getRowText?: (key: Key) => string;
+}
+interface GridSelectionState<T> {
+    /** A collection of items in the grid. */
+    collection: Collection<Node<T>>;
+    /** A set of items that are disabled. */
+    disabledKeys: Set<Key>;
+    /** A selection manager to read and update multiple selection state. */
+    selectionManager: SelectionManager;
+}
+export declare function useGridSelectionAnnouncement<T>(props: GridSelectionAnnouncementProps, state: GridSelectionState<T>): void;
+export {};

package/dist/types/src/grid/useGridSelectionCheckbox.d.ts

@@ -0,0 +1,18 @@
+import { AriaCheckboxProps } from '../checkbox/useCheckbox';
+import { IGridCollection as GridCollection } from 'react-stately/private/grid/GridCollection';
+import { GridState } from 'react-stately/private/grid/useGridState';
+import { Key } from '@react-types/shared';
+export interface AriaGridSelectionCheckboxProps {
+    /** A unique key for the checkbox. */
+    key: Key;
+}
+export interface GridSelectionCheckboxAria {
+    /** Props for the row selection checkbox element. */
+    checkboxProps: AriaCheckboxProps;
+}
+/**
+ * Provides the behavior and accessibility implementation for a selection checkbox in a grid.
+ * @param props - Props for the selection checkbox.
+ * @param state - State of the grid, as returned by `useGridState`.
+ */
+export declare function useGridSelectionCheckbox<T, C extends GridCollection<T>>(props: AriaGridSelectionCheckboxProps, state: GridState<T, C>): GridSelectionCheckboxAria;

package/dist/types/src/grid/useHighlightSelectionDescription.d.ts

@@ -0,0 +1,11 @@
+import { AriaLabelingProps } from '@react-types/shared';
+import { MultipleSelectionManager } from 'react-stately/useMultipleSelectionState';
+export interface HighlightSelectionDescriptionProps {
+    selectionManager: MultipleSelectionManager;
+    hasItemActions?: boolean;
+}
+/**
+ * Computes the description for a grid selectable collection.
+ * @param props
+ */
+export declare function useHighlightSelectionDescription(props: HighlightSelectionDescriptionProps): AriaLabelingProps;

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

@@ -0,0 +1,13 @@
+import type { IGridCollection as GridCollection } from 'react-stately/private/grid/GridCollection';
+import type { GridState } from 'react-stately/private/grid/useGridState';
+import type { Key, KeyboardDelegate } from '@react-types/shared';
+interface GridMapShared {
+    keyboardDelegate: KeyboardDelegate;
+    actions: {
+        onRowAction?: (key: Key) => void;
+        onCellAction?: (key: Key) => void;
+    };
+    shouldSelectOnPressUp?: boolean;
+}
+export declare const gridMap: WeakMap<GridState<unknown, GridCollection<unknown>>, GridMapShared>;
+export {};

package/dist/types/src/gridlist/useGridList.d.ts

@@ -0,0 +1,80 @@
+import { AriaLabelingProps, CollectionBase, DisabledBehavior, DOMAttributes, DOMProps, FocusStrategy, Key, KeyboardDelegate, LayoutDelegate, MultipleSelection, RefObject } from '@react-types/shared';
+import { ListState } from 'react-stately/useListState';
+export interface GridListProps<T> extends CollectionBase<T>, MultipleSelection {
+    /** Whether to auto focus the gridlist or an option. */
+    autoFocus?: boolean | FocusStrategy;
+    /**
+     * Handler that is called when a user performs an action on an item. The exact user event depends on
+     * the collection's `selectionBehavior` prop and the interaction modality.
+     */
+    onAction?: (key: Key) => void;
+    /**
+     * Whether `disabledKeys` applies to all interactions, or only selection.
+     * @default "all"
+     */
+    disabledBehavior?: DisabledBehavior;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+}
+export interface AriaGridListProps<T> extends GridListProps<T>, DOMProps, AriaLabelingProps {
+    /**
+     * Whether keyboard navigation to focusable elements within grid list items is
+     * via the left/right arrow keys or the tab key.
+     * @default 'arrow'
+     */
+    keyboardNavigationBehavior?: 'arrow' | 'tab';
+    /**
+     * Whether pressing the escape key should clear selection in the grid list or not.
+     *
+     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
+     * easily clear selection. Only use if the escape key is being handled externally or should not
+     * trigger selection clearing contextually.
+     * @default 'clearSelection'
+     */
+    escapeKeyBehavior?: 'clearSelection' | 'none';
+}
+export interface AriaGridListOptions<T> extends Omit<AriaGridListProps<T>, 'children'> {
+    /** Whether the list uses virtual scrolling. */
+    isVirtualized?: boolean;
+    /**
+     * Whether typeahead navigation is disabled.
+     * @default false
+     */
+    disallowTypeAhead?: boolean;
+    /**
+     * An optional keyboard delegate implementation for type to select,
+     * to override the default.
+     */
+    keyboardDelegate?: KeyboardDelegate;
+    /**
+     * A delegate object that provides layout information for items in the collection.
+     * By default this uses the DOM, but this can be overridden to implement things like
+     * virtualized scrolling.
+     */
+    layoutDelegate?: LayoutDelegate;
+    /**
+     * Whether focus should wrap around when the end/start is reached.
+     * @default false
+     */
+    shouldFocusWrap?: boolean;
+    /**
+     * The behavior of links in the collection.
+     * - 'action': link behaves like onAction.
+     * - 'selection': link follows selection interactions (e.g. if URL drives selection).
+     * - 'override': links override all other interactions (link items are not selectable).
+     * @default 'action'
+     */
+    linkBehavior?: 'action' | 'selection' | 'override';
+}
+export interface GridListAria {
+    /** Props for the grid element. */
+    gridProps: DOMAttributes;
+}
+/**
+ * Provides the behavior and accessibility implementation for a list component with interactive children.
+ * A grid list displays data in a single column and enables a user to navigate its contents via directional navigation keys.
+ * @param props - Props for the list.
+ * @param state - State for the list, as returned by `useListState`.
+ * @param ref - The ref attached to the list element.
+ */
+export declare function useGridList<T>(props: AriaGridListOptions<T>, state: ListState<T>, ref: RefObject<HTMLElement | null>): GridListAria;

package/dist/types/src/gridlist/useGridListItem.d.ts

@@ -0,0 +1,29 @@
+import { DOMAttributes, FocusableElement, RefObject, Node as RSNode } from '@react-types/shared';
+import type { ListState } from 'react-stately/useListState';
+import { SelectableItemStates } from '../selection/useSelectableItem';
+import type { TreeState } from 'react-stately/useTreeState';
+export interface AriaGridListItemOptions {
+    /** An object representing the list item. Contains all the relevant information that makes up the list row. */
+    node: RSNode<unknown>;
+    /** Whether the list row is contained in a virtual scroller. */
+    isVirtualized?: boolean;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+    /** Whether this item has children, even if not loaded yet. */
+    hasChildItems?: boolean;
+}
+export interface GridListItemAria extends SelectableItemStates {
+    /** Props for the list row element. */
+    rowProps: DOMAttributes;
+    /** Props for the grid cell element within the list row. */
+    gridCellProps: DOMAttributes;
+    /** Props for the list item description element, if any. */
+    descriptionProps: DOMAttributes;
+}
+/**
+ * Provides the behavior and accessibility implementation for a row in a grid list.
+ * @param props - Props for the row.
+ * @param state - State of the parent list, as returned by `useListState`.
+ * @param ref - The ref attached to the row element.
+ */
+export declare function useGridListItem<T>(props: AriaGridListItemOptions, state: ListState<T> | TreeState<T>, ref: RefObject<FocusableElement | null>): GridListItemAria;

package/dist/types/src/gridlist/useGridListSection.d.ts

@@ -0,0 +1,20 @@
+import { DOMAttributes, RefObject } from '@react-types/shared';
+import type { ListState } from 'react-stately/useListState';
+export interface AriaGridListSectionProps {
+    /** An accessibility label for the section. Required if `heading` is not present. */
+    'aria-label'?: string;
+}
+export interface GridListSectionAria {
+    /** Props for the wrapper list item. */
+    rowProps: DOMAttributes;
+    /** Props for the heading element, if any. */
+    rowHeaderProps: DOMAttributes;
+    /** Props for the grid's row group element. */
+    rowGroupProps: DOMAttributes;
+}
+/**
+ * Provides the behavior and accessibility implementation for a section in a grid list.
+ * See `useGridList` for more details about grid list.
+ * @param props - Props for the section.
+ */
+export declare function useGridListSection<T>(props: AriaGridListSectionProps, state: ListState<T>, ref: RefObject<HTMLElement | null>): GridListSectionAria;

package/dist/types/src/gridlist/useGridListSelectionCheckbox.d.ts

@@ -0,0 +1,8 @@
+import { AriaGridSelectionCheckboxProps, GridSelectionCheckboxAria } from '../grid/useGridSelectionCheckbox';
+import type { ListState } from 'react-stately/useListState';
+/**
+ * Provides the behavior and accessibility implementation for a selection checkbox in a grid list.
+ * @param props - Props for the selection checkbox.
+ * @param state - State of the list, as returned by `useListState`.
+ */
+export declare function useGridListSelectionCheckbox<T>(props: AriaGridSelectionCheckboxProps, state: ListState<T>): GridSelectionCheckboxAria;

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

@@ -0,0 +1,13 @@
+import { Key } from '@react-types/shared';
+import type { ListState } from 'react-stately/useListState';
+interface ListMapShared {
+    id: string;
+    onAction?: (key: Key) => void;
+    linkBehavior?: 'action' | 'selection' | 'override';
+    keyboardNavigationBehavior: 'arrow' | 'tab';
+    shouldSelectOnPressUp?: boolean;
+}
+export declare const listMap: WeakMap<ListState<unknown>, ListMapShared>;
+export declare function getRowId<T>(state: ListState<T>, key: Key): string;
+export declare function normalizeKey(key: Key): string;
+export {};

package/dist/types/src/i18n/I18nProvider.d.ts

@@ -0,0 +1,22 @@
+import { Direction } from '@react-types/shared';
+import { JSX, ReactNode } from 'react';
+export interface Locale {
+    /** The [BCP47](https://www.ietf.org/rfc/bcp/bcp47.txt) language code for the locale. */
+    locale: string;
+    /** The writing direction for the locale. */
+    direction: Direction;
+}
+export interface I18nProviderProps {
+    /** Contents that should have the locale applied. */
+    children: ReactNode;
+    /** The locale to apply to the children. */
+    locale?: string;
+}
+/**
+ * Provides the locale for the application to all child components.
+ */
+export declare function I18nProvider(props: I18nProviderProps): JSX.Element;
+/**
+ * Returns the current locale and layout direction.
+ */
+export declare function useLocale(): Locale;

package/dist/types/src/i18n/server.d.ts

@@ -0,0 +1,20 @@
+import type { LocalizedString } from '@internationalized/string';
+import { JSX } from 'react';
+type PackageLocalizedStrings = {
+    [packageName: string]: Record<string, LocalizedString>;
+};
+interface PackageLocalizationProviderProps {
+    locale: string;
+    strings: PackageLocalizedStrings;
+    nonce?: string;
+}
+/**
+ * A PackageLocalizationProvider can be rendered on the server to inject the localized strings
+ * needed by the client into the initial HTML.
+ */
+export declare function PackageLocalizationProvider(props: PackageLocalizationProviderProps): JSX.Element | null;
+/**
+ * Returns the content for an inline `<script>` tag to inject localized strings into initial HTML.
+ */
+export declare function getPackageLocalizationScript(locale: string, strings: PackageLocalizedStrings): string;
+export {};

package/dist/types/src/i18n/useCollator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provides localized string collation for the current locale. Automatically updates when the locale changes,
+ * and handles caching of the collator for performance.
+ * @param options - Collator options.
+ */
+export declare function useCollator(options?: Intl.CollatorOptions): Intl.Collator;

package/dist/types/src/i18n/useDateFormatter.d.ts

@@ -0,0 +1,10 @@
+import { DateFormatter } from '@internationalized/date';
+export interface DateFormatterOptions extends Intl.DateTimeFormatOptions {
+    calendar?: string;
+}
+/**
+ * Provides localized date formatting for the current locale. Automatically updates when the locale changes,
+ * and handles caching of the date formatter for performance.
+ * @param options - Formatting options.
+ */
+export declare function useDateFormatter(options?: DateFormatterOptions): DateFormatter;

package/dist/types/src/i18n/useDefaultLocale.d.ts

@@ -0,0 +1,9 @@
+import { Locale } from './I18nProvider';
+/**
+ * Gets the locale setting of the browser.
+ */
+export declare function getDefaultLocale(): Locale;
+/**
+ * Returns the current browser/system language, and updates when it changes.
+ */
+export declare function useDefaultLocale(): Locale;

package/dist/types/src/i18n/useFilter.d.ts

@@ -0,0 +1,13 @@
+export interface Filter {
+    /** Returns whether a string starts with a given substring. */
+    startsWith: (string: string, substring: string) => boolean;
+    /** Returns whether a string ends with a given substring. */
+    endsWith: (string: string, substring: string) => boolean;
+    /** Returns whether a string contains a given substring. */
+    contains: (string: string, substring: string) => boolean;
+}
+/**
+ * Provides localized string search functionality that is useful for filtering or matching items
+ * in a list. Options can be provided to adjust the sensitivity to case, diacritics, and other parameters.
+ */
+export declare function useFilter(options?: Intl.CollatorOptions): Filter;

package/dist/types/src/i18n/useListFormatter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provides localized list formatting for the current locale. Automatically updates when the locale changes,
+ * and handles caching of the list formatter for performance.
+ * @param options - Formatting options.
+ */
+export declare function useListFormatter(options?: Intl.ListFormatOptions): Intl.ListFormat;

package/dist/types/src/i18n/useLocalizedStringFormatter.d.ts

@@ -0,0 +1,11 @@
+import { LocalizedString, LocalizedStringDictionary, LocalizedStringFormatter, LocalizedStrings } from '@internationalized/string';
+/**
+ * Returns a cached LocalizedStringDictionary for the given strings.
+ */
+export declare function useLocalizedStringDictionary<K extends string = string, T extends LocalizedString = string>(strings: LocalizedStrings<K, T>, packageName?: string): LocalizedStringDictionary<K, T>;
+/**
+ * Provides localized string formatting for the current locale. Supports interpolating variables,
+ * selecting the correct pluralization, and formatting numbers. Automatically updates when the locale changes.
+ * @param strings - A mapping of languages to localized strings by key.
+ */
+export declare function useLocalizedStringFormatter<K extends string = string, T extends LocalizedString = string>(strings: LocalizedStrings<K, T>, packageName?: string): LocalizedStringFormatter<K, T>;

package/dist/types/src/i18n/useNumberFormatter.d.ts

@@ -0,0 +1,7 @@
+import { NumberFormatOptions } from '@internationalized/number';
+/**
+ * Provides localized number formatting for the current locale. Automatically updates when the locale changes,
+ * and handles caching of the number formatter for performance.
+ * @param options - Formatting options.
+ */
+export declare function useNumberFormatter(options?: NumberFormatOptions): Intl.NumberFormat;

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

@@ -0,0 +1,4 @@
+/**
+ * Determines if a locale is read right to left using [Intl.Locale]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale}.
+ */
+export declare function isRTL(localeString: string): boolean;

package/dist/types/src/interactions/PressResponder.d.ts

@@ -0,0 +1,11 @@
+import { FocusableElement } from '@react-types/shared';
+import { PressProps } from './usePress';
+import React, { JSX, ReactNode } from 'react';
+interface PressResponderProps extends PressProps {
+    children: ReactNode;
+}
+export declare const PressResponder: React.ForwardRefExoticComponent<PressResponderProps & React.RefAttributes<FocusableElement>>;
+export declare function ClearPressResponder({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+export {};

package/dist/types/src/interactions/Pressable.d.ts

@@ -0,0 +1,7 @@
+import { DOMAttributes, FocusableElement } from '@react-types/shared';
+import { PressProps } from './usePress';
+import React, { ReactElement } from 'react';
+export interface PressableProps extends PressProps {
+    children: ReactElement<DOMAttributes, string>;
+}
+export declare const Pressable: React.ForwardRefExoticComponent<PressableProps & React.RefAttributes<FocusableElement>>;

package/dist/types/src/interactions/context.d.ts

@@ -0,0 +1,9 @@
+import { FocusableElement } from '@react-types/shared';
+import { PressProps } from './usePress';
+import React, { MutableRefObject } from 'react';
+interface IPressResponderContext extends PressProps {
+    register(): void;
+    ref?: MutableRefObject<FocusableElement>;
+}
+export declare const PressResponderContext: React.Context<IPressResponderContext>;
+export {};

package/dist/types/src/interactions/createEventHandler.d.ts

@@ -0,0 +1,6 @@
+import { BaseEvent } from '@react-types/shared';
+import { SyntheticEvent } from 'react';
+/**
+ * This function wraps a React event handler to make stopPropagation the default, and support continuePropagation instead.
+ */
+export declare function createEventHandler<T extends SyntheticEvent>(handler?: (e: BaseEvent<T>) => void): ((e: T) => void) | undefined;

package/dist/types/src/interactions/focusSafely.d.ts

@@ -0,0 +1,6 @@
+import { FocusableElement } from '@react-types/shared';
+/**
+ * A utility function that focuses an element while avoiding undesired side effects such
+ * as page scrolling and screen reader issues with CSS transitions.
+ */
+export declare function focusSafely(element: FocusableElement): void;

package/dist/types/src/interactions/textSelection.d.ts

@@ -0,0 +1,2 @@
+export declare function disableTextSelection(target?: Element): void;
+export declare function restoreTextSelection(target?: Element): void;

package/dist/types/src/interactions/useFocus.d.ts

@@ -0,0 +1,14 @@
+import { DOMAttributes, FocusableElement, FocusEvents } from '@react-types/shared';
+export interface FocusProps<Target = FocusableElement> extends FocusEvents<Target> {
+    /** Whether the focus events should be disabled. */
+    isDisabled?: boolean;
+}
+export interface FocusResult<Target = FocusableElement> {
+    /** Props to spread onto the target element. */
+    focusProps: DOMAttributes<Target>;
+}
+/**
+ * Handles focus events for the immediate target.
+ * Focus events on child elements will be ignored.
+ */
+export declare function useFocus<Target extends FocusableElement = FocusableElement>(props: FocusProps<Target>): FocusResult<Target>;