@ansh-ui/react 0.2.0

package/dist/position-DVScKcaa.d.cts

@@ -0,0 +1,66 @@
+/**
+ * Anchored positioning.
+ *
+ * Popovers, tooltips, menus and comboboxes all need the same thing: place a floating box next to an
+ * anchor, keep it on screen, and report where it actually ended up so the arrow can point the right
+ * way. This is that calculation, as a **pure function** of rectangles.
+ *
+ * Keeping it pure is deliberate. Positioning bugs are notoriously hard to reproduce — they depend
+ * on scroll offset, viewport size and element dimensions all at once. As a pure function the whole
+ * space is testable in milliseconds without a browser, which is why the edge cases below (flipping
+ * into *less* space, shifting past the anchor, both axes at once) are covered by tests rather than
+ * by hoping.
+ *
+ * This is a focused ~200-line implementation, not a Floating UI replacement: it does offset, flip,
+ * shift, size-matching and arrow placement, which is what these components need. It does not do
+ * auto-placement search, virtual elements or `position: absolute` containing-block resolution —
+ * everything here assumes `position: fixed` against the viewport, which is the only strategy that
+ * is correct inside transformed and clipped ancestors.
+ */
+type Side = 'top' | 'right' | 'bottom' | 'left';
+type Align = 'start' | 'center' | 'end';
+type Placement = Side | `${Side}-${Align}`;
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface PositionOptions {
+    /** Preferred placement. Default `'bottom'`. */
+    placement?: Placement;
+    /** Gap between anchor and floating element, in px. Default `8`. */
+    offset?: number;
+    /** Minimum distance to keep from the viewport edge, in px. Default `8`. */
+    padding?: number;
+    /** Flip to the opposite side when there isn't room. Default `true`. */
+    flip?: boolean;
+    /** Slide along the cross axis to stay on screen. Default `true`. */
+    shift?: boolean;
+    /** Size of the arrow, in px, if one is being positioned. Default `0` (no arrow). */
+    arrowSize?: number;
+}
+interface PositionResult {
+    /** Viewport coordinates for the floating element's top-left corner. */
+    x: number;
+    y: number;
+    /** Where it actually ended up — may differ from the request if it flipped. */
+    placement: Placement;
+    side: Side;
+    align: Align;
+    /** Arrow offset along the anchor's edge, or `null` when `arrowSize` is 0. */
+    arrow: {
+        x: number;
+        y: number;
+    } | null;
+    /** True when the anchor is entirely outside the viewport — callers usually hide the surface. */
+    hidden: boolean;
+}
+/**
+ * Compute where a floating element should sit.
+ *
+ * All rectangles are in viewport coordinates, as `getBoundingClientRect` returns them.
+ */
+declare function computePosition(anchor: Rect, floating: Rect, viewport: Rect, options?: PositionOptions): PositionResult;
+
+export { type Align as A, type Placement as P, type Rect as R, type Side as S, type PositionOptions as a, type PositionResult as b, computePosition as c };

