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

package/slots/index.jsx

@@ -0,0 +1,473 @@
+// Ported from react-aria-components utils (packages/react-aria-components/src/utils.tsx), Apache-2.0, © Adobe.
+// THE slot / context / render-prop contract of the RAC component layer: every part (`Button`, `Heading`,
+// `Text`, `Label`, `Input`, …) reads its context with `contextProps`, every container provides its
+// parts' props with `<Provider values={[[ButtonContext, …], [HeadingContext, …]]}>`.
+// Rivet:
+// - names follow the cdk convention (no `use*`): `useContextProps` → `contextProps`, `useSlottedContext` →
+//   `slottedContext`, `useRenderProps` → `renderProps`, `useSlot` → `createSlot`, RA `useSlotId` → `createSlotId`.
+// - contexts are `createContext` tokens; parts register theirs with `resumableContext(createContext(null,
+//   { id: "rv-<name>" }))`, so a re-created region on a resumed page reads the same provision. Context
+//   values must be serializable (plain data, signals, R2 functions: inline arrows / local consts).
+// - `DEFAULT_SLOT` is a string, not a Symbol (symbol keys do not survive resume serialization).
+// - refs are Rivet refs (`ref()` signal objects or callbacks; `{ current }` objects too). `contextProps`
+//   returns the props' own ref when the context has none (and vice versa); when both exist it returns a
+//   fresh `ref()` and copies the element to both from a `clientEffect` (a merged callback ref is not
+//   resumable: a forwarded `ref={fn}` that is not a `ref()` is a resume render error).
+// - render props are accessors (`isHovered()`), never snapshots: the component runs once; `class` /
+//   `style` / `children` functions are called inside bindings (`class={rp.class()}`), so only
+//   the binding re-runs. `renderProps` returns accessors for `class` / `style` and a `children()`
+//   resolver (lazy plain JSX children / user render function / default children).
+// - prop names: `class` (RAC `className`), `defaultClassName` kept as the render-prop field name (RAC).
+// Deviations: no `data-rac` marker attribute; no `dom` element
+// proxy (Rivet compiles element templates). `render` (`DOMRenderProps` / `DOMRenderFunction`, re-exported below from `../utils/render.ts`) is a per-part prop; `createSlot` returns
+// `[Ref, hasSlot accessor]` (no layout-effect re-render; see `createSlot`).
+import { createContext, onCleanup, signal, untrack, useContext } from "@rivetjs/reactivity";
+import { createId } from "../utils/id.js";
+import { Provider as ContextProvider, clientEffect, ref as createRef } from "@rivetjs/runtime/dom";
+import { isSlot, renderSlot } from "@rivetjs/runtime/slot";
+import { mergeCopy, mergeProps } from "../interactions/merge-props.jsx";
+import { splitProps } from "@rivetjs/runtime/props";
+import { hasLive } from "../utils/live.jsx";
+export { createContext, useContext };
+/** Key of the default (unnamed) slot in a `{ slots }` context value. */
+export const DEFAULT_SLOT = "__rv_default_slot";
+/** Provides several contexts at once (RAC `Provider`); later pairs are nested inside earlier ones. */
+export function Provider(props) {
+    const values = props.values;
+    const content = props.children;
+    return <Nest values={values} index={0} content={content}/>;
+}
+function Nest(props) {
+    const { values, index, content } = props;
+    if (index >= values.length)
+        return renderSlot(content);
+    const token = values[index][0];
+    const value = values[index][1];
+    return (<ContextProvider token={token} value={value}>
+      <Nest values={values} index={index + 1} content={content}/>
+    </ContextProvider>);
+}
+/**
+ * Resolves `class` / `style` / `children` render props (RAC `useRenderProps`). The returned accessors call
+ * the user's functions with `{ ...values, defaultClassName | defaultStyle | defaultChildren }`.
+ */
+export function renderProps(props, from) {
+    const { defaultClassName, defaultChildren, defaultStyle, values } = props;
+    // Live props (P5): `from` (a `liveView` of the part's props, or one view per key: `renderPropsOf`) supplies `class` /
+    // `style` / `children`, read inside the accessors (getters stay live); without it the options' values are used as
+    // given. One view per key: each accessor captures only its own key on a resumed page — a `children` function capturing
+    // a class instance (a calendar cell's `date`) does not make the `class` binding unserializable (RESUME-BUGS 2026-10-09,
+    // ui-docs calendar indicators).
+    if (from) {
+        const [classView, styleView, childrenView] = Array.isArray(from)
+            ? from
+            : [from, from, from];
+        return {
+            class: () => {
+                const className = classView.class;
+                return (typeof className === "function" ? className({ ...values, defaultClassName }) : className) ?? defaultClassName;
+            },
+            style: () => {
+                const style = styleView.style;
+                const computed = typeof style === "function" ? style({ ...values, defaultStyle: defaultStyle || {} }) : style;
+                return computed || defaultStyle ? { ...defaultStyle, ...computed } : undefined;
+            },
+            children: () => resolveChildren(childrenView.children, values, defaultChildren),
+        };
+    }
+    const { class: className, style, children } = props;
+    return {
+        class: () => (typeof className === "function" ? className({ ...values, defaultClassName }) : className) ?? defaultClassName,
+        style: () => {
+            const computed = typeof style === "function" ? style({ ...values, defaultStyle: defaultStyle || {} }) : style;
+            return computed || defaultStyle ? { ...defaultStyle, ...computed } : undefined;
+        },
+        children: () => {
+            let computed;
+            if (isSlot(children))
+                computed = renderSlot(children);
+            else if (typeof children === "function")
+                computed = children({ ...values, defaultChildren });
+            else if (children == null)
+                computed = renderSlot(defaultChildren);
+            else
+                computed = children;
+            return computed ?? renderSlot(defaultChildren);
+        },
+    };
+}
+/**
+ * `renderProps` for a part's own props (`renderProps({ ...props, values, defaultClassName })`): live props (an own
+ * getter) → `class` / `style` / `children` read through one live view per key inside the accessors (`liveRenderProps`);
+ * static → the values. `keys`: the keys taken from the props (default all three; TabList leaves its collection
+ * children out). Call it directly in the `const rp = …` initializer, no `untrack(() => …)` wrapper and no inline arrow
+ * in `options` (hoist `values`): a function in the initializer makes the compiler capture `rp` whole in spread sites,
+ * so the class / style binding would encode the children accessor too (per-key views wasted).
+ */
+export function renderPropsOf(props, options, keys) {
+    if (hasLive(props))
+        return renderProps(options, liveRenderProps(props, keys));
+    if (!keys)
+        return renderProps({ class: props.class, style: props.style, children: props.children, ...options });
+    return renderProps({
+        class: keys.includes("class") ? props.class : undefined,
+        style: keys.includes("style") ? props.style : undefined,
+        children: keys.includes("children") ? props.children : undefined,
+        ...options,
+    });
+}
+const NO_VIEW = {};
+/**
+ * The live `from` of `renderProps` for live props (`hasLive(props)`): one forwarding `splitProps` view per key
+ * (`[class, style, children]`), so each resolved accessor captures only its own key on a resumed page. A shared
+ * `liveView(props, ["class", "style", "children"])` made the `class` / `style` bindings capture the children too: a
+ * children function capturing a class instance (a calendar cell's `date`) failed the resumable render. `keys` = the
+ * keys taken from the props (default all three); a left-out key gets an empty view (`renderProps` falls back to its
+ * default, as a `liveView` without that key did).
+ */
+export function liveRenderProps(props, keys) {
+    const views = splitProps(props, ["class"], ["style"], ["children"]);
+    if (!keys)
+        return [views[0], views[1], views[2]];
+    return [
+        keys.includes("class") ? views[0] : NO_VIEW,
+        keys.includes("style") ? views[1] : NO_VIEW,
+        keys.includes("children") ? views[2] : NO_VIEW,
+    ];
+}
+function resolveChildren(children, values, defaultChildren) {
+    let computed;
+    if (isSlot(children))
+        computed = renderSlot(children);
+    else if (typeof children === "function")
+        computed = children({ ...values, defaultChildren });
+    else if (children == null)
+        computed = renderSlot(defaultChildren);
+    else
+        computed = children;
+    return computed ?? renderSlot(defaultChildren);
+}
+/**
+ * Combines a user-provided render prop value (a static value or a function) with another value
+ * (RAC `composeRenderProps`).
+ */
+export function composeRenderProps(value, wrap) {
+    // Object-literal function value: a resumable symbol (bindings on resumed pages may capture it).
+    const composed = {
+        fn: (renderProps) => wrap(typeof value === "function" && !isSlot(value) ? value(renderProps) : value, renderProps),
+    };
+    return composed.fn;
+}
+/** The context value for `slot` (RAC `useSlottedContext`); throws for an unknown slot of a slotted value. */
+export function slottedContext(context, slot) {
+    const ctx = useContext(context);
+    if (slot === null) {
+        // An explicit `null` slot means don't use context.
+        return null;
+    }
+    if (ctx && typeof ctx === "object" && "slots" in ctx && ctx.slots) {
+        const slotKey = slot || DEFAULT_SLOT;
+        if (!ctx.slots[slotKey]) {
+            const availableSlots = new Intl.ListFormat().format(Object.keys(ctx.slots).map((p) => `"${p}"`));
+            const errorMessage = slot ? `Invalid slot "${slot}".` : "A slot prop is required.";
+            throw new Error(`${errorMessage} Valid slot names are ${availableSlots}.`);
+        }
+        return ctx.slots[slotKey];
+    }
+    return ctx;
+}
+function assignRef(target, element) {
+    if (target == null)
+        return;
+    if (typeof target === "function") {
+        const signalRef = target;
+        if (signalRef.set)
+            signalRef.set(element ?? undefined);
+        else
+            target(element);
+    }
+    else
+        target.current = element;
+}
+/**
+ * Merges the props a parent provided through `context` (for `props.slot`) with the component's own
+ * props (RAC `useContextProps`): own props win, handlers chain, classes join, `style` objects merge
+ * (functions compose). Returns the merged props (without `ref`) and the ref to put on the element.
+ */
+export function contextProps(props, ref, context) {
+    const ctx = (slottedContext(context, props.slot) || {});
+    // Live props (P5): own / context getters stay getters (see `liveContextProps`); the copy path below is unchanged.
+    if (hasLive(props) || hasLive(ctx))
+        return liveContextProps(props, ref, ctx);
+    // `ctxProps` is our copy (merged into in place below); `ownProps` is only read: no copy unless it holds a `ref`.
+    const { ref: contextRef, ...ctxProps } = ctx;
+    const ownProps = Object.hasOwn(props, "ref") ? withoutRef(props) : props;
+    // A slot id (`createSlotId`): this part renders, so the owner's aria-labelledby / -describedby keep it.
+    if (isSlotId(ctxProps.id)) {
+        const slotId = ctxProps.id;
+        ctxProps.id = slotId.id;
+        const own = ownProps.id;
+        if (own === undefined || own === slotId.id)
+            markRendered(slotId);
+        // The part keeps its own id (RA mergeIds): the owner's aria-labelledby / -describedby follow it.
+        else if (typeof own === "string" && own !== "")
+            markRendered(slotId, own);
+    }
+    else if (isMergedId(ctxProps.id)) {
+        // RA mergeIds: the parent's `useId` holder switches to the part's own id (which wins in mergeProps).
+        const mergedId = ctxProps.id;
+        const own = ownProps.id;
+        ctxProps.id = mergedId.id;
+        if (typeof own === "string" && own !== "")
+            setRendered(mergedId.current, own);
+    }
+    const contextStyle = ctxProps.style;
+    // Neither side holds a getter (checked above): the copy path without a second scan; the context copy is the result
+    // (merged in place: `ctxProps` is not read after this).
+    const mergedProps = mergeCopy([ctxProps, ownProps], true);
+    // mergeProps does not merge `style`.
+    if (contextStyle && "style" in ownProps && ownProps.style) {
+        const propsStyle = ownProps.style;
+        if (typeof contextStyle === "function" || typeof propsStyle === "function") {
+            // Object-literal function value: R2 makes it a resumable symbol (an assigned arrow is not), so a
+            // part's resumed style binding may capture it.
+            const composed = {
+                style: (renderProps) => {
+                    const fromContext = typeof contextStyle === "function" ? contextStyle(renderProps) : contextStyle;
+                    const defaultStyle = { ...renderProps.defaultStyle, ...fromContext };
+                    const own = typeof propsStyle === "function" ? propsStyle({ ...renderProps, defaultStyle }) : propsStyle;
+                    return { ...defaultStyle, ...own };
+                },
+            };
+            mergedProps.style = composed.style;
+        }
+        else {
+            mergedProps.style = { ...contextStyle, ...propsStyle };
+        }
+    }
+    return [mergedProps, mergeRefValues(ref, contextRef)];
+}
+function withoutRef(object) {
+    const { ref: _ref, ...rest } = object;
+    return rest;
+}
+/**
+ * `contextProps` over live props (own or context getters): nothing is read while merging. The merged object is the
+ * cdk `mergeProps` live merge of the context props and the own props (both without `ref`, `splitProps` parts that
+ * forward unread): own defined values win per read, handlers chain at call time, classes join in an accessor. `id`
+ * (slot / merged ids) and `ref` are read once (identity props); a live `style` on either side composes at read time.
+ */
+function liveContextProps(props, ref, ctx) {
+    const contextRef = ctx.ref;
+    const ctxId = Object.getOwnPropertyDescriptor(ctx, "id")?.get === undefined ? ctx.id : undefined;
+    // A slot / merged id holder is replaced by its plain id (below), never merged as an object.
+    const ctxProps = splitProps(ctx, isSlotId(ctxId) || isMergedId(ctxId) ? ["ref", "id"] : ["ref"])[1];
+    const ownProps = splitProps(props, ["ref"])[1];
+    let idOverride;
+    if (isSlotId(ctxId)) {
+        const own = props.id;
+        idOverride = { id: ctxId.id };
+        if (own === undefined || own === ctxId.id)
+            markRendered(ctxId);
+        else if (typeof own === "string" && own !== "")
+            markRendered(ctxId, own);
+    }
+    else if (isMergedId(ctxId)) {
+        const own = props.id;
+        idOverride = { id: ctxId.id };
+        if (typeof own === "string" && own !== "")
+            setRendered(ctxId.current, own);
+    }
+    const sources = [ctxProps];
+    if (idOverride)
+        sources.push(idOverride);
+    sources.push(ownProps);
+    // mergeProps does not merge `style`: both sides set → composed at read time (a function style resolves render props).
+    if (Object.hasOwn(ctxProps, "style") && Object.hasOwn(ownProps, "style")) {
+        // One-key views: the composed style (a part's resumed style binding captures it) must not reach the other props
+        // (children capturing a class instance).
+        const ctxStyle = splitProps(ctxProps, ["style"])[0];
+        const ownStyle = splitProps(ownProps, ["style"])[0];
+        const composed = {
+            style: (renderProps) => {
+                const contextStyle = ctxStyle.style;
+                const propsStyle = ownStyle.style;
+                const fromContext = typeof contextStyle === "function" ? contextStyle(renderProps) : contextStyle;
+                const defaultStyle = { ...renderProps?.defaultStyle, ...fromContext };
+                const own = typeof propsStyle === "function" ? propsStyle({ ...renderProps, defaultStyle }) : propsStyle;
+                return { ...defaultStyle, ...own };
+            },
+        };
+        sources.push({ style: composed.style });
+    }
+    return [mergeProps(...sources), mergeRefValues(ref, contextRef)];
+}
+/**
+ * One ref for an element from two refs (RA `mergeRefs` / `useSyncRef` for Rivet refs): either alone is
+ * returned as is; both → a fresh `ref()` whose element a `clientEffect` copies to both (see the header).
+ */
+export function mergeRefValues(own, fromContext) {
+    if (own == null)
+        return fromContext;
+    if (fromContext == null || fromContext === own)
+        return own;
+    const element = createRef();
+    clientEffect(() => {
+        const el = element() ?? null;
+        untrack(() => {
+            assignRef(own, el);
+            assignRef(fromContext, el);
+        });
+    });
+    return element;
+}
+/**
+ * Whether a slotted element (e.g. a `<Heading slot="title">` inside a Dialog) rendered (RAC `useSlot`).
+ * Put the returned ref on the slot element's context value; `hasSlot()` is `initialState` until that
+ * element exists in the browser (server render: `initialState`; resumed page: whether the server
+ * rendered it), then whether it is attached.
+ */
+export function createSlot(initialState = true) {
+    const element = createRef();
+    const initial = typeof initialState === "function" ? initialState() : initialState;
+    // An object-literal function value (R2 rewrites those into resumable symbols; array elements and plain
+    // local consts are not), so a binding on a resumed page may capture `hasSlot`.
+    // RAC useSlot: the ref being set = rendered (set on mount, reset on unmount by the runtime). Server: `initialState`,
+    // or true once the slot part rendered earlier in this render (`markSlotRendered`: RAC's ref callback turns a `false`
+    // initial state true, e.g. a TagGroup with `aria-label` and a visible Label; the resumed page keeps the server value).
+    const slot = { hasSlot: () => element() !== undefined || (typeof document === "undefined" && (initial || element[SLOT_RENDERED] === true)) };
+    return [element, slot.hasSlot];
+}
+const SLOT_RENDERED = Symbol.for("rv.slotRendered");
+/**
+ * @internal Server: the part holding a `createSlot` ref rendered (Label calls it with its context ref), so an owner whose
+ * attributes render after it sees `hasSlot()` true even with a `false` initial state. Browser: unused (the ref is set).
+ */
+export function markSlotRendered(ref) {
+    if (typeof ref === "function")
+        ref[SLOT_RENDERED] = true;
+}
+/**
+ * Creates a slot id (RA `useSlotId(depArray)`); `id` defaults to a generated one; the signals `deps` reads re-run
+ * the check. `deps` is captured by a resumable effect: pass a signal / computed or a local const function, not an
+ * inline arrow argument (arguments are not resumable).
+ */
+export function createSlotId(id, deps) {
+    const slotId = { id: id ?? createId(), rendered: signal(!SERVER) };
+    if (!SERVER)
+        clientEffect(() => {
+            if (deps)
+                deps();
+            // After the DOM updates of this change (RA: layout effect after commit).
+            queueMicrotask(() => syncRendered(slotId, document));
+        });
+    else if (deps)
+        changing.add(slotId);
+    return slotId;
+}
+/** Server render: slot ids created with `deps` (their part may unmount on the resumed page). */
+const changing = new WeakSet();
+/**
+ * The flag follows the DOM. A server id whose part never rendered is `false` already (serialized) while the owner's
+ * attribute still holds it: remove the token from the attributes that reference it (no signal change to re-run the
+ * binding).
+ */
+function syncRendered(slotId, doc) {
+    const flag = untrack(slotId.rendered);
+    const id = typeof flag === "string" ? flag : slotId.id;
+    const present = doc.getElementById(id) !== null;
+    if (present || flag) {
+        if (!(present && typeof flag === "string"))
+            slotId.rendered.set(present);
+        return;
+    }
+    for (const el of doc.querySelectorAll("[aria-describedby], [aria-labelledby]"))
+        for (const name of ["aria-describedby", "aria-labelledby"]) {
+            const tokens = el.getAttribute(name)?.split(/\s+/);
+            if (!tokens?.includes(id))
+                continue;
+            const rest = tokens.filter((token) => token && token !== id);
+            if (rest.length)
+                el.setAttribute(name, rest.join(" "));
+            else
+                el.removeAttribute(name);
+        }
+}
+const SERVER = typeof document === "undefined";
+/**
+ * The slot id's id while it is in use, else `undefined` (read it inside a binding). `expected`: server only, whether
+ * the part may still render later in the tree (an owner reads before its later parts): the id is kept then (RA's
+ * server HTML); a FieldError's id passes the validity (RAC FieldError renders only while invalid).
+ */
+export function slotIdRef(slotId, expected = true) {
+    if (!slotId)
+        return undefined;
+    // Server: read the flag (the owner's binding resumes and follows the part).
+    const flag = slotId.rendered();
+    if (typeof flag === "string")
+        return flag;
+    return flag || (SERVER && expected) ? slotId.id : undefined;
+}
+/**
+ * Server slot probe (`probeSlots`): a hideable part that renders nothing in the probe marks the slot id its context
+ * gives it (the id it would consume through `contextProps`), so the owner can write `slotIdRef(id, false)`.
+ */
+export function probeSlot(props, context) {
+    const id = slottedContext(context, props.slot)?.id;
+    if (!isSlotId(id))
+        return;
+    if (props.id === undefined || props.id === id.id)
+        setRendered(id.rendered, true);
+    else if (typeof props.id === "string" && props.id !== "")
+        setRendered(id.rendered, props.id);
+}
+/** Whether `value` is a `SlotId`. */
+export function isSlotId(value) {
+    return value !== null && typeof value === "object" && typeof value.id === "string" && typeof value.rendered === "function";
+}
+/** Creates a merged id (`id` defaults to a generated one). Read `mergedId.current()` inside bindings. */
+export function createMergedId(id) {
+    const value = id ?? createId();
+    return { id: value, current: signal(value) };
+}
+/** Whether `value` is a `MergedId`. */
+export function isMergedId(value) {
+    return value !== null && typeof value === "object" && typeof value.id === "string" && typeof value.current === "function";
+}
+/** The plain id of an id prop that may be a `MergedId` (its generated `id`). */
+export function mergedIdOf(id) {
+    return isMergedId(id) ? id.id : id;
+}
+function markRendered(slotId, value = true) {
+    setRendered(slotId.rendered, value);
+    // Server: the flag stays set (the part is in the HTML). A part whose id has `deps` may unmount on the resumed page:
+    // its region gets the client cleanup the server cannot hand over (a client effect, so that page boots at idle).
+    if (!SERVER)
+        onCleanup(() => setRendered(slotId.rendered, false));
+    else if (changing.has(slotId))
+        clientEffect(() => () => setRendered(slotId.rendered, false));
+}
+/** Writes the flag; skips no-op writes, and defers one made during a computed evaluation (a build pass). */
+function setRendered(flag, value) {
+    if (untrack(flag) === value)
+        return;
+    try {
+        flag.set(value);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !error.message.includes("during computed evaluation"))
+            throw error;
+        queueMicrotask(() => flag.set(value));
+    }
+}
+/** Filters out `data-*` attributes to keep them from being passed down and duplicated (RAC `removeDataAttributes`). */
+export function removeDataAttributes(props) {
+    const prefix = /^(data-.*)$/;
+    const filteredProps = {};
+    for (const prop in props)
+        if (!prefix.test(prop))
+            filteredProps[prop] = props[prop];
+    return filteredProps;
+}
+/** Registers a part context for resume (`resumableContext(createContext(v, { id: "rv-<name>" }))`). */
+export { resumableContext } from "@rivetjs/runtime/resume-format";

