@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/form/field-error.jsx

@@ -0,0 +1,67 @@
+// Ported from react-aria-components `FieldError` (packages/react-aria-components/src/FieldError.tsx), Apache-2.0, © Adobe.
+// A FieldError displays validation errors for a form field.
+// Rivet:
+// - `FieldErrorContext` is resumable (`rv-field-error`); fields provide their validation as an accessor
+//   (`() => displayValidation(state.validation)`) or a plain `ValidationResult`.
+// - nothing renders while the field is valid (or the children resolve to `null`): a `<Show>` region, so a
+//   field turning invalid on the client mounts the `<Text slot="errorMessage">` (its slot id puts the
+//   error id in the field's `aria-describedby` while it renders).
+// - render props are accessors (`{({ validationErrors }) => validationErrors().join(", ")}`); `class` / `style`
+//   may be functions of them (RAC `className` → `class`).
+// - `render` (RAC DOMRenderProps) is forwarded to the `Text` element it renders (`render(attrs, undefined)`), so it only runs while there is an error.
+import { createContext, useContext } from "@rivetjs/reactivity";
+import { Show } from "@rivetjs/runtime/dom";
+import { read } from "../state/form-validation.js";
+import { globalDOMProps } from "../utils/dom-props.js";
+import { resumableContext } from "../slots/index.jsx";
+import { isSlot } from "@rivetjs/runtime/slot";
+import {} from "../utils/render.js";
+import { Text } from "../text/index.jsx";
+import { renderPropsOf } from "../slots/index.jsx";
+import { slotProbing } from "#server";
+/** RAC `FieldErrorContext`: the validation of the enclosing field (`null` outside a field). */
+export const FieldErrorContext = resumableContext(createContext(null, { id: "rv-field-error" }));
+const OWNED = ["style", "class", "children", "elementType", "ref", "render"];
+/**
+ * A FieldError displays validation errors for a form field.
+ */
+export function FieldError(props) {
+    // A field's server slot probe (`probeSlots`): nothing to mark — owners keep the error id while invalid
+    // (`slotIdRef(errorId, isInvalid())`, RAC FieldError renders only then).
+    if (slotProbing)
+        return null;
+    const context = useContext(FieldErrorContext);
+    const validation = () => read(context ?? null);
+    const values = {
+        isInvalid: () => validation()?.isInvalid ?? false,
+        validationErrors: () => validation()?.validationErrors ?? [],
+        validationDetails: () => validation().validationDetails,
+    };
+    const rp = renderPropsOf(props, {
+        defaultClassName: "rv-FieldError",
+        values,
+    });
+    const defaultChildren = () => {
+        const errors = values.validationErrors();
+        return errors.length === 0 ? undefined : errors.join(" ");
+    };
+    // RAC: no error → nothing; children resolving to null → nothing.
+    const content = () => {
+        if (!values.isInvalid())
+            return null;
+        // Plain JSX children are a compiler slot: one resolving to `undefined` (`{cond ? msg : undefined}`) is RAC's
+        // `children == null` → the default children (a render-function child returning null still renders nothing).
+        const children = props.children === undefined ? defaultChildren() : (rp.children() ?? (isSlot(props.children) ? defaultChildren() : undefined));
+        return children == null ? null : { children };
+    };
+    const dom = globalDOMProps(props, OWNED);
+    const id = props.id;
+    const elementType = props.elementType;
+    const ref = props.ref;
+    const render = props.render;
+    return (<Show when={content}>
+      {(get) => (<Text {...dom} slot="errorMessage" id={id} elementType={elementType} ref={ref} render={render} class={rp.class()} style={rp.style()}>
+          {() => get()?.children}
+        </Text>)}
+    </Show>);
+}

package/form/index.d.ts

