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

package/state/toast.d.ts

@@ -0,0 +1,80 @@
+export type ToastAction = "add" | "remove" | "clear";
+/** Event dispatched on `document` by a queue update while no region subscribes (detail: the queue). */
+export declare const TOAST_QUEUE_EVENT = "rv-toast-queue";
+export interface ToastStateProps {
+    /** The maximum number of toasts to display at a time. */
+    maxVisibleToasts?: number;
+    /** Function to wrap updates in (i.e. document.startViewTransition()). */
+    wrapUpdate?: (fn: () => void, action: ToastAction) => void;
+    /** Rivet: name a server-rendered `<ToastRegion>` uses to find this queue on a resumed page. @default "default" */
+    name?: string;
+}
+export interface ToastOptions {
+    /** Handler that is called when the toast is closed, either by the user or after a timeout. */
+    onClose?: () => void;
+    /** A timeout to automatically close the toast after, in milliseconds. */
+    timeout?: number;
+}
+export interface QueuedToast<T> extends ToastOptions {
+    /** The content of the toast. */
+    content: T;
+    /** A unique key for the toast. */
+    key: string;
+    /** A timer for the toast, if a timeout was set. */
+    timer?: Timer;
+}
+export interface ToastState<T> {
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /** Closes a toast. */
+    close(key: string): void;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    /** The visible toasts (Rivet: a signal accessor). */
+    visibleToasts: () => QueuedToast<T>[];
+}
+/**
+ * Provides state management for a toast queue. Toasts display brief, temporary notifications
+ * of actions, errors, or other events in an application.
+ */
+export declare function createToastState<T>(props?: ToastStateProps): ToastState<T>;
+/** Subscribes to a provided toast queue and provides methods to update it. */
+export declare function createToastQueueState<T>(queue: ToastQueue<T>): ToastState<T>;
+/** A ToastQueue manages the order of toasts. */
+export declare class ToastQueue<T> {
+    private queue;
+    private subscriptions;
+    private maxVisibleToasts;
+    private wrapUpdate?;
+    /** Rivet: name a server-rendered `<ToastRegion>` uses to find this queue. */
+    readonly name: string;
+    /** The currently visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+    constructor(options?: ToastStateProps);
+    private runWithWrapUpdate;
+    /** Subscribes to updates to the visible toasts. */
+    subscribe(fn: () => void): () => void;
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /** Closes a toast. */
+    close(key: string): void;
+    private updateVisibleToasts;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    clear(): void;
+}
+/** A pausable countdown. */
+export declare class Timer {
+    private timerId;
+    private startTime;
+    private remaining;
+    private callback;
+    constructor(callback: () => void, delay: number);
+    reset(delay: number): void;
+    pause(): void;
+    resume(): void;
+}

package/state/toast.js