package/spinbutton/behaviour.d.ts

@@ -0,0 +1,66 @@
+import { type MaybeAccessor } from "../interactions/utils.js";
+import type { PressEvent } from "../interactions/press.jsx";
+import { type KeyboardShortcutBindings } from "../interactions/keyboard.jsx";
+export interface SpinButtonProps {
+    /** The current value (NaN / undefined: empty). */
+    value?: MaybeAccessor<number | undefined>;
+    textValue?: MaybeAccessor<string | undefined>;
+    minValue?: MaybeAccessor<number | undefined>;
+    maxValue?: MaybeAccessor<number | undefined>;
+    isDisabled?: MaybeAccessor<boolean | undefined>;
+    isReadOnly?: MaybeAccessor<boolean | undefined>;
+    isRequired?: MaybeAccessor<boolean | undefined>;
+    onIncrement?: () => void;
+    onIncrementPage?: () => void;
+    onDecrement?: () => void;
+    onDecrementPage?: () => void;
+    onDecrementToMin?: () => void;
+    onIncrementToMax?: () => void;
+    /** Rivet: locale of the "Empty" string (RA: `useLocale()`); default `en-US`. */
+    locale?: MaybeAccessor<string | undefined>;
+}
+/** Rivet: RA's refs / state of one spin button (plain JSON, mutated by the handlers). */
+export interface SpinButtonState {
+    /** Pending spin timer id (browser). */
+    timer: number | undefined;
+    isSpinning: boolean;
+    isFocused: boolean;
+    isUp: boolean;
+    isIncrementPressed: "touch" | "mouse" | null;
+    isDecrementPressed: "touch" | "mouse" | null;
+}
+export declare const createSpinButtonState: () => SpinButtonState;
+export interface SpinbuttonAria {
+    spinButtonProps: Record<string, unknown>;
+    incrementButtonProps: Record<string, unknown>;
+    decrementButtonProps: Record<string, unknown>;
+}
+/**
+ * Replace Unicode hyphen-minus (U+002D) with minus sign (U+2212).
+ * This ensures that macOS VoiceOver announces it as "minus" even with other characters between the minus sign
+ * and the number (e.g. currency symbol). Otherwise it announces nothing because it assumes the character is a hyphen.
+ * In addition, replace the empty string with the word "Empty" so that iOS VoiceOver does not read "50%" for an empty field.
+ */
+export declare function spinButtonTextValue(props: SpinButtonProps): string;
+/** RA `clearAsync`. */
+export declare function spinButtonClearAsync(state: SpinButtonState): void;
+/** Provides the behavior and accessibility implementation for a spin button (RA `useSpinButton`). */
+export declare function spinButtonProps(props: SpinButtonProps): SpinbuttonAria;
+/** RA's `useKeyboard` shortcuts of the spin button (a handler returning `false` = not handled). */
+export declare function spinButtonShortcuts(props: SpinButtonProps): KeyboardShortcutBindings;
+/** RA `keyboardProps.onKeyDown` of the spin button (`useKeyboard({ isDisabled: isDisabled || isReadOnly, shortcuts, allowRepeats })`). */
+export declare function spinButtonKeyDown(event: KeyboardEvent, props: SpinButtonProps, _state?: SpinButtonState): void;
+/** RA `keyboardProps.onKeyUp` of the spin button. */
+export declare function spinButtonKeyUp(event: KeyboardEvent, props: SpinButtonProps, _state?: SpinButtonState): void;
+/** RA `onFocus` (spin button and stepper buttons): starts announcing text changes. */
+export declare function spinButtonFocus(_event: Event | null, props: SpinButtonProps, state: SpinButtonState): void;
+/** RA `onBlur`. */
+export declare function spinButtonBlur(_event: Event | null, _props: SpinButtonProps, state: SpinButtonState): void;
+/** RA cleanup on unmount (`clearAsync`, global listeners). */
+export declare function spinButtonDispose(state: SpinButtonState): void;
+export declare function spinButtonIncrementPressStart(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;
+export declare function spinButtonIncrementPressUp(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;
+export declare function spinButtonIncrementPressEnd(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;
+export declare function spinButtonDecrementPressStart(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;
+export declare function spinButtonDecrementPressUp(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;
+export declare function spinButtonDecrementPressEnd(e: PressEvent, props: SpinButtonProps, state: SpinButtonState): void;