package/dist/position-DVScKcaa.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Anchored positioning.
+ *
+ * Popovers, tooltips, menus and comboboxes all need the same thing: place a floating box next to an
+ * anchor, keep it on screen, and report where it actually ended up so the arrow can point the right
+ * way. This is that calculation, as a **pure function** of rectangles.
+ *
+ * Keeping it pure is deliberate. Positioning bugs are notoriously hard to reproduce — they depend
+ * on scroll offset, viewport size and element dimensions all at once. As a pure function the whole
+ * space is testable in milliseconds without a browser, which is why the edge cases below (flipping
+ * into *less* space, shifting past the anchor, both axes at once) are covered by tests rather than
+ * by hoping.
+ *
+ * This is a focused ~200-line implementation, not a Floating UI replacement: it does offset, flip,
+ * shift, size-matching and arrow placement, which is what these components need. It does not do
+ * auto-placement search, virtual elements or `position: absolute` containing-block resolution —
+ * everything here assumes `position: fixed` against the viewport, which is the only strategy that
+ * is correct inside transformed and clipped ancestors.
+ */
+type Side = 'top' | 'right' | 'bottom' | 'left';
+type Align = 'start' | 'center' | 'end';
+type Placement = Side | `${Side}-${Align}`;
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface PositionOptions {
+    /** Preferred placement. Default `'bottom'`. */
+    placement?: Placement;
+    /** Gap between anchor and floating element, in px. Default `8`. */
+    offset?: number;
+    /** Minimum distance to keep from the viewport edge, in px. Default `8`. */
+    padding?: number;
+    /** Flip to the opposite side when there isn't room. Default `true`. */
+    flip?: boolean;
+    /** Slide along the cross axis to stay on screen. Default `true`. */
+    shift?: boolean;
+    /** Size of the arrow, in px, if one is being positioned. Default `0` (no arrow). */
+    arrowSize?: number;
+}
+interface PositionResult {
+    /** Viewport coordinates for the floating element's top-left corner. */
+    x: number;
+    y: number;
+    /** Where it actually ended up — may differ from the request if it flipped. */
+    placement: Placement;
+    side: Side;
+    align: Align;
+    /** Arrow offset along the anchor's edge, or `null` when `arrowSize` is 0. */
+    arrow: {
+        x: number;
+        y: number;
+    } | null;
+    /** True when the anchor is entirely outside the viewport — callers usually hide the surface. */
+    hidden: boolean;
+}
+/**
+ * Compute where a floating element should sit.
+ *
+ * All rectangles are in viewport coordinates, as `getBoundingClientRect` returns them.
+ */
+declare function computePosition(anchor: Rect, floating: Rect, viewport: Rect, options?: PositionOptions): PositionResult;
+
+export { type Align as A, type Placement as P, type Rect as R, type Side as S, type PositionOptions as a, type PositionResult as b, computePosition as c };

package/dist/primitives.cjs

@@ -0,0 +1,162 @@
+'use client';
+'use strict';
+
+var chunkOHBWBXLO_cjs = require('./chunk-OHBWBXLO.cjs');
+var chunkC32LKF23_cjs = require('./chunk-C32LKF23.cjs');
+var chunkXMXECSQO_cjs = require('./chunk-XMXECSQO.cjs');
+var chunkPO5DU3FU_cjs = require('./chunk-PO5DU3FU.cjs');
+var chunk6VRF7X5C_cjs = require('./chunk-6VRF7X5C.cjs');
+var chunkSFU5EPSN_cjs = require('./chunk-SFU5EPSN.cjs');
+
+
+
+Object.defineProperty(exports, "useAnimate", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useAnimate; }
+});
+Object.defineProperty(exports, "useIsMounted", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useIsMounted; }
+});
+Object.defineProperty(exports, "useMotionStyle", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useMotionStyle; }
+});
+Object.defineProperty(exports, "useMotionValue", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useMotionValue; }
+});
+Object.defineProperty(exports, "useMotionValueState", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useMotionValueState; }
+});
+Object.defineProperty(exports, "useSpringValue", {
+  enumerable: true,
+  get: function () { return chunkOHBWBXLO_cjs.useSpringValue; }
+});
+Object.defineProperty(exports, "Presence", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.Presence; }
+});
+Object.defineProperty(exports, "Slot", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.Slot; }
+});
+Object.defineProperty(exports, "countElements", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.countElements; }
+});
+Object.defineProperty(exports, "getTabbable", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.getTabbable; }
+});
+Object.defineProperty(exports, "slotted", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.slotted; }
+});
+Object.defineProperty(exports, "useAutoFocus", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.useAutoFocus; }
+});
+Object.defineProperty(exports, "useFocusRestore", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.useFocusRestore; }
+});
+Object.defineProperty(exports, "useFocusTrap", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.useFocusTrap; }
+});
+Object.defineProperty(exports, "usePresence", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.usePresence; }
+});
+Object.defineProperty(exports, "useRovingFocus", {
+  enumerable: true,
+  get: function () { return chunkC32LKF23_cjs.useRovingFocus; }
+});
+Object.defineProperty(exports, "Portal", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.Portal; }
+});
+Object.defineProperty(exports, "computePosition", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.computePosition; }
+});
+Object.defineProperty(exports, "getLayerStack", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.getLayerStack; }
+});
+Object.defineProperty(exports, "useAnchoredPosition", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.useAnchoredPosition; }
+});
+Object.defineProperty(exports, "useDismiss", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.useDismiss; }
+});
+Object.defineProperty(exports, "useScrollLock", {
+  enumerable: true,
+  get: function () { return chunkXMXECSQO_cjs.useScrollLock; }
+});
+Object.defineProperty(exports, "useControllableState", {
+  enumerable: true,
+  get: function () { return chunkPO5DU3FU_cjs.useControllableState; }
+});
+Object.defineProperty(exports, "useElementSize", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useElementSize; }
+});
+Object.defineProperty(exports, "useFrameBudget", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useFrameBudget; }
+});
+Object.defineProperty(exports, "useInView", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useInView; }
+});
+Object.defineProperty(exports, "useMergedRef", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useMergedRef; }
+});
+Object.defineProperty(exports, "usePointer", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.usePointer; }
+});
+Object.defineProperty(exports, "useReducedMotion", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useReducedMotion; }
+});
+Object.defineProperty(exports, "useScrollProgress", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useScrollProgress; }
+});
+Object.defineProperty(exports, "useTicker", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useTicker; }
+});
+Object.defineProperty(exports, "useWindowScroll", {
+  enumerable: true,
+  get: function () { return chunk6VRF7X5C_cjs.useWindowScroll; }
+});
+Object.defineProperty(exports, "assignRef", {
+  enumerable: true,
+  get: function () { return chunkSFU5EPSN_cjs.assignRef; }
+});
+Object.defineProperty(exports, "composeEventHandlers", {
+  enumerable: true,
+  get: function () { return chunkSFU5EPSN_cjs.composeEventHandlers; }
+});
+Object.defineProperty(exports, "cx", {
+  enumerable: true,
+  get: function () { return chunkSFU5EPSN_cjs.cx; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return chunkSFU5EPSN_cjs.mergeProps; }
+});
+Object.defineProperty(exports, "mergeRefs", {
+  enumerable: true,
+  get: function () { return chunkSFU5EPSN_cjs.mergeRefs; }
+});
+//# sourceMappingURL=primitives.cjs.map
+//# sourceMappingURL=primitives.cjs.map