@@ -0,0 +1,146 @@
+// Ported from react-stately (packages/react-stately/src/toast/useToastState.ts: useToastState,
+// useToastQueue, ToastQueue, Timer), Apache-2.0, © Adobe.
+// Rivet:
+// - `useToastQueue(queue)` → `createToastQueueState(queue)`: subscribes (owned: unsubscribes on owner
+//   cleanup) and returns the ToastState with `visibleToasts` as a signal accessor; `useToastState(props)`
+//   → `createToastState(props)` = `createToastQueueState(new ToastQueue(props))`.
+// - `ToastQueue` is used directly (browser module singleton, as the original's recommended global queue).
+//   A queue carries a `name` (default "default") so a server-rendered `<ToastRegion queue>` finds it on a
+//   resumed page: while no region subscribes, every update also dispatches `TOAST_QUEUE_EVENT` on
+//   `document` (detail: the queue) inside `wrapUpdate`; the region's resumable `clientEvent` connects on
+//   it (its chunk loads on the first toast).
+// Deviation: `Timer.reset` clears a running countdown and `Timer.resume` is a no-op while running (the
+//   original starts a second `setTimeout`, so a toast whose region resumes timers twice closes twice).
+import { getOwner, onCleanup, signal } from "@rivetjs/reactivity";
+/** Event dispatched on `document` by a queue update while no region subscribes (detail: the queue). */
+export const TOAST_QUEUE_EVENT = "rv-toast-queue";
+/**
+ * Provides state management for a toast queue. Toasts display brief, temporary notifications
+ * of actions, errors, or other events in an application.
+ */
+export function createToastState(props = {}) {
+    const { maxVisibleToasts = 1, wrapUpdate, name } = props;
+    return createToastQueueState(new ToastQueue({ maxVisibleToasts, wrapUpdate, name }));
+}
+/** Subscribes to a provided toast queue and provides methods to update it. */
+export function createToastQueueState(queue) {
+    const visibleToasts = signal(queue.visibleToasts);
+    const unsubscribe = queue.subscribe(() => visibleToasts.set(queue.visibleToasts));
+    if (getOwner())
+        onCleanup(unsubscribe);
+    return {
+        visibleToasts,
+        add: (content, options) => queue.add(content, options),
+        close: (key) => queue.close(key),
+        pauseAll: () => queue.pauseAll(),
+        resumeAll: () => queue.resumeAll(),
+    };
+}
+/** A ToastQueue manages the order of toasts. */
+export class ToastQueue {
+    queue = [];
+    subscriptions = new Set();
+    maxVisibleToasts;
+    wrapUpdate;
+    /** Rivet: name a server-rendered `<ToastRegion>` uses to find this queue. */
+    name;
+    /** The currently visible toasts. */
+    visibleToasts = [];
+    constructor(options) {
+        this.maxVisibleToasts = options?.maxVisibleToasts ?? Infinity;
+        this.wrapUpdate = options?.wrapUpdate;
+        this.name = options?.name ?? "default";
+    }
+    runWithWrapUpdate(fn, action) {
+        if (this.wrapUpdate)
+            this.wrapUpdate(fn, action);
+        else
+            fn();
+    }
+    /** Subscribes to updates to the visible toasts. */
+    subscribe(fn) {
+        this.subscriptions.add(fn);
+        return () => this.subscriptions.delete(fn);
+    }
+    /** Adds a new toast to the queue. */
+    add(content, options = {}) {
+        const toastKey = "_" + Math.random().toString(36).slice(2);
+        const toast = {
+            ...options,
+            content,
+            key: toastKey,
+            timer: options.timeout ? new Timer(() => this.close(toastKey), options.timeout) : undefined,
+        };
+        this.queue.unshift(toast);
+        this.updateVisibleToasts("add");
+        return toastKey;
+    }
+    /** Closes a toast. */
+    close(key) {
+        const index = this.queue.findIndex((t) => t.key === key);
+        if (index >= 0) {
+            this.queue[index].onClose?.();
+            this.queue.splice(index, 1);
+        }
+        this.updateVisibleToasts("remove");
+    }
+    updateVisibleToasts(action) {
+        this.visibleToasts = this.queue.slice(0, this.maxVisibleToasts);
+        this.runWithWrapUpdate(() => {
+            // Rivet: no region connected yet (resumed page) → wake the server-rendered regions.
+            if (this.subscriptions.size === 0 && typeof document !== "undefined" && this.visibleToasts.length > 0)
+                document.dispatchEvent(new CustomEvent(TOAST_QUEUE_EVENT, { detail: this }));
+            for (const fn of [...this.subscriptions])
+                fn();
+        }, action);
+    }
+    /** Pauses the timers for all visible toasts. */
+    pauseAll() {
+        for (const toast of this.visibleToasts)
+            toast.timer?.pause();
+    }
+    /** Resumes the timers for all visible toasts. */
+    resumeAll() {
+        for (const toast of this.visibleToasts)
+            toast.timer?.resume();
+    }
+    clear() {
+        this.queue = [];
+        this.updateVisibleToasts("clear");
+    }
+}
+/** A pausable countdown. */
+export class Timer {
+    timerId = null;
+    startTime = null;
+    remaining;
+    callback;
+    constructor(callback, delay) {
+        this.remaining = delay;
+        this.callback = callback;
+    }
+    reset(delay) {
+        if (this.timerId != null)
+            clearTimeout(this.timerId);
+        this.timerId = null;
+        this.remaining = delay;
+        this.resume();
+    }
+    pause() {
+        if (this.timerId == null)
+            return;
+        clearTimeout(this.timerId);
+        this.timerId = null;
+        this.remaining -= Date.now() - this.startTime;
+    }
+    resume() {
+        if (this.remaining <= 0 || this.timerId != null)
+            return;
+        this.startTime = Date.now();
+        this.timerId = setTimeout(() => {
+            this.timerId = null;
+            this.remaining = 0;
+            this.callback();
+        }, this.remaining);
+    }
+}