@@ -0,0 +1,77 @@
+import type { Content } from "@rivetjs/runtime/jsx-runtime";
+import type { MaybeAccessor, ValidationBehavior, ValidationErrors } from "../state/form-validation.js";
+import { type GlobalDOMAttributes } from "../utils/dom-props.js";
+import { type ContextValue, type RefValue, type SlotProps } from "../slots/index.jsx";
+import { type DOMRenderProps } from "../utils/render.js";
+export type { ValidationBehavior, ValidationErrors, ValidationResult, ValidationFunction } from "../state/form-validation.js";
+export { FieldError, FieldErrorContext, type FieldErrorProps, type FieldErrorRenderProps } from "./field-error.jsx";
+/** `@react-types/shared` `FormProps` + RAC `FormProps`. */
+export interface FormProps extends GlobalDOMAttributes<HTMLFormElement>, SlotProps, DOMRenderProps<"form", undefined> {
+    /**
+     * Validation errors for the form, typically returned by a server.
+     * This should be set to an object mapping from input names to errors (object, signal or accessor).
+     */
+    validationErrors?: MaybeAccessor<ValidationErrors | undefined>;
+    /**
+     * Whether to use native HTML form validation to prevent form submission
+     * when a field value is missing or invalid, or mark fields as required
+     * or invalid via ARIA.
+     *
+     * @default 'native'
+     */
+    validationBehavior?: ValidationBehavior;
+    /** Where to send the form-data when the form is submitted. */
+    action?: string;
+    /** The HTTP method to submit the form with. */
+    method?: "get" | "post" | "dialog";
+    /** The encoding type when the form is submitted. */
+    encType?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    /** Where to display the response after submitting the form. */
+    target?: "_blank" | "_self" | "_parent" | "_top" | (string & {});
+    /** Indicates whether input elements can by default have their values automatically completed by the browser. */
+    autoComplete?: "off" | "on";
+    /** Controls whether inputted text is automatically capitalized and, if so, in what manner. */
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters";
+    /** An ARIA role override for the form element. */
+    role?: "search" | "presentation";
+    /** The form's name. */
+    name?: string;
+    /** The element's unique identifier. */
+    id?: string;
+    /**
+     * The CSS class for the element.
+     *
+     * @default 'rv-Form'
+     */
+    class?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-details"?: string;
+    /** Triggered when a user submits the form (after pending field validity was applied and the form is valid). */
+    onSubmit?: (event: SubmitEvent) => void;
+    /** Triggered when a user resets the form. */
+    onReset?: (event: Event) => void;
+    /** Triggered for each invalid field when a user submits the form; `preventDefault()` keeps the first invalid field from focusing. */
+    onInvalid?: (event: Event) => void;
+    ref?: RefValue<HTMLFormElement>;
+    /** The children of the form. */
+    children?: Content | (() => Content);
+}
+/** RAC `FormContext`: props for a `<Form>` inside; the `<Form>` provides `{ validationBehavior }` to its fields. */
+export declare const FormContext: import("@rivetjs/reactivity").Context<ContextValue<FormProps, HTMLFormElement>>;
+/** RAC `FormValidationContext` (react-stately): server errors per field name. */
+export declare const FormValidationContext: import("@rivetjs/reactivity").Context<MaybeAccessor<ValidationErrors | undefined>>;
+/** Validation behaviour of a field: its own prop, else the enclosing `<Form>`'s, else "native" (RAC fields). */
+export declare function formValidationBehavior(own: ValidationBehavior | undefined): ValidationBehavior;
+/** Server errors of the enclosing `<Form>` (accessor or object), if any (RS `useContext(FormValidationContext)`). */
+export declare function formValidationErrors(): MaybeAccessor<ValidationErrors | undefined> | undefined;
+/** @deprecated migration shim — remove when no importer (use `formValidationBehavior`). */
+export declare const useValidationBehavior: typeof formValidationBehavior;
+/** @deprecated migration shim — remove when no importer (use `formValidationErrors`). */
+export declare const useValidationErrors: typeof formValidationErrors;
+/**
+ * A form is a group of inputs that allows users to submit data to a server,
+ * with support for providing field validation errors.
+ */
+export declare function Form(props: FormProps): import("@rivetjs/runtime/jsx-runtime").CompiledElement;

