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

package/interactions/long-press.jsx

@@ -0,0 +1,79 @@
+// longPressProps: long press across mouse and touch, with threshold, accessibility description,
+// pointercancel of other press handlers, click / context menu suppression after a long press.
+// Ported from @react-aria/interactions useLongPress (react-spectrum), Apache-2.0, © Adobe.
+//
+// Rivet: built on pressProps (resumable handlers); the description is an element rendered by the
+// caller from `descriptionProps` + `description` (the original's useDescription creates a hidden node
+// at run time — not resumable; render `<span id={descriptionId} hidden>{text}</span>` once).
+import { createId } from "../utils/id.js";
+import { focusWithoutScrolling, getOwnerDocument, getOwnerWindow, read } from "./utils.js";
+import { pressProps } from "./press.jsx";
+import { mergeProps } from "./merge-props.jsx";
+const DEFAULT_THRESHOLD = 500;
+const accepted = (lp, e) => lp.props.pointerType ? e.pointerType === lp.props.pointerType : e.pointerType === "mouse" || e.pointerType === "touch";
+function addGlobal(lp, target, type, fn, options) {
+    target.addEventListener(type, fn, options);
+    lp.state.globals.push(() => target.removeEventListener(type, fn, options));
+}
+const removeAllGlobals = (lp) => {
+    for (const remove of lp.state.globals.splice(0))
+        remove();
+};
+const toLongPress = (e, type) => ({
+    type,
+    pointerType: e.pointerType,
+    target: e.target,
+    shiftKey: e.shiftKey,
+    ctrlKey: e.ctrlKey,
+    metaKey: e.metaKey,
+    altKey: e.altKey,
+    x: e.x,
+    y: e.y,
+    key: e.key,
+});
+/** @internal onPressStart of longPressProps. */
+export function longPressStart(lp, e) {
+    e.continuePropagation();
+    if (!accepted(lp, e))
+        return;
+    const { props, state } = lp;
+    props.onLongPressStart?.(toLongPress(e, "longpressstart"));
+    state.timer = setTimeout(() => {
+        // Stop other pressProps handlers from handling this press.
+        e.target.dispatchEvent(new PointerEvent("pointercancel", { bubbles: true }));
+        // No default click action (e.g. following a link) after a long press.
+        addGlobal(lp, e.target, "click", (event) => event.preventDefault(), { once: true });
+        // Touch devices focus on pointer up: focus now.
+        if (getOwnerDocument(e.target).activeElement !== e.target)
+            focusWithoutScrolling(e.target);
+        props.onLongPress?.(toLongPress(e, "longpress"));
+        state.timer = undefined;
+    }, props.threshold ?? DEFAULT_THRESHOLD);
+    // Touch long press may open the context menu.
+    if (e.pointerType === "touch")
+        addGlobal(lp, e.target, "contextmenu", (event) => event.preventDefault(), { once: true });
+    // Without a quick contextmenu / click after pointerup, drop the handlers so later events pass.
+    addGlobal(lp, getOwnerWindow(e.target), "pointerup", () => setTimeout(() => removeAllGlobals(lp), 100), { once: true });
+}
+/** @internal onPressEnd of longPressProps. */
+export function longPressEnd(lp, e) {
+    if (lp.state.timer)
+        clearTimeout(lp.state.timer);
+    if (lp.props.onLongPressEnd && accepted(lp, e))
+        lp.props.onLongPressEnd(toLongPress(e, "longpressend"));
+}
+/** Long press interactions across mouse and touch devices. */
+export function longPressProps(props = {}) {
+    const lp = { props, state: { timer: undefined, globals: [] } };
+    const press = pressProps({
+        isDisabled: props.isDisabled,
+        onPressStart: (e) => longPressStart(lp, e),
+        onPressEnd: (e) => longPressEnd(lp, e),
+    });
+    const described = props.onLongPress && !read(props.isDisabled) && props.accessibilityDescription;
+    const descriptionId = described ? createId() : undefined;
+    return {
+        longPressProps: mergeProps(press.pressProps, descriptionId ? { "aria-describedby": descriptionId } : {}),
+        descriptionId,
+    };
+}

package/interactions/merge-props.d.ts