package/state/toggle-group.d.ts

@@ -0,0 +1,70 @@
+import { type Signal } from "@rivetjs/reactivity";
+import type { Key } from "../collections/types.js";
+export interface ToggleGroupProps {
+    /**
+     * Whether single or multiple selection is enabled. Read once at mount (it picks the group / item roles and the selection model).
+     *
+     * @default 'single'
+     */
+    selectionMode?: "single" | "multiple";
+    /** Whether the collection allows empty selection (live through the `live` source: `ToggleButtonGroup`). */
+    disallowEmptySelection?: boolean;
+    /** The currently selected keys in the collection (controlled: a plain iterable, or a two-way Signal). */
+    selectedKeys?: Iterable<Key> | Signal<Iterable<Key>> | (() => Iterable<Key>);
+    /** The initial selected keys in the collection (uncontrolled). */
+    defaultSelectedKeys?: Iterable<Key>;
+    /** Handler that is called when the selection changes. */
+    onSelectionChange?: (keys: Set<Key>) => void;
+    /** Whether all items are disabled. */
+    isDisabled?: boolean;
+    /**
+     * Rivet extension: the selected key in single selection (controlled: a plain key or `null`, or a two-way `Signal<Key | null>`).
+     * Ignored when `selectedKeys` is given.
+     */
+    selectedKey?: Key | null | Signal<Key | null> | Signal<string | null> | Signal<number | null> | (() => Key | null);
+    /** Rivet extension: the initial selected key in single selection (uncontrolled). Ignored when `defaultSelectedKeys` is given. */
+    defaultSelectedKey?: Key;
+}
+export interface ToggleGroupState {
+    /** Whether single or multiple selection is enabled. */
+    readonly selectionMode: "single" | "multiple";
+    /** Whether all items are disabled, when the state was created (live: `isGroupDisabled(state)`). */
+    readonly isDisabled: boolean;
+    /** Rivet: live source of `isDisabled` (`createToggleGroupState(props, live)`), read by `isGroupDisabled`. */
+    readonly live: ToggleGroupLive | undefined;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection: boolean;
+    /** A set of keys for items that are selected (read it to track). */
+    readonly selectedKeys: Signal<Set<Key>>;
+    /** Two-way selection Signal given as `selectedKeys` (written on change). */
+    readonly source: Signal<Iterable<Key>> | undefined;
+    /** Rivet: two-way single-key Signal given as `selectedKey` (written with the first selected key, or `null`). */
+    readonly keySource?: Signal<Key | null> | undefined;
+    /** Plain / accessor controlled `selectedKeys` / `selectedKey`: changes are only reported. */
+    readonly controlled: boolean;
+    readonly onSelectionChange: ((keys: Set<Key>) => void) | undefined;
+}
+/** Rivet: live sources of the group flags (an object of getters, e.g. `ToggleButtonGroup`'s own props / context). */
+export interface ToggleGroupLive {
+    readonly isDisabled?: boolean;
+    readonly disallowEmptySelection?: boolean;
+}
+/**
+ * Manages state for a group of toggles.
+ * It supports both single and multiple selected items.
+ */
+export declare function createToggleGroupState(props?: ToggleGroupProps, live?: ToggleGroupLive): ToggleGroupState;
+/** Whether the group is disabled now: the live source when given (tracked when it reads signals), else `state.isDisabled`. */
+export declare function isGroupDisabled(state: ToggleGroupState): boolean;
+/** Whether empty selection is disallowed now: the live source when it defines it, else `state.disallowEmptySelection`. */
+export declare function isEmptySelectionDisallowed(state: ToggleGroupState): boolean;
+/** Selected keys: the two-way source when given (tracked), else the state's own set. */
+export declare function selectedKeysOf(state: ToggleGroupState): Set<Key>;
+/** Whether `key` is selected (tracked). */
+export declare function isKeySelected(state: ToggleGroupState, key: Key): boolean;
+/** Replaces the set of selected keys (RA `setSelectedKeys`). */
+export declare function setSelectedKeys(state: ToggleGroupState, keys: Set<Key>): void;
+/** Toggles the selected state for an item by its key. */
+export declare function toggleKey(state: ToggleGroupState, key: Key): void;
+/** Sets whether the given key is selected. */
+export declare function setSelected(state: ToggleGroupState, key: Key, isSelected: boolean): void;