package/form/index.jsx

@@ -0,0 +1,116 @@
+// Ported from react-aria-components `Form` (packages/react-aria-components/src/Form.tsx), Apache-2.0, © Adobe.
+// A form is a group of inputs that allows users to submit data to a server, with support for providing
+// field validation errors.
+// Rivet:
+// - plain JSX children are lazy (the compiler compiles them to a slot evaluated inside the parent,
+//   `renderSlot`), so the fields see the Form contexts; a function child `{() => …}` works too.
+// - `FormContext` (`rv-form`) and `FormValidationContext` (`rv-form-validation`) are resumable. The form
+//   provides `{ validationBehavior }` in `FormContext` (RAC: all of its props): provided values must
+//   serialize, and fields only read `validationBehavior`.
+// - `onInvalid` is bound in the capture phase (`invalid` does not bubble): it sees each field's `invalid`
+//   event before the field's own handler, like React's form `onInvalid`, so `preventDefault()` there
+//   keeps the field from focusing itself (RA `useFormValidation`).
+// - native mode: fields never interacted with get their custom validity on submit (`formSubmit`, see
+//   behaviour.ts) — no layout effect runs before interaction.
+// `render` (RAC DOMRenderProps): given, the attributes go to `render(attrs, undefined)` instead of the default `<form>`. Deviations: `action` is a URL string (no React form actions).
+import { createContext, useContext } from "@rivetjs/reactivity";
+import { clientEffect, Provider, ref as createRef } from "@rivetjs/runtime/dom";
+import { renderSlot } from "@rivetjs/runtime/slot";
+import { globalDOMProps } from "../utils/dom-props.js";
+import { resumableContext, contextProps, mergeRefValues, slottedContext } from "../slots/index.jsx";
+import {} from "../utils/render.js";
+import { applyPendingValidity, formSubmit } from "./behaviour.js";
+import { isLive, liveAssign, liveClass } from "../utils/live.jsx";
+export { FieldError, FieldErrorContext } from "./field-error.jsx";
+/** RAC `FormContext`: props for a `<Form>` inside; the `<Form>` provides `{ validationBehavior }` to its fields. */
+export const FormContext = resumableContext(createContext(null, { id: "rv-form" }));
+/** RAC `FormValidationContext` (react-stately): server errors per field name. */
+export const FormValidationContext = resumableContext(createContext(undefined, { id: "rv-form-validation" }));
+/** Validation behaviour of a field: its own prop, else the enclosing `<Form>`'s, else "native" (RAC fields). */
+export function formValidationBehavior(own) {
+    return own ?? slottedContext(FormContext)?.validationBehavior ?? "native";
+}
+/** Server errors of the enclosing `<Form>` (accessor or object), if any (RS `useContext(FormValidationContext)`). */
+export function formValidationErrors() {
+    return useContext(FormValidationContext);
+}
+/** @deprecated migration shim — remove when no importer (use `formValidationBehavior`). */
+export const useValidationBehavior = formValidationBehavior;
+/** @deprecated migration shim — remove when no importer (use `formValidationErrors`). */
+export const useValidationErrors = formValidationErrors;
+/**
+ * A form is a group of inputs that allows users to submit data to a server,
+ * with support for providing field validation errors.
+ */
+export function Form(props) {
+    const [merged, ref] = contextProps(props, props.ref, FormContext);
+    const { validationErrors, validationBehavior = "native", children, onSubmit, onReset, onInvalid, render } = merged;
+    // `autocomplete` / `autocapitalize` are not in the form element typings: spread with the DOM props.
+    // Live props (P5): a live `class` goes through the spread as an accessor.
+    const className = (isLive(merged, "class") ? liveClass(merged, "rv-Form") : merged.class || "rv-Form");
+    const dom = liveAssign(globalDOMProps(merged, ["render"]), { autocomplete: merged.autoComplete, autocapitalize: merged.autoCapitalize, class: className });
+    const id = merged.id;
+    const slot = merged.slot || undefined;
+    const { action, method, encType, target, role, name } = merged;
+    const ariaLabel = merged["aria-label"];
+    const ariaLabelledby = merged["aria-labelledby"];
+    const ariaDescribedby = merged["aria-describedby"];
+    const ariaDetails = merged["aria-details"];
+    const formValue = { validationBehavior };
+    const errors = validationErrors ?? {};
+    const formRef = createRef();
+    const formElementRef = mergeRefValues(formRef, ref);
+    if (typeof validationErrors === "function") {
+        // RA useFormValidation's layout effect for server errors that change on the client (e.g. after a
+        // submit): native mode re-applies every field's `data-rv-error` as custom validity once the
+        // bindings settled. Static errors need no effect (applied on submit).
+        clientEffect(() => {
+            validationErrors();
+            const form = formRef();
+            if (form && !form.noValidate)
+                queueMicrotask(() => applyPendingValidity(form));
+        });
+    }
+    if (render)
+        return render({
+            ...dom,
+            ref: formElementRef,
+            id,
+            class: className,
+            slot,
+            action,
+            method,
+            encType,
+            target,
+            role,
+            name,
+            "aria-label": ariaLabel,
+            "aria-labelledby": ariaLabelledby,
+            "aria-describedby": ariaDescribedby,
+            "aria-details": ariaDetails,
+            noValidate: validationBehavior !== "native" ? true : undefined,
+            onSubmit: (event) => {
+                formSubmit(event);
+                if (!event.defaultPrevented && onSubmit)
+                    onSubmit(event);
+            },
+            onReset: (event) => onReset?.(event),
+            onInvalidCapture: (event) => onInvalid?.(event),
+            children: () => (<Provider token={FormContext} value={formValue}>
+            <Provider token={FormValidationContext} value={errors}>
+              {renderSlot(children)}
+            </Provider>
+          </Provider>),
+        }, undefined);
+    return (<form {...dom} ref={formElementRef} id={id} slot={slot} action={action} method={method} encType={encType} target={target} role={role} name={name} aria-label={ariaLabel} aria-labelledby={ariaLabelledby} aria-describedby={ariaDescribedby} aria-details={ariaDetails} noValidate={validationBehavior !== "native" ? true : undefined} onSubmit={(event) => {
+            formSubmit(event);
+            if (!event.defaultPrevented && onSubmit)
+                onSubmit(event);
+        }} onReset={(event) => onReset?.(event)} onInvalidCapture={(event) => onInvalid?.(event)}>
+      <Provider token={FormContext} value={formValue}>
+        <Provider token={FormValidationContext} value={errors}>
+          {renderSlot(children)}
+        </Provider>
+      </Provider>
+    </form>);
+}