@@ -0,0 +1,54 @@
+type Bag = Record<string, any>;
+type Fn = (...args: unknown[]) => unknown;
+type PropsArg = Bag | null | undefined;
+type TupleTypes<T> = {
+    [P in keyof T]: T[P];
+} extends {
+    [key: number]: infer V;
+} ? (V extends null | undefined ? {} : V) : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** A Rivet / React ref: `ref()` signal object, callback (may return a cleanup) or `{ current }` object. */
+export type RefLike<T> = ((value: T | null) => void | (() => void)) | {
+    current: T | null;
+} | null | undefined;
+/** Call `a`, then `b` (either may be missing). The returned function is a resumable symbol. */
+export declare function chain2(a: Fn | null | undefined, b: Fn | null | undefined): Fn;
+/** Calls all functions in the order they were chained with the same arguments (non-functions skipped; react-aria `chain`). */
+export declare function chain(...callbacks: unknown[]): (...args: any[]) => void;
+/** Merges refs (callback or `{ current }` objects) into one callback ref; cleanups are chained. */
+export declare function mergeRefs<T>(...refs: RefLike<T>[]): RefLike<T>;
+/**
+ * Merges props objects (react-aria `mergeProps`): `on[A-Z]*` handlers are chained, `class` /
+ * `className` strings joined, `id`s merged with `mergeIds`, `ref`s merged with `mergeRefs`; any other
+ * key: the last defined value wins.
+ */
+export declare function mergeProps<T extends PropsArg[]>(...args: T): UnionToIntersection<TupleTypes<T>>;
+/**
+ * The copy path of `mergeProps` for sources known to hold no getter (cdk `contextProps` after its own `hasLive`
+ * checks): no per-key descriptor scan. `intoFirst`: `args[0]` is a fresh bag the caller owns and reads no more —
+ * merged into in place (no copy of it).
+ * @internal cdk parts
+ */
+export declare function mergeCopy(args: readonly PropsArg[], intoFirst?: boolean): Bag;
+/**
+ * `mergeProps(first, ...rest)` merged into `first` itself (no copy of it): `first` must be a fresh bag the caller owns
+ * and reads no more (a `liveOmit` / `globalDOMProps` result). Same result as `mergeProps`: a getter in any source (a
+ * live `first`: a forwarding part) takes the live path, which leaves `first` untouched.
+ * @internal cdk parts
+ */
+export declare function mergeInto(first: Bag, ...rest: PropsArg[]): Bag;
+/**
+ * `mergeProps(literal, ...rest)` for an RA bag `literal` written in place (data only by construction: not scanned,
+ * merged into), then `definedProps` on the static path. A getter in `rest` takes the live `mergeProps` path (all keys).
+ * @internal cdk parts
+ */
+export declare function mergeDefined(literal: Bag, ...rest: PropsArg[]): Bag;
+/**
+ * A fresh copy of `bag` without its `undefined` entries (key order kept): for a data-only RA prop bag (no
+ * getters — they would be read) that is merged / spread next. RA bags list every optional attribute (`aria-*`, `name`,
+ * `form`, …), mostly unset; `undefined` never overrides in `mergeProps` and an unset spread key writes nothing, so the
+ * element gets the same attributes while every later copy / merge / spread walks only the set keys.
+ * @internal cdk parts
+ */
+export declare function definedProps(bag: Bag): Bag;
+export {};

package/interactions/merge-props.jsx