package/state/toggle-group.js

@@ -0,0 +1,110 @@
+// Ported from react-stately `useToggleGroupState` (packages/react-stately/src/toggle/useToggleGroupState.ts), Apache-2.0, © Adobe.
+// Toggle group state (ToggleButtonGroup): pure signals + JSON, serializable, server-safe.
+// Rivet:
+// - `selectedKeys` (RA `useControlledState`): a `Signal<Iterable<Key>>` is two-way (written on every change);
+//   a plain iterable is controlled (the signal keeps it, only `onSelectionChange` reports changes), so is an accessor
+//   (a live prop: read on use, never written); omitted →
+//   uncontrolled from `defaultSelectedKeys`. Read the selection with `selectedKeysOf(state)` / `isKeySelected`.
+// - Methods are free functions taking the state (`toggleKey(state, key)`, `setSelected`, `setSelectedKeys`).
+// - `useControlledState` calls `onChange` when the new value is not `Object.is` the current one; every write
+//   here is a fresh Set, so `onSelectionChange` fires on every toggle (upstream behaviour).
+// - Live `isDisabled` (React re-creates the state with the new prop each render): `state.isDisabled` is the value at creation
+//   (plain data, so the state encodes by value on resume: a getter would make the resume encoder rebuild it from its recipe,
+//   with a fresh selection signal the server bindings do not track); `live` (2nd argument, a compiler-registered getter
+//   object of the component) is read by `isGroupDisabled(state)`, which every in-cdk reader uses. Only the selection signal
+//   is region state (`_regionState`): a re-created region gets the server's selection back, the rest from its fresh props.
+// - Rivet extension (no RAC counterpart; RAC Tabs / Select / RadioGroup shape): `selectedKey` / `defaultSelectedKey` for single
+//   selection. A `Signal<Key | null>` is two-way (`keySource`, written with the first key of the new set or `null`); a plain key is
+//   controlled (= `selectedKeys: [key]`); `defaultSelectedKey` = `defaultSelectedKeys: [key]`. `selectedKeys` wins when both are given.
+//   Used by `@rivetjs/ui/segment` (feature set inspired by HeroUI Pro's public docs).
+import { signal, untrack, _regionState } from "@rivetjs/reactivity";
+const isSignal = (value) => typeof value === "function" && typeof value.set === "function";
+/**
+ * Manages state for a group of toggles.
+ * It supports both single and multiple selected items.
+ */
+export function createToggleGroupState(props = {}, live) {
+    const { selectionMode = "single", disallowEmptySelection = false } = props;
+    const keyProp = props.selectedKeys === undefined ? props.selectedKey : undefined;
+    // A Signal is two-way; an accessor (live prop `selectedKeys={k()}`) is read as is and never written (`controlled`).
+    const keySource = typeof keyProp === "function" ? keyProp : undefined;
+    const prop = props.selectedKeys ?? (keyProp === undefined || keySource ? undefined : keyProp === null ? [] : [keyProp]);
+    const source = typeof prop === "function" ? prop : undefined;
+    const controlled = (prop != null && !isSignal(prop)) || (keySource !== undefined && !isSignal(keySource));
+    const defaults = props.defaultSelectedKeys ?? (props.defaultSelectedKey !== undefined ? [props.defaultSelectedKey] : []);
+    // Region state: a resumed page re-creating the group's region keeps the selection.
+    const selectedKeys = _regionState(() => signal(new Set(source || keySource ? [] : controlled ? prop : defaults)));
+    return {
+        selectionMode,
+        isDisabled: !!props.isDisabled,
+        disallowEmptySelection,
+        selectedKeys,
+        source,
+        keySource,
+        controlled,
+        onSelectionChange: props.onSelectionChange,
+        live,
+    };
+}
+/** Whether the group is disabled now: the live source when given (tracked when it reads signals), else `state.isDisabled`. */
+export function isGroupDisabled(state) {
+    return state.live !== undefined ? !!state.live.isDisabled : state.isDisabled;
+}
+/** Whether empty selection is disallowed now: the live source when it defines it, else `state.disallowEmptySelection`. */
+export function isEmptySelectionDisallowed(state) {
+    const live = state.live?.disallowEmptySelection;
+    return live !== undefined ? !!live : state.disallowEmptySelection;
+}
+/** Selected keys: the two-way source when given (tracked), else the state's own set. */
+export function selectedKeysOf(state) {
+    if (state.keySource) {
+        const key = state.keySource();
+        return new Set(key == null ? [] : [key]);
+    }
+    if (state.source) {
+        const value = state.source();
+        return value instanceof Set ? value : new Set(value);
+    }
+    return state.selectedKeys();
+}
+/** Whether `key` is selected (tracked). */
+export function isKeySelected(state, key) {
+    return selectedKeysOf(state).has(key);
+}
+/** Replaces the set of selected keys (RA `setSelectedKeys`). */
+export function setSelectedKeys(state, keys) {
+    const current = untrack(() => selectedKeysOf(state));
+    if (Object.is(current, keys))
+        return;
+    if (!state.controlled) {
+        if (state.keySource)
+            state.keySource.set(keys.values().next().value ?? null);
+        else if (state.source)
+            state.source.set(keys);
+        else
+            state.selectedKeys.set(keys);
+    }
+    state.onSelectionChange?.(keys);
+}
+/** Toggles the selected state for an item by its key. */
+export function toggleKey(state, key) {
+    const selectedKeys = untrack(() => selectedKeysOf(state));
+    const disallowEmpty = untrack(() => isEmptySelectionDisallowed(state));
+    let keys;
+    if (state.selectionMode === "multiple") {
+        keys = new Set(selectedKeys);
+        if (keys.has(key) && (!disallowEmpty || keys.size > 1))
+            keys.delete(key);
+        else
+            keys.add(key);
+    }
+    else {
+        keys = new Set(selectedKeys.has(key) && !disallowEmpty ? [] : [key]);
+    }
+    setSelectedKeys(state, keys);
+}
+/** Sets whether the given key is selected. */
+export function setSelected(state, key, isSelected) {
+    if (isSelected !== untrack(() => selectedKeysOf(state)).has(key))
+        toggleKey(state, key);
+}