package/grid/behaviour.d.ts

@@ -0,0 +1,290 @@
+import type { Collection, Direction, Key, KeyboardDelegate, LayoutDelegate, Node, Selection } from "../collections/types.js";
+import type { GridNode, IGridCollection } from "../collections/grid.js";
+import type { MultipleSelectionManager, SelectionManager } from "../selection/manager.js";
+import type { GridState } from "../state/grid.js";
+import { type SelectableItemStates } from "../selection/selectable-item.js";
+import { type RefLike } from "../selection/utils.js";
+/** Localized-string option shared by the grid hooks. */
+export interface GridLocaleProps {
+    /** Locale of the strings (default "en-US"). */
+    locale?: string | undefined;
+}
+export interface AriaGridSelectionCheckboxProps extends GridLocaleProps {
+    /** A unique key for the checkbox. */
+    key: Key;
+    /** Id of the checkbox (react-aria generates one per hook call). */
+    id?: string | undefined;
+}
+/** react-aria `AriaCheckboxProps` subset the selection checkbox sets (`onChange`: `gridSelectionCheckboxChange`). */
+export interface GridSelectionCheckboxProps {
+    id: string;
+    "aria-label": string;
+    isSelected: boolean;
+    isDisabled: boolean;
+}
+/** The grid state slice the selection checkbox reads. */
+export interface GridSelectionState {
+    selectionManager: SelectionManager | MultipleSelectionManager;
+}
+/**
+ * Props for the row selection checkbox of a grid (react-aria `useGridSelectionCheckbox`
+ * `checkboxProps`, without `onChange` → `gridSelectionCheckboxChange`).
+ */
+export declare function gridSelectionCheckboxProps(props: AriaGridSelectionCheckboxProps, state: GridSelectionState): GridSelectionCheckboxProps;
+/** The selection checkbox's `onChange`: always toggles selection, regardless of selectionBehavior. */
+export declare function gridSelectionCheckboxChange(_isSelected: boolean, props: {
+    key: Key;
+}, state: GridSelectionState): void;
+export interface HighlightSelectionDescriptionProps extends GridLocaleProps {
+    selectionManager: MultipleSelectionManager;
+    hasItemActions?: boolean | undefined;
+}
+/** The interaction description of a grid selectable collection, or undefined. */
+export declare function highlightSelectionDescription(props: HighlightSelectionDescriptionProps): string | undefined;
+/**
+ * Computes the description props for a grid selectable collection (react-aria
+ * `useHighlightSelectionDescription`): `aria-describedby` = `descriptionId` when there is a
+ * description. Render the description element yourself (`<div id={descriptionId} hidden>`), or
+ * attach the shared one in the browser with `../utils` `useDescription(element, message)`.
+ */
+export declare function highlightSelectionDescriptionProps(props: HighlightSelectionDescriptionProps & {
+    descriptionId?: string;
+}): {
+    "aria-describedby"?: string;
+};
+export interface GridSelectionAnnouncementProps extends GridLocaleProps {
+    /**
+     * 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) | undefined;
+}
+export interface GridSelectionAnnouncementState<T> {
+    /** A collection of items in the grid. */
+    collection: Collection<Node<T>>;
+    /** A selection manager to read and update multiple selection state. */
+    selectionManager: SelectionManager;
+}
+/**
+ * Many screen readers do not announce when items in a grid are selected / deselected: announce the
+ * change from `lastSelection` to the current selection through the live announcer. Call at the end
+ * of a handler that may change the selection (react-aria runs it as an update effect on selection /
+ * focus change; when the collection is not focused it waits a frame, e.g. for mouse down focus).
+ */
+export declare function gridSelectionAnnouncement<T>(props: GridSelectionAnnouncementProps, state: GridSelectionAnnouncementState<T>, lastSelection: Selection): void;
+/**
+ * The data `useGrid` shares with `useGridRow` / `useGridCell` (react-aria `gridMap` value, minus the
+ * keyboard delegate: Rivet builds the delegate per event — `gridKeyboardDelegate`).
+ */
+export interface GridShared {
+    actions: {
+        onRowAction?: ((key: Key) => void) | undefined;
+        onCellAction?: ((key: Key) => void) | undefined;
+    };
+    shouldSelectOnPressUp?: boolean | undefined;
+    keyboardNavigationBehavior?: "arrow" | "tab" | undefined;
+}
+/**
+ * A react-stately `GridState` view as the grid hooks read it; `grid` carries the `gridShared(props)`
+ * data (react-aria `gridMap.get(state)`: views are rebuilt per event, so the data rides on the view).
+ */
+export type GridStateLike<T = unknown, C extends IGridCollection<T> = IGridCollection<T>> = GridState<T, C> & {
+    grid?: GridShared | undefined;
+};
+/** react-aria `gridMap`: shared grid data per (long-lived) state object (fallback of `state.grid`). */
+export declare const gridMap: WeakMap<object, GridShared>;
+/** The data `gridProps` shares with rows and cells (put it on the state view as `grid`). */
+export declare function gridShared(props: Pick<GridProps, "onRowAction" | "onCellAction" | "shouldSelectOnPressUp" | "keyboardNavigationBehavior">): GridShared;
+export interface GridProps extends GridLocaleProps {
+    /** The element's unique identifier (react-aria generates one with `useId`). */
+    id?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-details"?: string | undefined;
+    /** Whether the grid uses virtual scrolling. */
+    isVirtualized?: boolean | undefined;
+    /** Whether typeahead navigation is disabled. */
+    disallowTypeAhead?: boolean | undefined;
+    /** An optional keyboard delegate implementation for type to select, to override the default. */
+    keyboardDelegate?: KeyboardDelegate | undefined;
+    /** Whether initial grid focus should be placed on the grid row or grid cell. Default "row". */
+    focusMode?: "row" | "cell" | undefined;
+    /** Text announced when a row is added to / removed from the selection. */
+    getRowText?: ((key: Key) => string) | undefined;
+    /** The scrollable body (automatic scrolling on item focus for non-virtualized grids). */
+    scrollRef?: RefLike;
+    /** Handler that is called when a user performs an action on the row. */
+    onRowAction?: ((key: Key) => void) | undefined;
+    /** Handler that is called when a user performs an action on the cell. */
+    onCellAction?: ((key: Key) => void) | undefined;
+    /** Whether pressing the escape key should clear selection in the grid or not. Default "clearSelection". */
+    escapeKeyBehavior?: "clearSelection" | "none" | undefined;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean | undefined;
+    /** Whether keyboard navigation to focusable elements within grid cells is via arrow keys or the tab key. Default "arrow". */
+    keyboardNavigationBehavior?: "arrow" | "tab" | undefined;
+    /** Rivet: the grid element (handlers default to `event.currentTarget`). */
+    ref?: RefLike;
+    /** Rivet: reading direction (default: computed from the grid element). */
+    direction?: Direction | undefined;
+    /** Rivet: layout delegate of the default keyboard delegate (virtualizers). */
+    layoutDelegate?: LayoutDelegate | undefined;
+    /** Rivet: id of the highlight-selection description element (react-aria `useDescription`). */
+    descriptionId?: string | undefined;
+}
+export interface GridAria {
+    /** Props for the grid element. */
+    gridProps: Record<string, unknown>;
+}
+type Ev<E extends Event> = E & {
+    currentTarget: EventTarget | null;
+};
+/**
+ * The keyboard delegate `useGrid` builds (react-aria memoizes it; Rivet builds it per event):
+ * `props.keyboardDelegate`, else a `GridKeyboardDelegate` over the grid element's DOM layout.
+ */
+export declare function gridKeyboardDelegate<T>(props: GridProps, state: GridStateLike<T, any>, element: HTMLElement | null): KeyboardDelegate;
+/** Runs a handler body, then announces the selection change (`useGridSelectionAnnouncement` effect). */
+export declare function withSelectionAnnouncement<R>(props: GridSelectionAnnouncementProps, state: GridSelectionAnnouncementState<any>, body: () => R): R;
+/**
+ * Attributes of the grid element (react-aria `useGrid` → `gridProps`): role, id, labelling,
+ * aria-multiselectable, roving tabIndex (an empty grid is tabbable unless it holds a tabbable child:
+ * `hasTabbableChild` = react-aria `useHasTabbableChild`), the highlight-selection description,
+ * virtualized row / col counts. Reads state: bind as accessors. Wire the `grid<Event>(event, props,
+ * state)` handlers on the same element (`gridKeyDownCapture` as a capture handler).
+ */
+export declare function gridProps<T>(props: GridProps, state: GridStateLike<T, any>, hasTabbableChild?: boolean): GridAria;
+/** keydown (capture phase) on the grid element: typeahead. */
+export declare function gridKeyDownCapture(e: Ev<KeyboardEvent>, props: GridProps, state: GridStateLike<any, any>): boolean;
+/** keydown on the grid element: arrow / Home / End / Page navigation, select all, Escape, Tab. */
+export declare function gridKeyDown(e: Ev<KeyboardEvent>, props: GridProps, state: GridStateLike<any, any>): boolean;
+/** focus (wire as `onFocusIn`) on the grid element. With keyboard navigation disabled only the focused state is tracked. */
+export declare function gridFocus(e: Ev<FocusEvent>, props: GridProps, state: GridStateLike<any, any>): void;
+/** blur (wire as `onFocusOut`) on the grid element. */
+export declare function gridBlur(e: Ev<FocusEvent>, props: GridProps, state: GridStateLike<any, any>): void;
+/** mousedown on the grid element. */
+export declare function gridMouseDown(e: Ev<MouseEvent>, props: GridProps, state: GridStateLike<any, any>): void;
+/** scroll on the grid's scrollable body. */
+export declare function gridScroll(e: Ev<Event>, props: GridProps, state: GridStateLike<any, any>): void;
+export interface GridRowGroupAria {
+    /** Props for the row group element. */
+    rowGroupProps: Record<string, unknown>;
+}
+/** Provides the accessibility implementation for a row group in a grid (react-aria `useGridRowGroup`). */
+export declare function gridRowGroupProps(): GridRowGroupAria;
+export interface GridRowProps<T> {
+    /** An object representing the grid row. */
+    node: GridNode<T>;
+    /** Whether the grid row is contained in a virtual scroller. */
+    isVirtualized?: boolean | undefined;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean | undefined;
+    /** @deprecated Handler that is called when a user performs an action on the row. Use onRowAction on the grid. */
+    onAction?: (() => void) | undefined;
+    /** Rivet: the row element (handlers default to `event.currentTarget`). */
+    ref?: RefLike;
+    /** Rivet: announcement options (`useGrid` `getRowText`, locale). */
+    getRowText?: ((key: Key) => string) | undefined;
+    locale?: string | undefined;
+}
+export interface GridRowAria extends SelectableItemStates {
+    /** Props for the grid row element. */
+    rowProps: Record<string, unknown>;
+}
+/**
+ * Provides the behavior and accessibility implementation for a row in a grid (react-aria
+ * `useGridRow` → `gridRowProps`): row attributes + item states. Reads state: bind as accessors. Wire
+ * `gridRow<Event>(event, props, state)` on the row.
+ */
+export declare function gridRowProps<T>(props: GridRowProps<T>, state: GridStateLike<T, any>): GridRowAria;
+/** pointerdown on the row (press start). */
+export declare function gridRowPointerDown<T>(e: Ev<PointerEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** pointerup on the row. */
+export declare function gridRowPointerUp<T>(e: Ev<PointerEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** pointercancel on the row. */
+export declare function gridRowPointerCancel<T>(e: Ev<PointerEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** click on the row (the press). */
+export declare function gridRowClick<T>(e: Ev<MouseEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** dblclick on the row (secondary action with selectionBehavior "replace"). */
+export declare function gridRowDoubleClick<T>(e: Ev<MouseEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** keydown on the row: Space / Enter press. */
+export declare function gridRowKeyDown<T>(e: Ev<KeyboardEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** keyup on the row. */
+export declare function gridRowKeyUp<T>(e: Ev<KeyboardEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** focus (wire as `onFocusIn`) on the row: the row becomes the focused key. */
+export declare function gridRowFocus<T>(e: Ev<FocusEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+/** dragstart on the row. */
+export declare function gridRowDragStart<T>(e: Ev<DragEvent>, props: GridRowProps<T>, state: GridStateLike<T, any>): void;
+export interface GridCellProps {
+    /** An object representing the grid cell. */
+    node: GridNode<unknown>;
+    /** Whether the grid cell is contained in a virtual scroller. */
+    isVirtualized?: boolean | undefined;
+    /**
+     * Whether the cell or its first focusable child element should be focused when the grid cell is
+     * focused. Defaults to 'child' in arrow keyboard navigation mode and 'cell' in tab mode.
+     */
+    focusMode?: "child" | "cell" | undefined;
+    /** Whether the cell supports arrow key navigation even when the collection uses tab navigation. */
+    allowsArrowNavigation?: boolean | undefined;
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean | undefined;
+    /** Indicates how many columns the data cell spans. */
+    colSpan?: number | undefined;
+    /** @deprecated Handler that is called when a user performs an action on the cell. Use onCellAction on the grid. */
+    onAction?: (() => void) | undefined;
+    /** Rivet: the cell element (handlers default to `event.currentTarget`). */
+    ref?: RefLike;
+    /** Rivet: reading direction (default: computed from the cell). */
+    direction?: Direction | undefined;
+    /** Rivet: the grid's keyboard delegate (default: `gridKeyboardDelegate` over the closest grid element). */
+    keyboardDelegate?: KeyboardDelegate | undefined;
+}
+export interface GridCellAria {
+    /** Props for the grid cell element. */
+    gridCellProps: Record<string, unknown>;
+    /** Whether the cell is currently in a pressed state. */
+    isPressed: boolean;
+}
+/** Focus the cell, or (focusMode "child") its last focused / first / last focusable child — react-aria's cell `focus()`. */
+export declare function focusGridCell(props: GridCellProps, state: GridStateLike<any, any>, cell: HTMLElement | null): void;
+/**
+ * Provides the behavior and accessibility implementation for a cell in a grid (react-aria
+ * `useGridCell` → `gridCellProps`). Reads state: bind as accessors. Wire
+ * `gridCell<Event>(event, props, state)` on the cell; `gridCellKeyDownCapture` (capture phase) when
+ * `keyboardNavigationBehavior !== "tab"` or `allowsArrowNavigation`, `gridCellKeyDown` when it is
+ * "tab".
+ */
+export declare function gridCellProps(props: GridCellProps, state: GridStateLike<any, any>): GridCellAria;
+/** Whether `gridCellKeyDownCapture` applies (react-aria wires it only then). */
+export declare const gridCellHasKeyDownCapture: (props: GridCellProps, state: GridStateLike<any, any>) => boolean;
+/**
+ * keydown (capture phase) on the cell: Left / Right move between focusable children (RTL aware) and
+ * on to the neighbouring cell; Up / Down from a child are re-dispatched from the cell's parent so the
+ * grid navigates.
+ */
+export declare function gridCellKeyDownCapture(e: Ev<KeyboardEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/**
+ * keydown on the cell: with "tab" keyboard navigation, events from children stay in the cell (Tab
+ * moves between children while there are more); then the selectable item's Space / Enter press.
+ */
+export declare function gridCellKeyDown(e: Ev<KeyboardEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/** keyup on the cell. */
+export declare function gridCellKeyUp(e: Ev<KeyboardEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/**
+ * focus (wire as `onFocusIn`) on the cell: a focused child makes the cell the focused key (unless
+ * focus is visible); the cell itself focused in focusMode "child" moves focus to a child after a frame.
+ */
+export declare function gridCellFocus(e: Ev<FocusEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/**
+ * pointerdown on the cell: the press; with `shouldSelectOnPressUp` on a non-pressable cell, the
+ * tabIndex is removed for a frame so a draggable row's pointer down does not focus the cell.
+ */
+export declare function gridCellPointerDown(e: Ev<PointerEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/** pointerup on the cell. */
+export declare function gridCellPointerUp(e: Ev<PointerEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+/** click on the cell (the press). */
+export declare function gridCellClick(e: Ev<MouseEvent>, props: GridCellProps, state: GridStateLike<any, any>): void;
+export {};