react-stately 3.45.0 → 3.46.0

package/dist/types/src/list/useSingleSelectListState.d.ts

@@ -0,0 +1,21 @@
+import { CollectionStateBase, Key, Node, SingleSelection } from '@react-types/shared';
+import { ListState } from './useListState';
+export interface SingleSelectListProps<T> extends CollectionStateBase<T>, Omit<SingleSelection, 'disallowEmptySelection'> {
+    /** Filter function to generate a filtered list of nodes. */
+    filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>;
+    /** @private */
+    suppressTextValueWarning?: boolean;
+}
+export interface SingleSelectListState<T> extends ListState<T> {
+    /** The key for the currently selected item. */
+    readonly selectedKey: Key | null;
+    /** Sets the selected key. */
+    setSelectedKey(key: Key | null): void;
+    /** The value of the currently selected item. */
+    readonly selectedItem: Node<T> | null;
+}
+/**
+ * Provides state management for list-like components with single selection.
+ * Handles building a collection of items from props, and manages selection state.
+ */
+export declare function useSingleSelectListState<T extends object>(props: SingleSelectListProps<T>): SingleSelectListState<T>;

package/dist/types/src/menu/useMenuTriggerState.d.ts

@@ -0,0 +1,36 @@
+import { FocusStrategy, Key } from '@react-types/shared';
+import { OverlayTriggerProps, OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+export type MenuTriggerType = 'press' | 'longPress';
+export interface MenuTriggerProps extends OverlayTriggerProps {
+    /**
+     * How the menu is triggered.
+     * @default 'press'
+     */
+    trigger?: MenuTriggerType;
+}
+export interface MenuTriggerState extends OverlayTriggerState {
+    /** Controls which item will be auto focused when the menu opens. */
+    readonly focusStrategy: FocusStrategy | null;
+    /** Opens the menu. */
+    open(focusStrategy?: FocusStrategy | null): void;
+    /** Toggles the menu. */
+    toggle(focusStrategy?: FocusStrategy | null): void;
+}
+export interface RootMenuTriggerState extends MenuTriggerState {
+    /** Opens a specific submenu tied to a specific menu item at a specific level. */
+    openSubmenu: (triggerKey: Key, level: number) => void;
+    /** Closes a specific submenu tied to a specific menu item at a specific level. */
+    closeSubmenu: (triggerKey: Key, level: number) => void;
+    /** An array of open submenu trigger keys within the menu tree.
+     * The index of key within array matches the submenu level in the tree.
+     */
+    expandedKeysStack: Key[];
+    /** Closes the menu and all submenus in the menu tree. */
+    close: () => void;
+}
+/**
+ * Manages state for a menu trigger. Tracks whether the menu is currently open,
+ * and controls which item will receive focus when it opens. Also tracks the open submenus within
+ * the menu tree via their trigger keys.
+ */
+export declare function useMenuTriggerState(props: MenuTriggerProps): RootMenuTriggerState;

package/dist/types/src/menu/useSubmenuTriggerState.d.ts

@@ -0,0 +1,30 @@
+import { FocusStrategy, Key } from '@react-types/shared';
+import type { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+import { RootMenuTriggerState } from './useMenuTriggerState';
+export interface SubmenuTriggerProps {
+    /** Key of the trigger item. */
+    triggerKey: Key;
+}
+export interface SubmenuTriggerState extends OverlayTriggerState {
+    /** Whether the submenu is currently open. */
+    isOpen: boolean;
+    /** Controls which item will be auto focused when the submenu opens. */
+    focusStrategy: FocusStrategy | null;
+    /** Opens the submenu. */
+    open: (focusStrategy?: FocusStrategy | null) => void;
+    /** Closes the submenu. */
+    close: () => void;
+    /** Closes all menus and submenus in the menu tree. */
+    closeAll: () => void;
+    /** The level of the submenu. */
+    submenuLevel: number;
+    /** Toggles the submenu. */
+    toggle: (focusStrategy?: FocusStrategy | null) => void;
+    /** @private */
+    setOpen: () => void;
+}
+/**
+ * Manages state for a submenu trigger. Tracks whether the submenu is currently open, the level of the submenu, and
+ * controls which item will receive focus when it opens.
+ */
+export declare function useSubmenuTriggerState(props: SubmenuTriggerProps, state: RootMenuTriggerState): SubmenuTriggerState;

package/dist/types/src/numberfield/useNumberFieldState.d.ts

@@ -0,0 +1,76 @@
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, RangeInputBase, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+export interface NumberFieldProps extends InputBase, Validation<number>, FocusableProps, TextInputBase, ValueBase<number>, RangeInputBase<number>, LabelableProps, HelpTextProps {
+    /**
+     * Formatting options for the value displayed in the number field.
+     * This also affects what characters are allowed to be typed by the user.
+     */
+    formatOptions?: Intl.NumberFormatOptions;
+    /**
+     * Controls the behavior of the number field when the user blurs the field after editing.
+     * 'snap' will clamp the value to the min/max values, and snap to the nearest step value.
+     * 'validate' will not clamp the value, and will validate that the value is within the min/max range and on a valid step.
+     * @default 'snap'
+     */
+    commitBehavior?: 'snap' | 'validate';
+}
+export interface NumberFieldState extends FormValidationState {
+    /**
+     * The current text value of the input. Updated as the user types,
+     * and formatted according to `formatOptions` on blur.
+     */
+    inputValue: string;
+    /**
+     * The currently parsed number value, or NaN if a valid number could not be parsed.
+     * Updated based on the `inputValue` as the user types.
+     */
+    numberValue: number;
+    /** The default value of the input. */
+    defaultNumberValue: number;
+    /** The minimum value of the number field. */
+    minValue?: number;
+    /** The maximum value of the number field. */
+    maxValue?: number;
+    /** Whether the current value can be incremented according to the maximum value and step. */
+    canIncrement: boolean;
+    /** Whether the current value can be decremented according to the minimum value and step. */
+    canDecrement: boolean;
+    /**
+     * Validates a user input string according to the current locale and format options.
+     * Values can be partially entered, and may be valid even if they cannot currently be parsed to a number.
+     * Can be used to implement validation as a user types.
+     */
+    validate(value: string): boolean;
+    /** Sets the current text value of the input. */
+    setInputValue(val: string): void;
+    /** Sets the number value. */
+    setNumberValue(val: number): void;
+    /**
+     * Commits the current input value. The value is parsed to a number, clamped according
+     * to the minimum and maximum values of the field, and snapped to the nearest step value.
+     * This will fire the `onChange` prop with the new value, and if uncontrolled, update the `numberValue`.
+     * Typically this is called when the field is blurred.
+     * @param value - The value to commit. If not provided, the current input value is used.
+     */
+    commit(value?: string): void;
+    /** Increments the current input value to the next step boundary, and fires `onChange`. */
+    increment(): void;
+    /** Decrements the current input value to the next step boundary, and fires `onChange`. */
+    decrement(): void;
+    /** Sets the current value to the `maxValue` if any, and fires `onChange`. */
+    incrementToMax(): void;
+    /** Sets the current value to the `minValue` if any, and fires `onChange`. */
+    decrementToMin(): void;
+}
+export interface NumberFieldStateOptions extends NumberFieldProps {
+    /**
+     * The locale that should be used for parsing.
+     * @default 'en-US'
+     */
+    locale: string;
+}
+/**
+ * Provides state management for a number field component. Number fields allow users to enter a number,
+ * and increment or decrement the value using stepper buttons.
+ */
+export declare function useNumberFieldState(props: NumberFieldStateOptions): NumberFieldState;

package/dist/types/src/overlays/useOverlayTriggerState.d.ts

@@ -0,0 +1,25 @@
+export interface OverlayTriggerProps {
+    /** Whether the overlay is open by default (controlled). */
+    isOpen?: boolean;
+    /** Whether the overlay is open by default (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Handler that is called when the overlay's open state changes. */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export interface OverlayTriggerState {
+    /** Whether the overlay is currently open. */
+    readonly isOpen: boolean;
+    /** Sets whether the overlay is open. */
+    setOpen(isOpen: boolean): void;
+    /** Opens the overlay. */
+    open(): void;
+    /** Closes the overlay. */
+    close(): void;
+    /** Toggles the overlay's visibility. */
+    toggle(): void;
+}
+/**
+ * Manages state for an overlay trigger. Tracks whether the overlay is open, and provides
+ * methods to toggle this state.
+ */
+export declare function useOverlayTriggerState(props: OverlayTriggerProps): OverlayTriggerState;

package/dist/types/src/radio/useRadioGroupState.d.ts

@@ -0,0 +1,45 @@
+import { FocusEvents, HelpTextProps, InputBase, InputDOMProps, LabelableProps, Orientation, Validation, ValidationState, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+export interface RadioGroupProps extends ValueBase<string | null, string>, InputBase, Pick<InputDOMProps, 'name'>, Validation<string>, LabelableProps, HelpTextProps, FocusEvents {
+    /**
+     * The axis the Radio Button(s) should align with.
+     * @default 'vertical'
+     */
+    orientation?: Orientation;
+}
+export interface RadioGroupState extends FormValidationState {
+    /**
+     * The name for the group, used for native form submission.
+     * @deprecated
+     * @private
+     */
+    readonly name: string;
+    /** Whether the radio group is disabled. */
+    readonly isDisabled: boolean;
+    /** Whether the radio group is read only. */
+    readonly isReadOnly: boolean;
+    /** Whether the radio group is required. */
+    readonly isRequired: boolean;
+    /**
+     * Whether the radio group is valid or invalid.
+     * @deprecated Use `isInvalid` instead.
+     */
+    readonly validationState: ValidationState | null;
+    /** Whether the radio group is invalid. */
+    readonly isInvalid: boolean;
+    /** The currently selected value. */
+    readonly selectedValue: string | null;
+    /** The default selected value. */
+    readonly defaultSelectedValue: string | null;
+    /** Sets the selected value. */
+    setSelectedValue(value: string | null): void;
+    /** The value of the last focused radio. */
+    readonly lastFocusedValue: string | null;
+    /** Sets the last focused value. */
+    setLastFocusedValue(value: string | null): void;
+}
+/**
+ * Provides state management for a radio group component. Provides a name for the group,
+ * and manages selection and focus state.
+ */
+export declare function useRadioGroupState(props: RadioGroupProps): RadioGroupState;

package/dist/types/src/searchfield/useSearchFieldState.d.ts

@@ -0,0 +1,19 @@
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+export interface TextFieldProps<T = HTMLInputElement> extends InputBase, Validation<string>, HelpTextProps, FocusableProps<T>, TextInputBase, ValueBase<string>, LabelableProps {
+}
+export interface SearchFieldProps extends TextFieldProps {
+    /** Handler that is called when the SearchField is submitted. */
+    onSubmit?: (value: string) => void;
+    /** Handler that is called when the clear button is pressed. */
+    onClear?: () => void;
+}
+export interface SearchFieldState {
+    /** The current value of the search field. */
+    readonly value: string;
+    /** Sets the value of the search field. */
+    setValue(value: string): void;
+}
+/**
+ * Provides state management for a search field.
+ */
+export declare function useSearchFieldState(props: SearchFieldProps): SearchFieldState;

package/dist/types/src/select/useSelectState.d.ts

@@ -0,0 +1,89 @@
+import { CollectionBase, CollectionStateBase, FocusableProps, FocusStrategy, HelpTextProps, InputBase, Key, LabelableProps, Node, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+import { ListState } from '../list/useListState';
+import { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+export type SelectionMode = 'single' | 'multiple';
+export type ValueType<M extends SelectionMode> = M extends 'single' ? Key | null : readonly Key[];
+export type ChangeValueType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
+type ValidationType<M extends SelectionMode> = M extends 'single' ? Key : Key[];
+export interface SelectProps<T, M extends SelectionMode = 'single'> extends CollectionBase<T>, Omit<InputBase, 'isReadOnly'>, ValueBase<ValueType<M>, ChangeValueType<M>>, Validation<ValidationType<M>>, HelpTextProps, LabelableProps, TextInputBase, FocusableProps {
+    /**
+     * Whether single or multiple selection is enabled.
+     * @default 'single'
+     */
+    selectionMode?: M;
+    /**
+     * The currently selected key in the collection (controlled).
+     * @deprecated
+     */
+    selectedKey?: Key | null;
+    /**
+     * The initial selected key in the collection (uncontrolled).
+     * @deprecated
+     */
+    defaultSelectedKey?: Key | null;
+    /**
+     * Handler that is called when the selection changes.
+     * @deprecated
+     */
+    onSelectionChange?: (key: Key | null) => void;
+    /** Sets the open state of the menu. */
+    isOpen?: boolean;
+    /** Sets the default open state of the menu. */
+    defaultOpen?: boolean;
+    /** Method that is called when the open state of the menu changes. */
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Whether the Select should close when an item is selected. Defaults to true if selectionMode is single, false otherwise. */
+    shouldCloseOnSelect?: boolean;
+    /** Whether the select should be allowed to be open when the collection is empty. */
+    allowsEmptyCollection?: boolean;
+}
+export interface SelectStateOptions<T, M extends SelectionMode = 'single'> extends Omit<SelectProps<T, M>, 'children'>, CollectionStateBase<T> {
+}
+export interface SelectState<T, M extends SelectionMode = 'single'> extends ListState<T>, OverlayTriggerState, FormValidationState {
+    /**
+     * The key for the first selected item.
+     * @deprecated
+     */
+    readonly selectedKey: Key | null;
+    /**
+     * The default selected key.
+     * @deprecated
+     */
+    readonly defaultSelectedKey: Key | null;
+    /**
+     * Sets the selected key.
+     * @deprecated
+     */
+    setSelectedKey(key: Key | null): void;
+    /** The current select value. */
+    readonly value: ValueType<M>;
+    /** The default select value. */
+    readonly defaultValue: ValueType<M>;
+    /** Sets the select value. */
+    setValue(value: Key | readonly Key[] | null): void;
+    /**
+     * The value of the first selected item.
+     * @deprecated
+     */
+    readonly selectedItem: Node<T> | null;
+    /** The value of the selected items. */
+    readonly selectedItems: Node<T>[];
+    /** Whether the select is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the select is focused. */
+    setFocused(isFocused: boolean): void;
+    /** Controls which item will be auto focused when the menu opens. */
+    readonly focusStrategy: FocusStrategy | null;
+    /** Opens the menu. */
+    open(focusStrategy?: FocusStrategy | null): void;
+    /** Toggles the menu. */
+    toggle(focusStrategy?: FocusStrategy | null): void;
+}
+/**
+ * Provides state management for a select component. Handles building a collection
+ * of items from props, handles the open state for the popup menu, and manages
+ * multiple selection state.
+ */
+export declare function useSelectState<T extends object, M extends SelectionMode = 'single'>(props: SelectStateOptions<T, M>): SelectState<T, M>;
+export {};

package/dist/types/src/selection/Selection.d.ts

@@ -0,0 +1,10 @@
+import { Key } from '@react-types/shared';
+/**
+ * A Selection is a special Set containing Keys, which also has an anchor
+ * and current selected key for use when range selecting.
+ */
+export declare class Selection extends Set<Key> {
+    anchorKey: Key | null;
+    currentKey: Key | null;
+    constructor(keys?: Iterable<Key> | Selection, anchorKey?: Key | null, currentKey?: Key | null);
+}

package/dist/types/src/selection/SelectionManager.d.ts

@@ -0,0 +1,122 @@
+import { Collection, DisabledBehavior, FocusStrategy, Selection as ISelection, Key, LayoutDelegate, LongPressEvent, Node, PressEvent, SelectionBehavior, SelectionMode } from '@react-types/shared';
+import { MultipleSelectionManager, MultipleSelectionState } from './types';
+interface SelectionManagerOptions {
+    allowsCellSelection?: boolean;
+    layoutDelegate?: LayoutDelegate;
+    fullCollection?: Collection<Node<unknown>>;
+}
+/**
+ * An interface for reading and updating multiple selection state.
+ */
+export declare class SelectionManager implements MultipleSelectionManager {
+    collection: Collection<Node<unknown>>;
+    private state;
+    private allowsCellSelection;
+    private _isSelectAll;
+    private layoutDelegate;
+    private fullCollection;
+    constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
+    /**
+     * The type of selection that is allowed in the collection.
+     */
+    get selectionMode(): SelectionMode;
+    /**
+     * Whether the collection allows empty selection.
+     */
+    get disallowEmptySelection(): boolean;
+    /**
+     * The selection behavior for the collection.
+     */
+    get selectionBehavior(): SelectionBehavior;
+    /**
+     * Sets the selection behavior for the collection.
+     */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /**
+     * Whether the collection is currently focused.
+     */
+    get isFocused(): boolean;
+    /**
+     * Sets whether the collection is focused.
+     */
+    setFocused(isFocused: boolean): void;
+    /**
+     * The current focused key in the collection.
+     */
+    get focusedKey(): Key | null;
+    /** Whether the first or last child of the focused key should receive focus. */
+    get childFocusStrategy(): FocusStrategy | null;
+    /**
+     * Sets the focused key.
+     */
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+    /**
+     * The currently selected keys in the collection.
+     */
+    get selectedKeys(): Set<Key>;
+    /**
+     * The raw selection value for the collection.
+     * Either 'all' for select all, or a set of keys.
+     */
+    get rawSelection(): ISelection;
+    /**
+     * Returns whether a key is selected.
+     */
+    isSelected(key: Key): boolean;
+    /**
+     * Whether the selection is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Whether all items in the collection are selected.
+     */
+    get isSelectAll(): boolean;
+    get firstSelectedKey(): Key | null;
+    get lastSelectedKey(): Key | null;
+    get disabledKeys(): Set<Key>;
+    get disabledBehavior(): DisabledBehavior;
+    /**
+     * Extends the selection to the given key.
+     */
+    extendSelection(toKey: Key): void;
+    private getKeyRange;
+    private getKeyRangeInternal;
+    private getKey;
+    /**
+     * Toggles whether the given key is selected.
+     */
+    toggleSelection(key: Key): void;
+    /**
+     * Replaces the selection with only the given key.
+     */
+    replaceSelection(key: Key): void;
+    /**
+     * Replaces the selection with the given keys.
+     */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    private getSelectAllKeys;
+    /**
+     * Selects all items in the collection.
+     */
+    selectAll(): void;
+    /**
+     * Removes all keys from the selection.
+     */
+    clearSelection(): void;
+    /**
+     * Toggles between select all and an empty selection.
+     */
+    toggleSelectAll(): void;
+    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
+    /**
+     * Returns whether the current selection is equal to the given selection.
+     */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    canSelectItem(key: Key): boolean;
+    private canSelectItemIn;
+    isDisabled(key: Key): boolean;
+    isLink(key: Key): boolean;
+    getItemProps(key: Key): any;
+    withCollection(collection: Collection<Node<unknown>>): SelectionManager;
+}
+export {};

package/dist/types/src/selection/types.d.ts

@@ -0,0 +1,96 @@
+import { Collection, DisabledBehavior, FocusStrategy, Key, LongPressEvent, Node, PressEvent, Selection, SelectionBehavior, SelectionMode } from '@react-types/shared';
+export interface FocusState {
+    /** Whether the collection is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the collection is focused. */
+    setFocused(isFocused: boolean): void;
+    /** The current focused key in the collection. */
+    readonly focusedKey: Key | null;
+    /** Whether the first or last child of the focused key should receive focus. */
+    readonly childFocusStrategy: FocusStrategy | null;
+    /** Sets the focused key, and optionally, whether the first or last child of that key should receive focus. */
+    setFocusedKey(key: Key | null, child?: FocusStrategy): void;
+}
+export interface SingleSelectionState extends FocusState {
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection?: boolean;
+    /** The currently selected key in the collection. */
+    readonly selectedKey: Key;
+    /** Sets the selected key in the collection. */
+    setSelectedKey(key: Key | null): void;
+}
+export interface MultipleSelectionState extends FocusState {
+    /** The type of selection that is allowed in the collection. */
+    readonly selectionMode: SelectionMode;
+    /** The selection behavior for the collection. */
+    readonly selectionBehavior: SelectionBehavior;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection: boolean;
+    /** The currently selected keys in the collection. */
+    readonly selectedKeys: Selection;
+    /** Sets the selected keys in the collection. */
+    setSelectedKeys(keys: Selection): void;
+    /** The currently disabled keys in the collection. */
+    readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to selection, actions, or both. */
+    readonly disabledBehavior: DisabledBehavior;
+}
+export interface MultipleSelectionManager extends FocusState {
+    /** The type of selection that is allowed in the collection. */
+    readonly selectionMode: SelectionMode;
+    /** The selection behavior for the collection. */
+    readonly selectionBehavior: SelectionBehavior;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection?: boolean;
+    /** The currently selected keys in the collection. */
+    readonly selectedKeys: Set<Key>;
+    /** Whether the selection is empty. */
+    readonly isEmpty: boolean;
+    /** Whether all items in the collection are selected. */
+    readonly isSelectAll: boolean;
+    /** The first selected key in the collection. */
+    readonly firstSelectedKey: Key | null;
+    /** The last selected key in the collection. */
+    readonly lastSelectedKey: Key | null;
+    /** The currently disabled keys in the collection. */
+    readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to selection, actions, or both. */
+    readonly disabledBehavior: DisabledBehavior;
+    /** Returns whether a key is selected. */
+    isSelected(key: Key): boolean;
+    /** Returns whether the current selection is equal to the given selection. */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    /** Extends the selection to the given key. */
+    extendSelection(toKey: Key): void;
+    /** Toggles whether the given key is selected. */
+    toggleSelection(key: Key): void;
+    /** Replaces the selection with only the given key. */
+    replaceSelection(key: Key): void;
+    /** Replaces the selection with the given keys. */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    /** Selects all items in the collection. */
+    selectAll(): void;
+    /** Removes all keys from the selection. */
+    clearSelection(): void;
+    /** Toggles between select all and an empty selection. */
+    toggleSelectAll(): void;
+    /**
+     * Toggles, replaces, or extends selection to the given key depending
+     * on the pointer event and collection's selection mode.
+     */
+    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
+    /** Returns whether the given key can be selected. */
+    canSelectItem(key: Key): boolean;
+    /** Returns whether the given key is non-interactive, i.e. both selection and actions are disabled. */
+    isDisabled(key: Key): boolean;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /** Returns whether the given key is a hyperlink. */
+    isLink(key: Key): boolean;
+    /** Returns the props for the given item. */
+    getItemProps(key: Key): any;
+    /** The collection of nodes that the selection manager handles. */
+    collection: Collection<Node<unknown>>;
+}

package/dist/types/src/selection/useMultipleSelectionState.d.ts

@@ -0,0 +1,20 @@
+import { DisabledBehavior, MultipleSelection, SelectionBehavior } from '@react-types/shared';
+import { MultipleSelectionState } from './types';
+export interface MultipleSelectionStateProps extends MultipleSelection {
+    /**
+     * How multiple selection should behave in the collection.
+     * @default 'toggle'
+     */
+    selectionBehavior?: SelectionBehavior;
+    /** Whether onSelectionChange should fire even if the new set of keys is the same as the last. */
+    allowDuplicateSelectionEvents?: boolean;
+    /**
+     * Whether `disabledKeys` applies to all interactions, or only selection.
+     * @default 'all'
+     */
+    disabledBehavior?: DisabledBehavior;
+}
+/**
+ * Manages state for multiple selection and focus in a collection.
+ */
+export declare function useMultipleSelectionState(props: MultipleSelectionStateProps): MultipleSelectionState;