package/state/toggle.d.ts

@@ -0,0 +1,40 @@
+import { type Signal } from "@rivetjs/reactivity";
+import { type ControlledState } from "../interactions/controllable.js";
+export interface ToggleState {
+    /** The shown selection (read `state.selected()` in bindings; change with `setSelected`). */
+    readonly selected: () => boolean;
+    /** RA `useControlledState` state behind `selected`. */
+    readonly controlled: ControlledState<boolean>;
+    /** RA `defaultSelected`: value restored on form reset (`defaultSelected ?? initial`). */
+    readonly defaultSelected: boolean;
+    /** Rivet: `isDisabled` when created (RA hooks check it; `toggle` ignores a disabled state). */
+    readonly disabled: boolean;
+    /** Rivet: the caller's `isDisabled` accessor (read by `toggle`), when it passed one. */
+    readonly isDisabled?: () => boolean | undefined;
+    readonly readOnly: boolean;
+    /** Rivet: the caller's `isReadOnly` accessor (live props), when it passed one. */
+    readonly isReadOnly?: () => boolean | undefined;
+}
+/** RA `ToggleStateOptions`. */
+export interface ToggleStateOptions {
+    /** Whether the element should be selected (controlled): a plain value, a two-way Signal or an accessor. */
+    isSelected?: boolean | Signal<boolean> | (() => boolean);
+    /** Whether the element should be selected (uncontrolled). */
+    defaultSelected?: boolean;
+    /** Handler that is called when the element's selection state changes. */
+    onChange?: (isSelected: boolean) => void;
+    /** Whether the input can be selected but not changed by the user (a value, or an accessor that stays live). */
+    isReadOnly?: boolean | (() => boolean | undefined) | undefined;
+    /** Whether the input is disabled (a value, or an accessor that stays live). */
+    isDisabled?: boolean | (() => boolean | undefined) | undefined;
+}
+/** RA `useToggleState`. */
+export declare function createToggleState(options?: ToggleStateOptions): ToggleState;
+/** RA `setSelected`: ignored while read-only; calls `onChange` when the value changes. */
+export declare function setSelected(state: ToggleState, value: boolean): void;
+/** RA `toggle`: flip unless read-only (Rivet: also unless disabled — the hooks never toggle a disabled control). */
+export declare function toggle(state: ToggleState): void;
+/** The current selection including a write earlier in the same task (RA `isSelected` after setState). */
+export declare const isToggleSelected: (state: ToggleState) => boolean;
+/** Whether the state is read-only now (its live `isReadOnly` accessor, else the creation value). */
+export declare const isToggleReadOnly: (state: ToggleState) => boolean;