@@ -0,0 +1,257 @@
+// mergeProps / chain / mergeRefs — THE prop-merging helpers of the package (`@rivetjs/cdk/utils`
+// re-exports them). Ported from @react-aria/utils mergeProps, chain, mergeRefs (react-spectrum),
+// Apache-2.0, © Adobe.
+//
+// Rules (react-aria): later keys win; `on[A-Z]*` handlers chain (earlier first); `class` /
+// `className` / `UNSAFE_className` concatenate; `id`s merge with `mergeIds`; `ref`s merge with
+// `mergeRefs`; `undefined` never overrides.
+// Rivet: a `.tsx` module compiled for resume (R2), so the chained handlers / merged refs it returns
+// are resumable symbols — a merged bag of resumable handlers stays resumable when spread on a native
+// element. Deviation: class values may be accessors (signals); an accessor on either side yields an accessor.
+// Live props (P5, docs/design/specs/2026-10-07-live-props-design.md §8): a source with an own getter (a live prop)
+// is merged without reading it — the result is a runtime `mergeProps` object (same "later defined value wins"
+// rule, getters forwarded unread) over the sources plus one bag of the keys that combine: handlers of a live key
+// chain at call time, live classes join in an accessor (render-prop values passed through). `id` / `ref` with two
+// holders are read once (identity props). Sources without getters take the copy path below unchanged.
+import { mergeProps as mergeLive } from "@rivetjs/runtime/props";
+import { mergeIds } from "../utils/id.js";
+import { hasLive } from "../utils/live.jsx";
+/** Call `a`, then `b` (either may be missing). The returned function is a resumable symbol. */
+export function chain2(a, b) {
+    return (...args) => {
+        if (typeof a === "function")
+            a(...args);
+        if (typeof b === "function")
+            return b(...args);
+    };
+}
+/** Calls all functions in the order they were chained with the same arguments (non-functions skipped; react-aria `chain`). */
+export function chain(...callbacks) {
+    let out = null;
+    for (const callback of callbacks)
+        if (typeof callback === "function")
+            out = out ? chain2(out, callback) : callback;
+    return out ?? noop();
+}
+function noop() {
+    return () => undefined;
+}
+const text = (v) => (v == null || v === "" ? "" : String(v));
+function joinText(a, b) {
+    if (typeof a === "function" || typeof b === "function")
+        return joined(a, b);
+    return [a, b].filter((v) => v != null && v !== "").join(" ");
+}
+function joined(a, b) {
+    return () => [typeof a === "function" ? a() : a, typeof b === "function" ? b() : b].filter((v) => text(v) !== "").join(" ");
+}
+function setRef(ref, value) {
+    // A Rivet `ref()` object is a signal: set it (calling it would only read it).
+    const signalRef = ref;
+    if (typeof ref === "function" && typeof signalRef.set === "function") {
+        signalRef.set(value ?? undefined);
+        return;
+    }
+    if (typeof ref === "function")
+        return ref(value);
+    if (ref != null)
+        ref.current = value;
+}
+/** Merges refs (callback or `{ current }` objects) into one callback ref; cleanups are chained. */
+export function mergeRefs(...refs) {
+    if (refs.length === 1 && refs[0])
+        return refs[0];
+    return (value) => {
+        // One loop; the cleanups array exists only once a ref returns a cleanup (most refs return none).
+        let cleanups;
+        for (let i = 0; i < refs.length; i++) {
+            const cleanup = setRef(refs[i], value);
+            if (typeof cleanup === "function")
+                (cleanups ??= [])[i] = cleanup;
+        }
+        if (cleanups) {
+            const done = cleanups;
+            return () => {
+                for (let i = 0; i < refs.length; i++) {
+                    const cleanup = done[i];
+                    if (typeof cleanup === "function")
+                        cleanup();
+                    else
+                        setRef(refs[i], null);
+                }
+            };
+        }
+    };
+}
+/**
+ * Merges props objects (react-aria `mergeProps`): `on[A-Z]*` handlers are chained, `class` /
+ * `className` strings joined, `id`s merged with `mergeIds`, `ref`s merged with `mergeRefs`; any other
+ * key: the last defined value wins.
+ */
+export function mergeProps(...args) {
+    for (let i = 0; i < args.length; i++)
+        if (hasLive(args[i]))
+            return live(args);
+    return mergeCopy(args);
+}
+/**
+ * The copy path of `mergeProps` for sources known to hold no getter (cdk `contextProps` after its own `hasLive`
+ * checks): no per-key descriptor scan. `intoFirst`: `args[0]` is a fresh bag the caller owns and reads no more —
+ * merged into in place (no copy of it).
+ * @internal cdk parts
+ */
+export function mergeCopy(args, intoFirst = false) {
+    const out = intoFirst ? args[0] : { ...args[0] };
+    for (let i = 1; i < args.length; i++) {
+        const bag = args[i];
+        if (!bag)
+            continue;
+        for (const key in bag) {
+            const a = out[key], b = bag[key];
+            if (typeof a === "function" && typeof b === "function" && key[0] === "o" && key[1] === "n" && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90)
+                out[key] = chain2(a, b);
+            else if ((key === "class" || key === "className" || key === "UNSAFE_className") && a != null && b != null)
+                out[key] = joinText(a, b);
+            else if (key === "id" && a && b)
+                out.id = mergeIds(a, b);
+            else if (key === "ref" && a && b)
+                out.ref = mergeRefs(a, b);
+            else
+                out[key] = b !== undefined ? b : a;
+        }
+    }
+    return out;
+}
+/**
+ * `mergeProps(first, ...rest)` merged into `first` itself (no copy of it): `first` must be a fresh bag the caller owns
+ * and reads no more (a `liveOmit` / `globalDOMProps` result). Same result as `mergeProps`: a getter in any source (a
+ * live `first`: a forwarding part) takes the live path, which leaves `first` untouched.
+ * @internal cdk parts
+ */
+export function mergeInto(first, ...rest) {
+    if (hasLive(first))
+        return mergeProps(first, ...rest);
+    return mergeOwned(first, rest) ?? mergeProps(first, ...rest);
+}
+/**
+ * `mergeProps(literal, ...rest)` for an RA bag `literal` written in place (data only by construction: not scanned,
+ * merged into), then `definedProps` on the static path. A getter in `rest` takes the live `mergeProps` path (all keys).
+ * @internal cdk parts
+ */
+export function mergeDefined(literal, ...rest) {
+    const out = mergeOwned(literal, rest);
+    return out ? definedProps(out) : mergeProps(literal, ...rest);
+}
+// The copy path into `first` when no bag of `rest` holds a getter, else null.
+function mergeOwned(first, rest) {
+    for (let i = 0; i < rest.length; i++)
+        if (hasLive(rest[i]))
+            return null;
+    rest.unshift(first);
+    return mergeCopy(rest, true);
+}
+/**
+ * A fresh copy of `bag` without its `undefined` entries (key order kept): for a data-only RA prop bag (no
+ * getters — they would be read) that is merged / spread next. RA bags list every optional attribute (`aria-*`, `name`,
+ * `form`, …), mostly unset; `undefined` never overrides in `mergeProps` and an unset spread key writes nothing, so the
+ * element gets the same attributes while every later copy / merge / spread walks only the set keys.
+ * @internal cdk parts
+ */
+export function definedProps(bag) {
+    const out = {};
+    for (const key in bag) {
+        const value = bag[key];
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+const isHandler = (key) => key[0] === "o" && key[1] === "n" && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90;
+const isClass = (key) => key === "class" || key === "className" || key === "UNSAFE_className";
+// Live merge: runtime `mergeProps(...sources, combined)` — `combined` holds the keys two or more sources combine
+// (handlers, classes, id, ref); every other key forwards to its last defined source (getters unread).
+function live(args) {
+    const sources = [];
+    for (const bag of args)
+        if (bag)
+            sources.push(bag);
+    const combined = {};
+    for (let s = 0; s < sources.length; s++) {
+        const source = sources[s];
+        for (const key of Object.keys(source)) {
+            // Category once per key; a key is handled at its first holder (no `seen` set, no `filter` copy per key).
+            const handler = isHandler(key), cls = !handler && isClass(key);
+            if (!(handler || cls || key === "id" || key === "ref"))
+                continue;
+            let earlier = false;
+            for (let j = 0; j < s; j++)
+                if (Object.hasOwn(sources[j], key)) {
+                    earlier = true;
+                    break;
+                }
+            if (earlier)
+                continue;
+            let holders;
+            for (let j = s + 1; j < sources.length; j++)
+                if (Object.hasOwn(sources[j], key))
+                    (holders ??= [source]).push(sources[j]);
+            if (holders === undefined)
+                continue;
+            let anyLive = false;
+            for (let j = 0; j < holders.length; j++)
+                if (Object.getOwnPropertyDescriptor(holders[j], key).get !== undefined) {
+                    anyLive = true;
+                    break;
+                }
+            if (handler && anyLive)
+                combined[key] = liveChain(holders, key);
+            else if (cls && anyLive)
+                combined[key] = liveClass(holders, key);
+            else {
+                // Data holders (or id / ref): fold with the copy-path rules, reading each value once.
+                let a = holders[0][key];
+                for (let i = 1; i < holders.length; i++) {
+                    const b = holders[i][key];
+                    if (handler && typeof a === "function" && typeof b === "function")
+                        a = chain2(a, b);
+                    else if (cls && a != null && b != null)
+                        a = joinText(a, b);
+                    else if (key === "id" && a && b)
+                        a = mergeIds(a, b);
+                    else if (key === "ref" && a && b)
+                        a = mergeRefs(a, b);
+                    else
+                        a = b !== undefined ? b : a;
+                }
+                if (a !== undefined)
+                    combined[key] = a;
+            }
+        }
+    }
+    return mergeLive(...sources, combined);
+}
+/** Handlers of a live key: every holder's current function, in source order, at call time. */
+function liveChain(holders, key) {
+    return (...args) => {
+        let result;
+        for (const holder of holders) {
+            const f = holder[key];
+            if (typeof f === "function")
+                result = f(...args);
+        }
+        return result;
+    };
+}
+/** Classes of a live key, joined at read time (an accessor; render-prop class functions get the render props). */
+function liveClass(holders, key) {
+    return (renderProps) => {
+        let out = "";
+        for (const holder of holders) {
+            const v = holder[key];
+            const t = text(typeof v === "function" ? v(renderProps) : v);
+            if (t !== "")
+                out = out === "" ? t : out + " " + t;
+        }
+        return out;
+    };
+}

package/interactions/move.d.ts

@@ -0,0 +1,48 @@
+import { type PointerType } from "./utils.js";
+interface BaseMoveEvent {
+    pointerType: PointerType;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}
+export interface MoveStartEvent extends BaseMoveEvent {
+    type: "movestart";
+}
+export interface MoveMoveEvent extends BaseMoveEvent {
+    type: "move";
+    /** Movement in X since the last event. */
+    deltaX: number;
+    /** Movement in Y since the last event. */
+    deltaY: number;
+}
+export interface MoveEndEvent extends BaseMoveEvent {
+    type: "moveend";
+}
+export type MoveEvent = MoveStartEvent | MoveMoveEvent | MoveEndEvent;
+export interface MoveEvents {
+    onMoveStart?: (e: MoveStartEvent) => void;
+    onMove?: (e: MoveMoveEvent) => void;
+    onMoveEnd?: (e: MoveEndEvent) => void;
+}
+export interface MoveResult {
+    moveProps: Record<string, unknown>;
+}
+interface Move {
+    props: MoveEvents;
+    state: {
+        didMove: boolean;
+        lastPosition: {
+            pageX: number;
+            pageY: number;
+        } | null;
+        id: number | null;
+    };
+}
+/** @internal pointerdown handler of moveProps. */
+export declare function movePointerDown(m: Move, e: PointerEvent): void;
+/** @internal keydown handler of moveProps. */
+export declare function moveKeyDown(m: Move, e: KeyboardEvent): void;
+/** Move interactions (drag with mouse / touch / pen, arrow keys). Spread `moveProps` on the target. */
+export declare function moveProps(props?: MoveEvents): MoveResult;
+export {};

package/interactions/move.jsx

@@ -0,0 +1,96 @@
+// moveProps: drag-style movement with mouse, pen, touch (pointer events, page coordinates) and arrow
+// keys; movestart only after the first non-zero delta; text selection disabled while moving.
+// Ported from @react-aria/interactions useMove (react-spectrum), Apache-2.0, © Adobe.
+//
+// Rivet: resumable handlers; per-move state is a JSON object. No mouse/touch fallback (test-only in
+// the original).
+import { disableTextSelection, getEventTarget, getOwnerWindow, restoreTextSelection } from "./utils.js";
+const modifiers = (e) => ({ shiftKey: e.shiftKey, metaKey: e.metaKey, ctrlKey: e.ctrlKey, altKey: e.altKey });
+function move(m, e, pointerType, deltaX, deltaY) {
+    if (deltaX === 0 && deltaY === 0)
+        return;
+    if (!m.state.didMove) {
+        m.state.didMove = true;
+        m.props.onMoveStart?.({ type: "movestart", pointerType, ...modifiers(e) });
+    }
+    m.props.onMove?.({ type: "move", pointerType, deltaX, deltaY, ...modifiers(e) });
+}
+function end(m, e, pointerType) {
+    restoreTextSelection();
+    if (m.state.didMove)
+        m.props.onMoveEnd?.({ type: "moveend", pointerType, ...modifiers(e) });
+}
+function start(m) {
+    disableTextSelection();
+    m.state.didMove = false;
+}
+/** @internal pointerdown handler of moveProps. */
+export function movePointerDown(m, e) {
+    const { state } = m;
+    if (e.button !== 0 || state.id != null)
+        return;
+    start(m);
+    e.stopPropagation();
+    e.preventDefault();
+    state.lastPosition = { pageX: e.pageX, pageY: e.pageY };
+    state.id = e.pointerId;
+    const win = getOwnerWindow(getEventTarget(e));
+    const onPointerMove = (event) => {
+        if (event.pointerId !== state.id)
+            return;
+        // movementX/Y is 0 on macOS Safari and DPR-scaled on Chrome Android: use page coordinates.
+        move(m, event, (event.pointerType || "mouse"), event.pageX - (state.lastPosition?.pageX ?? 0), event.pageY - (state.lastPosition?.pageY ?? 0));
+        state.lastPosition = { pageX: event.pageX, pageY: event.pageY };
+    };
+    const onPointerUp = (event) => {
+        if (event.pointerId !== state.id)
+            return;
+        end(m, event, (event.pointerType || "mouse"));
+        state.id = null;
+        win.removeEventListener("pointermove", onPointerMove, false);
+        win.removeEventListener("pointerup", onPointerUp, false);
+        win.removeEventListener("pointercancel", onPointerUp, false);
+    };
+    win.addEventListener("pointermove", onPointerMove, false);
+    win.addEventListener("pointerup", onPointerUp, false);
+    win.addEventListener("pointercancel", onPointerUp, false);
+}
+/** @internal keydown handler of moveProps. */
+export function moveKeyDown(m, e) {
+    let delta = null;
+    switch (e.key) {
+        case "Left":
+        case "ArrowLeft":
+            delta = [-1, 0];
+            break;
+        case "Right":
+        case "ArrowRight":
+            delta = [1, 0];
+            break;
+        case "Up":
+        case "ArrowUp":
+            delta = [0, -1];
+            break;
+        case "Down":
+        case "ArrowDown":
+            delta = [0, 1];
+            break;
+    }
+    if (!delta)
+        return;
+    e.preventDefault();
+    e.stopPropagation();
+    start(m);
+    move(m, e, "keyboard", delta[0], delta[1]);
+    end(m, e, "keyboard");
+}
+/** Move interactions (drag with mouse / touch / pen, arrow keys). Spread `moveProps` on the target. */
+export function moveProps(props = {}) {
+    const m = { props, state: { didMove: false, lastPosition: null, id: null } };
+    return {
+        moveProps: {
+            onPointerDown: (e) => movePointerDown(m, e),
+            onKeyDown: (e) => moveKeyDown(m, e),
+        },
+    };
+}

package/interactions/press.d.ts

@@ -0,0 +1,129 @@
+import { type FocusableElement, type MaybeAccessor, type PointerType } from "./utils.js";
+export type { PointerType } from "./utils.js";
+export interface PressEvent {
+    /** The type of press event being fired. */
+    type: "pressstart" | "pressend" | "pressup" | "press";
+    /** The pointer type that triggered the press event. */
+    pointerType: PointerType;
+    /** The target element of the press event. */
+    target: Element;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    /** X position relative to the target. */
+    x: number;
+    /** Y position relative to the target. */
+    y: number;
+    /** The key that triggered the press event (keyboard presses): Space vs Enter. */
+    key?: string;
+    /** Press events stop propagation by default; call this to let a parent handle the event too. */
+    continuePropagation(): void;
+}
+export interface PressEvents {
+    /** Called when the press is released over the target. */
+    onPress?: ((e: PressEvent) => void) | undefined;
+    /** Called when a press interaction starts. */
+    onPressStart?: ((e: PressEvent) => void) | undefined;
+    /** Called when a press interaction ends, over the target or when the pointer leaves it. */
+    onPressEnd?: ((e: PressEvent) => void) | undefined;
+    /** Called when the press state changes. */
+    onPressChange?: ((isPressed: boolean) => void) | undefined;
+    /** Called when a press is released over the target, whether or not it started there. */
+    onPressUp?: ((e: PressEvent) => void) | undefined;
+    /** Not recommended (use `onPress`): a click alias for compatibility with other libraries. */
+    onClick?: ((e: MouseEvent) => void) | undefined;
+}
+export interface PressProps extends PressEvents {
+    /** Controlled press state (e.g. an overlay it triggers is open). */
+    isPressed?: MaybeAccessor<boolean | undefined>;
+    /** Disable press events. */
+    isDisabled?: MaybeAccessor<boolean | undefined>;
+    /** Do not focus the target on press. */
+    preventFocusOnPress?: boolean;
+    /**
+     * Cancel the press when the pointer leaves the target while pressed (default false: re-entering
+     * fires onPressStart again).
+     */
+    shouldCancelOnPointerExit?: boolean;
+    /** Allow text selection on the pressable element. */
+    allowTextSelectionOnPress?: boolean;
+}
+export interface PressHookProps extends PressProps {
+    /** Other attributes / handlers merged into `pressProps` (like the original's DOM props pass-through). */
+    [attribute: string]: unknown;
+}
+export interface PressResult {
+    /** Whether the target is currently pressed (signal accessor). */
+    isPressed: () => boolean;
+    /** Attributes and handlers to spread on the target element. */
+    pressProps: Record<string, unknown>;
+}
+interface PressState {
+    isPressed: boolean;
+    ignoreEmulatedMouseEvents: boolean;
+    didFirePressStart: boolean;
+    isTriggeringEvent: boolean;
+    activePointerId: number | null;
+    target: FocusableElement | null;
+    isOverTarget: boolean;
+    pointerType: PointerType | null;
+    metaKeyEvents: Map<string, KeyboardEvent> | null;
+    /** Browser-only: cleanup functions and global listeners of the current press. */
+    disposables: (() => void)[];
+    globals: (() => void)[];
+    /** `timeStamp` of the last click seen (a replayed cold keydown older than it starts nothing). */
+    lastClick: number;
+}
+/** A press instance: options, transient state and the pressed sink (a signal, or `data-pressed` on the element). */
+export interface Press {
+    props: PressHookProps;
+    state: PressState;
+    pressed: {
+        set(value: boolean): unknown;
+    };
+    /**
+     * Element listeners a pointer press binds on its target while pressed (`PRESS_TRACK_*` bits): `dragstart`
+     * (cancel) and `pointerenter` / `pointerleave` (exit / re-entry). RA binds them on the element for its whole
+     * life; they act only during a pointer press, so Rivet binds them at pointerdown and drops them when it ends.
+     */
+    track?: number;
+}
+/** `Press.track`: bind `dragstart` while pressed. */
+export declare const PRESS_TRACK_DRAG = 1;
+/** `Press.track`: bind `pointerenter` / `pointerleave` while pressed. */
+export declare const PRESS_TRACK_EXIT = 2;
+/** Fresh transient press state (browser-only, never serialized). */
+export declare function createPressState(): PressState;
+/** Context through which a parent (e.g. a trigger wrapper) passes press props to a child's usePress. */
+export declare const PressResponderContext: import("@rivetjs/reactivity").Context<(PressProps & {
+    register?: () => void;
+}) | null>;
+/**
+ * Release a press if the hook became disabled while pressed (the original's `isDisabled` effect).
+ * Rivet reads `isDisabled` at event time; call this when a controlled disabled signal turns true
+ * during a press.
+ */
+export declare function cancelPress(press: Press): void;
+/** @internal keydown handler of pressProps. */
+export declare function pressKeyDown(press: Press, e: KeyboardEvent): void;
+/** @internal click handler of pressProps (virtual clicks and the end of pointer presses). */
+export declare function pressClick(press: Press, e: MouseEvent): void;
+/** @internal pointerdown handler of pressProps. */
+export declare function pressPointerDown(press: Press, e: PointerEvent): void;
+/** @internal mousedown handler of pressProps (focus prevention). */
+export declare function pressMouseDown(press: Press, e: MouseEvent): void;
+/** @internal pointerup handler on the target of pressProps. */
+export declare function pressPointerUp(press: Press, e: PointerEvent): void;
+/** @internal pointerenter handler of a press (bound on the target while pressed: `PRESS_TRACK_EXIT`). */
+export declare function pressPointerEnter(press: Press, e: PointerEvent): void;
+/** @internal pointerleave handler of a press (bound on the target while pressed: `PRESS_TRACK_EXIT`). */
+export declare function pressPointerLeave(press: Press, e: PointerEvent): void;
+/** @internal dragstart handler of a press (bound on the target while pressed: `PRESS_TRACK_DRAG`; Safari fires no pointercancel when a drag starts). */
+export declare function pressDragStart(press: Press, e: DragEvent): void;
+/**
+ * Handle press interactions across mouse, touch, keyboard and screen readers. Spread `pressProps`
+ * on the target (`<div {...pressProps}>`); `isPressed()` reads the press state. Options are read at
+ * event time, so `isDisabled` / `isPressed` may be signals.
+ */
+export declare function pressProps(props?: PressHookProps): PressResult;