package/dist/primitives.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"primitives.cjs"}

package/dist/primitives.d.cts

@@ -0,0 +1,294 @@
+import * as react from 'react';
+import { Ref, SyntheticEvent, ReactNode, RefObject, CSSProperties } from 'react';
+import { b as PositionResult, a as PositionOptions } from './position-DVScKcaa.cjs';
+export { A as Align, P as Placement, R as Rect, S as Side, c as computePosition } from './position-DVScKcaa.cjs';
+export { I as InViewOptions, u as useElementSize, a as useFrameBudget, b as useInView, c as useMergedRef, d as usePointer, e as useReducedMotion, f as useScrollProgress, g as useTicker, h as useWindowScroll } from './use-observers-B9qtimrk.cjs';
+import * as _ansh_ui_core from '@ansh-ui/core';
+import { MotionValue, AnimationOptions, SpringOptions } from '@ansh-ui/core';
+
+/**
+ * Create a stable {@link MotionValue}.
+ *
+ * The value survives re-renders and — critically — **does not cause them**. That is the whole
+ * point: 60 renders per second of a React tree is not viable at any realistic component count,
+ * so animated values live outside React's reactivity and are written straight to the DOM.
+ *
+ * Reach for {@link useMotionValueState} only when you genuinely need the value in render output.
+ */
+declare function useMotionValue<T>(initial: T): MotionValue<T>;
+/**
+ * Subscribe to a MotionValue as React state.
+ *
+ * Uses `useSyncExternalStore`, which is the correct primitive here rather than
+ * `useState` + `useEffect`: it is tear-free under concurrent rendering, and it reads the value
+ * during render so there is never a frame showing a stale value.
+ *
+ * **This re-renders on every change.** For a value driven by an animation that is 60 renders per
+ * second. Use it for values that change at interaction rate (a toggle, a settled spring's final
+ * state), never for a value being animated continuously.
+ */
+declare function useMotionValueState<T>(value: MotionValue<T>): T;
+/**
+ * Write a MotionValue directly to a DOM property, bypassing React entirely.
+ *
+ * This is the mechanism that makes smooth animation possible in React. The returned ref is
+ * attached to an element; every change to the MotionValue writes straight to the node in the
+ * ticker's `write` phase.
+ *
+ * ```tsx
+ * const x = useMotionValue(0)
+ * const ref = useMotionStyle(x, (v) => `translateX(${v}px)`, 'transform')
+ * return <div ref={ref} />
+ * ```
+ */
+declare function useMotionStyle<T, El extends HTMLElement = HTMLDivElement>(value: MotionValue<T>, format: (value: T) => string, property?: keyof CSSStyleDeclaration & string): (node: El | null) => void;
+/**
+ * A spring that continuously chases a target.
+ *
+ * Returns a MotionValue and a setter. Unlike `animate(…, { type: 'spring' })` the target may
+ * change at any time and the spring carries its momentum through — which is what a cursor
+ * follower or a drag handle needs.
+ */
+declare function useSpringValue(initial: number, options?: SpringOptions): [MotionValue<number>, (target: number) => void];
+/**
+ * Imperative animation, scoped to the component's lifetime.
+ *
+ * Returns a `start` function and cancels any in-flight animation on unmount — the leak that
+ * hand-rolled `useEffect` animation code almost always has.
+ */
+declare function useAnimate(): <T>(from: T | MotionValue<T>, to: T | readonly T[], options?: AnimationOptions<T>) => _ansh_ui_core.AnimationControls;
+/**
+ * A boolean that flips to `true` once the component has mounted on the client.
+ *
+ * The idiomatic guard for anything that must not run during SSR. Returning `false` on the server
+ * and on the first client render means the two agree, so React never reports a hydration
+ * mismatch — which is what a naive `typeof window !== 'undefined'` check in render *does* cause.
+ */
+declare function useIsMounted(): boolean;
+
+/**
+ * State that works both controlled and uncontrolled.
+ *
+ * Every non-trivial component in this library needs this. A `<Select>` must work as
+ * `<Select />` (it owns its value), as `<Select defaultValue="a" />` (it owns its value, seeded),
+ * and as `<Select value={v} onChange={setV} />` (the parent owns it). Writing that logic per
+ * component is how libraries end up with a `Dialog` that supports controlled mode and a `Popover`
+ * that silently doesn't.
+ *
+ * The rule this encodes: **`value !== undefined` means controlled**, checked per render rather than
+ * latched on mount. Latching would be more "correct" in React's own terms, but it makes a component
+ * that starts uncontrolled and later receives a value fail silently, which is a real pattern when
+ * data arrives asynchronously.
+ */
+declare function useControllableState<T>(options: {
+    /** The controlled value. Pass `undefined` to stay uncontrolled. */
+    value?: T | undefined;
+    /** Initial value when uncontrolled. */
+    defaultValue: T;
+    /** Called on every change, in both modes. */
+    onChange?: ((value: T) => void) | undefined;
+}): [T, (next: T | ((previous: T) => T)) => void];
+
+/**
+ * Run a component's own handler after the consumer's, unless the consumer prevented default.
+ *
+ * The order matters and so does the check. A consumer's `onClick` on a `<Dialog.Close>` should be
+ * able to call `event.preventDefault()` to stop the dialog closing — that is the escape hatch that
+ * keeps composed components usable. Calling the internal handler first would make it impossible.
+ */
+declare function composeEventHandlers<E extends SyntheticEvent | Event>(theirs: ((event: E) => void) | undefined, ours: (event: E) => void, options?: {
+    checkForDefaultPrevented?: boolean;
+}): (event: E) => void;
+/** Assign a node to any ref shape — callback, object, or nothing. */
+declare function assignRef<T>(ref: Ref<T> | undefined | null, node: T | null): void;
+/**
+ * Merge refs without a hook.
+ *
+ * `useMergedRef` is the hook form and should be preferred inside components. This exists for the
+ * places a ref must be merged outside of a render — cloning an element in a `Slot`, for instance.
+ */
+declare function mergeRefs<T>(...refs: Array<Ref<T> | undefined | null>): (node: T | null) => void;
+/**
+ * Merge two sets of props, with the child's winning for everything except handlers, `className`
+ * and `style`, which compose.
+ *
+ * This is the merge strategy `asChild` needs. A naive spread would let a child's `onClick`
+ * silently delete a `Popover.Trigger`'s open handler, producing a trigger that renders perfectly
+ * and does nothing.
+ */
+declare function mergeProps(slotProps: Record<string, unknown>, childProps: Record<string, unknown>): Record<string, unknown>;
+/** Join class names, dropping falsy entries. The whole of `clsx` that this library actually uses. */
+declare function cx(...parts: Array<string | false | null | undefined>): string;
+
+interface SlotProps {
+    children?: ReactNode;
+    [key: string]: unknown;
+}
+/**
+ * Render into the child element instead of rendering a wrapper.
+ *
+ * This is what powers `asChild`. Without it, a `<Tooltip.Trigger>` wrapping a `<Button>` emits a
+ * `<span>` around the button — which breaks flex layouts, adds a node that inherits nothing, and
+ * puts the trigger's ARIA attributes on the wrong element for assistive technology.
+ *
+ * ```tsx
+ * <Tooltip.Trigger asChild>
+ *   <Button>Save</Button>
+ * </Tooltip.Trigger>
+ * ```
+ *
+ * The button *is* the trigger: it carries `aria-describedby` and the handlers, and no extra DOM
+ * node exists.
+ */
+declare const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<HTMLElement>>;
+/**
+ * Pick between a host element and its child based on `asChild`.
+ *
+ * Every component in this library that accepts `asChild` uses this, so the behaviour is identical
+ * across all of them rather than reimplemented with small differences.
+ */
+declare function slotted(asChild: boolean | undefined, fallback: React.ElementType): React.ElementType;
+/** Count element children, ignoring `null`/`false` from conditional rendering. */
+declare function countElements(children: ReactNode): number;
+
+interface PortalProps {
+    children: ReactNode;
+    /** Where to mount. Defaults to `document.body`. */
+    container?: Element | null;
+    /** Skip the portal and render in place. Useful inside an already-portalled surface. */
+    disabled?: boolean;
+}
+/**
+ * Render children elsewhere in the DOM.
+ *
+ * Overlays must escape their parent's stacking and clipping context. A popover inside a container
+ * with `overflow: hidden` gets clipped; one inside a `transform`ed ancestor has its `position:
+ * fixed` resolved against that ancestor instead of the viewport, so it lands in the wrong place.
+ * Neither is fixable with z-index, and both are the single most common overlay bug.
+ *
+ * SSR-safe: renders nothing on the server and on the first client render, then portals after mount.
+ * Portalling during SSR is impossible (no DOM), and portalling on the first client render would
+ * produce markup the server didn't emit — a hydration mismatch.
+ */
+declare function Portal({ children, container, disabled }: PortalProps): react.JSX.Element | null;
+
+/** Every tabbable descendant, in tab order. */
+declare function getTabbable(container: HTMLElement | null): HTMLElement[];
+/**
+ * Trap Tab within a container while `active`.
+ *
+ * Implemented on `keydown` at the container rather than with sentinel elements at either end. The
+ * sentinel approach adds two focusable nodes to the accessibility tree that screen readers can
+ * land on and announce as blank; intercepting the key does not.
+ */
+declare function useFocusTrap(ref: RefObject<HTMLElement | null>, active: boolean): void;
+/**
+ * Restore focus to whatever was focused before `active` became true.
+ *
+ * The element is captured on activation, not on mount, because a component can be mounted long
+ * before it opens.
+ */
+declare function useFocusRestore(active: boolean): void;
+/**
+ * Move focus into a surface when it opens.
+ *
+ * Prefers an explicitly marked element, then the first tabbable one, then the container itself.
+ * The container fallback matters for a dialog whose only content is text: focus must land inside
+ * it so a screen reader announces the dialog rather than continuing from the page behind.
+ */
+declare function useAutoFocus(ref: RefObject<HTMLElement | null>, active: boolean, initialFocus?: RefObject<HTMLElement | null>): void;
+/**
+ * Roving tabindex for a composite widget (toolbar, tab list, menu).
+ *
+ * The ARIA authoring practice: a composite has exactly **one** tab stop, and arrow keys move
+ * within it. Ten tabs that are each a tab stop means a keyboard user presses Tab ten times to get
+ * past the tab bar — technically operable, practically hostile.
+ */
+declare function useRovingFocus(options: {
+    /** Items in DOM order. */
+    itemsRef: RefObject<Array<HTMLElement | null>>;
+    /** Index that currently owns the tab stop. */
+    active: number;
+    onActiveChange: (index: number) => void;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    loop?: boolean;
+}): (event: React.KeyboardEvent) => void;
+
+/** Ids of the currently open dismissable layers, outermost first. Exposed for tests. */
+declare function getLayerStack(): readonly string[];
+interface DismissOptions {
+    /** Close on pointer press outside the surface. Default `true`. */
+    outsidePress?: boolean;
+    /** Close on Escape. Only the topmost layer responds. Default `true`. */
+    escapeKey?: boolean;
+    /**
+     * Extra elements that count as "inside" — normally the trigger.
+     *
+     * Without this the trigger's own click closes the surface via the outside handler and then
+     * immediately reopens it via its own onClick, so the surface appears not to close at all.
+     */
+    ignore?: Array<RefObject<HTMLElement | null>>;
+}
+declare function useDismiss(ref: RefObject<HTMLElement | null>, open: boolean, onDismiss: () => void, options?: DismissOptions): void;
+declare function useScrollLock(active: boolean): void;
+
+/**
+ * Keep an element mounted while it animates out.
+ *
+ * The problem: `{open && <Dialog />}` cannot animate on close, because React removes the node the
+ * instant `open` flips. The fix is to keep rendering it and unmount when the exit animation
+ * actually finishes.
+ *
+ * Finishing is detected from `animationend`/`transitionend` rather than a duration prop. A duration
+ * prop has to be kept in sync with the CSS by hand, and it drifts the moment someone retimes the
+ * animation in the stylesheet — leaving either a flash (unmount too early) or a surface that lingers
+ * invisibly and swallows clicks (too late). The timeout below is only a safety net for the case
+ * where no animation is declared at all and no event ever fires.
+ */
+declare function usePresence(open: boolean, ref: RefObject<HTMLElement | null>): {
+    mounted: boolean;
+    state: 'open' | 'closed';
+};
+interface PresenceProps {
+    open: boolean;
+    children: (props: {
+        ref: RefObject<HTMLElement | null>;
+        state: 'open' | 'closed';
+    }) => ReactNode;
+}
+/**
+ * Render-prop form of `usePresence`, for callers that would otherwise need to hoist a ref.
+ *
+ * ```tsx
+ * <Presence open={open}>
+ *   {({ ref, state }) => <div ref={ref} data-state={state} className="fade" />}
+ * </Presence>
+ * ```
+ */
+declare function Presence({ open, children }: PresenceProps): react.JSX.Element | null;
+
+interface AnchoredPositionOptions extends PositionOptions {
+    /** Set the floating element's width to the anchor's — what a combobox listbox wants. */
+    matchWidth?: boolean;
+    /** Recompute while open. Default `true`. */
+    enabled?: boolean;
+}
+interface AnchoredPosition {
+    style: CSSProperties;
+    arrowStyle: CSSProperties | undefined;
+    placement: PositionResult['placement'];
+    side: PositionResult['side'];
+    /** Force a recompute — call after content changes size in a way observers can't see. */
+    update: () => void;
+}
+/**
+ * Keep a floating element positioned against an anchor.
+ *
+ * Recomputes on scroll (capture phase, so nested scroll containers are caught), on viewport
+ * resize, and whenever either element changes size. It deliberately does **not** poll on every
+ * frame: that costs a forced layout per frame for a value that changes only on discrete events,
+ * and it is the reason some popover libraries make scrolling janky.
+ */
+declare function useAnchoredPosition(anchorRef: RefObject<HTMLElement | null>, floatingRef: RefObject<HTMLElement | null>, open: boolean, options?: AnchoredPositionOptions): AnchoredPosition;
+
+export { type AnchoredPosition, type AnchoredPositionOptions, type DismissOptions, Portal, type PortalProps, PositionOptions, PositionResult, Presence, type PresenceProps, Slot, type SlotProps, assignRef, composeEventHandlers, countElements, cx, getLayerStack, getTabbable, mergeProps, mergeRefs, slotted, useAnchoredPosition, useAnimate, useAutoFocus, useControllableState, useDismiss, useFocusRestore, useFocusTrap, useIsMounted, useMotionStyle, useMotionValue, useMotionValueState, usePresence, useRovingFocus, useScrollLock, useSpringValue };