package/state/toggle.js

@@ -0,0 +1,39 @@
+// Ported from react-stately `useToggleState` (packages/react-stately/src/toggle/useToggleState.ts), Apache-2.0, © Adobe.
+// Toggle state (ToggleButton, Checkbox, Switch): pure signals, serializable, server-safe.
+// Rivet: RA `isSelected` (plain value or two-way Signal) / `defaultSelected` / `onChange` through
+// `controllable` (react-stately useControlledState port); `isSelected` may also be an accessor
+// (`() => boolean`: controlled by the caller's state, live without re-creating the state; changes are
+// reported through `onChange`). `selected` reads the shown value; `setSelected` / `toggle` are free functions.
+import { untrack } from "@rivetjs/reactivity";
+import { controllable, controlledValue, setControlledValue } from "../interactions/controllable.js";
+/** RA `useToggleState`. */
+export function createToggleState(options = {}) {
+    const isDisabled = options.isDisabled;
+    const isReadOnly = options.isReadOnly;
+    const controlled = controllable(options.isSelected, options.defaultSelected || false, options.onChange);
+    return {
+        selected: controlled.value,
+        controlled,
+        defaultSelected: options.defaultSelected ?? untrack(controlled.value),
+        disabled: !!untrack(() => (typeof isDisabled === "function" ? isDisabled() : isDisabled)),
+        ...(typeof isDisabled === "function" ? { isDisabled } : {}),
+        readOnly: !!untrack(() => (typeof isReadOnly === "function" ? isReadOnly() : isReadOnly)),
+        ...(typeof isReadOnly === "function" ? { isReadOnly } : {}),
+    };
+}
+/** RA `setSelected`: ignored while read-only; calls `onChange` when the value changes. */
+export function setSelected(state, value) {
+    if (isToggleReadOnly(state))
+        return;
+    setControlledValue(state.controlled, value);
+}
+/** RA `toggle`: flip unless read-only (Rivet: also unless disabled — the hooks never toggle a disabled control). */
+export function toggle(state) {
+    if (isToggleReadOnly(state) || (state.isDisabled ? !!state.isDisabled() : state.disabled))
+        return;
+    setSelected(state, !isToggleSelected(state));
+}
+/** The current selection including a write earlier in the same task (RA `isSelected` after setState). */
+export const isToggleSelected = (state) => untrack(() => controlledValue(state.controlled));
+/** Whether the state is read-only now (its live `isReadOnly` accessor, else the creation value). */
+export const isToggleReadOnly = (state) => (state.isReadOnly ? !!untrack(state.isReadOnly) : state.readOnly);

package/state/tooltip.d.ts

@@ -0,0 +1,53 @@
+import { type Signal } from "@rivetjs/reactivity";
+import { type OverlayTriggerProps, type OverlayTriggerState } from "./overlays.js";
+export interface TooltipTriggerProps extends OverlayTriggerProps {
+    /** Whether the tooltip should be disabled, independent from the trigger. A boolean, or an accessor read at event time (Rivet; e.g. Sidebar menu tooltips, enabled only while collapsed). */
+    isDisabled?: boolean | (() => boolean | undefined);
+    /** The delay time for the tooltip to show up (ms; a number, or an accessor read at event time: live). @default 1500 */
+    delay?: number | (() => number | undefined);
+    /** The delay time for the tooltip to close (ms; a number, or an accessor read at event time: live). @default 500 */
+    closeDelay?: number | (() => number | undefined);
+    /** By default, opens for both focus and hover. Can be made to open only for focus (or an accessor read at event time: live). @default 'hover' */
+    trigger?: "hover" | "focus" | (() => "hover" | "focus" | undefined);
+    /** Whether the tooltip should close when the trigger is pressed (or an accessor read at event time: live). @default true */
+    shouldCloseOnPress?: boolean | (() => boolean | undefined);
+}
+export declare const TOOLTIP_DELAY = 1500;
+export declare const TOOLTIP_COOLDOWN = 500;
+export interface TooltipTriggerState extends OverlayTriggerState {
+    /**
+     * Whether the tooltip is being shown or hidden without an animation. This is true while the
+     * global warmup timer is active, i.e. when quickly moving between tooltips.
+     */
+    readonly shouldSkipAnimation: Signal<boolean>;
+    /** The show delay when the state was created (live: `tooltipDelay(state)`). */
+    readonly delay: number;
+    /** The close delay when the state was created (live: `tooltipCloseDelay(state)`). */
+    readonly closeDelay: number;
+    /** Rivet: live `delay` / `closeDelay` accessors (read at event time). */
+    readonly live?: {
+        readonly delay?: () => number | undefined;
+        readonly closeDelay?: () => number | undefined;
+    };
+}
+/** The show delay now (ms): the live accessor when given (untracked: event time), else `state.delay`. */
+export declare const tooltipDelay: (state: TooltipTriggerState) => number;
+/** The close delay now (ms): the live accessor when given (untracked: event time), else `state.closeDelay`. */
+export declare const tooltipCloseDelay: (state: TooltipTriggerState) => number;
+/**
+ * Manages state for a tooltip trigger. Tracks whether the tooltip is open, and provides methods to
+ * toggle this state. Ensures only one tooltip is open at a time and controls the delay for showing a
+ * tooltip (react-stately `useTooltipTriggerState`).
+ */
+export declare function createTooltipTriggerState(props?: TooltipTriggerProps): TooltipTriggerState;
+/**
+ * Shows the tooltip. By default, the tooltip becomes visible after a delay depending on a global
+ * warmup timer. The `immediate` option shows the tooltip immediately instead.
+ */
+export declare function openTooltip(state: TooltipTriggerState, immediate?: boolean): void;
+/** Hides the tooltip (after `closeDelay` unless `immediate`). */
+export declare function closeTooltip(state: TooltipTriggerState, immediate?: boolean): void;
+/** The original's unmount effect: cancel the close timer and drop the tooltip from the registry. */
+export declare function disposeTooltip(state: TooltipTriggerState): void;
+/** Test hook: reset the global warmup / cooldown state. */
+export declare function _resetTooltips(): void;