@ansh-ui/vue 0.2.0

package/dist/overlay.js

@@ -0,0 +1,8 @@
+export { AlertDialog, ContextMenu, Dialog, DialogFooter, Drawer, DropdownMenu, HoverCard, Popover, PopoverContent, PopoverTrigger, Tooltip, TooltipProvider } from './chunk-2VSROZ2N.js';
+import './chunk-6XJOB6LE.js';
+import './chunk-XZ5ZFLZM.js';
+import './chunk-TMG3M6TK.js';
+import './chunk-OAQ7MDYX.js';
+import './chunk-NJDDNO4C.js';
+//# sourceMappingURL=overlay.js.map
+//# sourceMappingURL=overlay.js.map

package/dist/overlay.js.map

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

package/dist/position-Cn7qP1pn.d.cts

@@ -0,0 +1,50 @@
+/**
+ * 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 — verbatim from
+ * `@ansh-ui/react`'s `primitives/position.ts`.
+ *
+ * It is duplicated rather than imported across the workspace boundary on purpose: the function has
+ * zero framework dependency, so copying costs nothing in drift (a bug fix here is a five-line diff
+ * to mirror) and avoids making `@ansh-ui/vue` depend on `@ansh-ui/react` for one pure function.
+ */
+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 {
+    x: number;
+    y: number;
+    placement: Placement;
+    side: Side;
+    align: Align;
+    arrow: {
+        x: number;
+        y: number;
+    } | null;
+    hidden: boolean;
+}
+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-Cn7qP1pn.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 — verbatim from
+ * `@ansh-ui/react`'s `primitives/position.ts`.
+ *
+ * It is duplicated rather than imported across the workspace boundary on purpose: the function has
+ * zero framework dependency, so copying costs nothing in drift (a bug fix here is a five-line diff
+ * to mirror) and avoids making `@ansh-ui/vue` depend on `@ansh-ui/react` for one pure function.
+ */
+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 {
+    x: number;
+    y: number;
+    placement: Placement;
+    side: Side;
+    align: Align;
+    arrow: {
+        x: number;
+        y: number;
+    } | null;
+    hidden: boolean;
+}
+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,129 @@
+'use strict';
+
+var chunkDMPNT3MY_cjs = require('./chunk-DMPNT3MY.cjs');
+var chunkXLLSS464_cjs = require('./chunk-XLLSS464.cjs');
+var chunkEISHOEB6_cjs = require('./chunk-EISHOEB6.cjs');
+var chunk774WBLDR_cjs = require('./chunk-774WBLDR.cjs');
+var chunkPP6OYURM_cjs = require('./chunk-PP6OYURM.cjs');
+var chunk6732H4BQ_cjs = require('./chunk-6732H4BQ.cjs');
+
+
+
+Object.defineProperty(exports, "usePresence", {
+  enumerable: true,
+  get: function () { return chunkDMPNT3MY_cjs.usePresence; }
+});
+Object.defineProperty(exports, "computePosition", {
+  enumerable: true,
+  get: function () { return chunkXLLSS464_cjs.computePosition; }
+});
+Object.defineProperty(exports, "getLayerStack", {
+  enumerable: true,
+  get: function () { return chunkXLLSS464_cjs.getLayerStack; }
+});
+Object.defineProperty(exports, "useAnchoredPosition", {
+  enumerable: true,
+  get: function () { return chunkXLLSS464_cjs.useAnchoredPosition; }
+});
+Object.defineProperty(exports, "useDismiss", {
+  enumerable: true,
+  get: function () { return chunkXLLSS464_cjs.useDismiss; }
+});
+Object.defineProperty(exports, "useScrollLock", {
+  enumerable: true,
+  get: function () { return chunkXLLSS464_cjs.useScrollLock; }
+});
+Object.defineProperty(exports, "getTabbable", {
+  enumerable: true,
+  get: function () { return chunkEISHOEB6_cjs.getTabbable; }
+});
+Object.defineProperty(exports, "useAutoFocus", {
+  enumerable: true,
+  get: function () { return chunkEISHOEB6_cjs.useAutoFocus; }
+});
+Object.defineProperty(exports, "useFocusRestore", {
+  enumerable: true,
+  get: function () { return chunkEISHOEB6_cjs.useFocusRestore; }
+});
+Object.defineProperty(exports, "useFocusTrap", {
+  enumerable: true,
+  get: function () { return chunkEISHOEB6_cjs.useFocusTrap; }
+});
+Object.defineProperty(exports, "useRovingFocus", {
+  enumerable: true,
+  get: function () { return chunkEISHOEB6_cjs.useRovingFocus; }
+});
+Object.defineProperty(exports, "useControllableState", {
+  enumerable: true,
+  get: function () { return chunk774WBLDR_cjs.useControllableState; }
+});
+Object.defineProperty(exports, "useAnimate", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useAnimate; }
+});
+Object.defineProperty(exports, "useAnimatedFrom", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useAnimatedFrom; }
+});
+Object.defineProperty(exports, "useElementSize", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useElementSize; }
+});
+Object.defineProperty(exports, "useFrameBudget", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useFrameBudget; }
+});
+Object.defineProperty(exports, "useInView", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useInView; }
+});
+Object.defineProperty(exports, "useMotionRef", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useMotionRef; }
+});
+Object.defineProperty(exports, "useMotionStyle", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useMotionStyle; }
+});
+Object.defineProperty(exports, "useMotionValue", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useMotionValue; }
+});
+Object.defineProperty(exports, "usePointer", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.usePointer; }
+});
+Object.defineProperty(exports, "useReducedMotion", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useReducedMotion; }
+});
+Object.defineProperty(exports, "useScrollProgress", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useScrollProgress; }
+});
+Object.defineProperty(exports, "useSpringValue", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useSpringValue; }
+});
+Object.defineProperty(exports, "useTicker", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useTicker; }
+});
+Object.defineProperty(exports, "useWindowScroll", {
+  enumerable: true,
+  get: function () { return chunkPP6OYURM_cjs.useWindowScroll; }
+});
+Object.defineProperty(exports, "cx", {
+  enumerable: true,
+  get: function () { return chunk6732H4BQ_cjs.cx; }
+});
+Object.defineProperty(exports, "resolveSlotContent", {
+  enumerable: true,
+  get: function () { return chunk6732H4BQ_cjs.resolveSlotContent; }
+});
+Object.defineProperty(exports, "useId", {
+  enumerable: true,
+  get: function () { return chunk6732H4BQ_cjs.useId; }
+});
+//# 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,300 @@
+import { R as ReadonlyRef } from './utils-IKPG3zcC.cjs';
+export { S as SlotContent, c as cx, r as resolveSlotContent, u as useId } from './utils-IKPG3zcC.cjs';
+import { b as PositionResult, a as PositionOptions } from './position-Cn7qP1pn.cjs';
+export { A as Align, P as Placement, R as Rect, S as Side, c as computePosition } from './position-Cn7qP1pn.cjs';
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import * as _ansh_ui_core from '@ansh-ui/core';
+import { BudgetReport, PointerState, ScrollTrackOptions, ScrollProgress, FrameState, MotionValue, AnimationOptions, SpringOptions } from '@ansh-ui/core';
+
+/**
+ * State that works both controlled and uncontrolled — the Vue counterpart of
+ * `@ansh-ui/react`'s hook of the same name, and just as load-bearing here.
+ *
+ * A `<Select>` must work as `<Select />` (owns its value), `<Select :default-value="a" />` (owns
+ * its value, seeded), `v-model="v"` (the parent owns it via `modelValue`/`update:modelValue`), and
+ * `<Select :open="open" @update:open="…" />` for a named prop like a dialog's `open`. All four are
+ * the same shape: **the prop is controlled when the reactive getter returns something other than
+ * `undefined`**, evaluated on every read rather than latched once — so a component that starts
+ * uncontrolled and later receives a value (an async-loaded form) switches over instead of silently
+ * ignoring the prop from then on.
+ *
+ * ```ts
+ * const [value, setValue] = useControllableState(
+ *   () => props.modelValue,
+ *   defaultValue,
+ *   (next) => emit('update:modelValue', next),
+ * )
+ * ```
+ *
+ * `getProp` is a plain function rather than a `Ref` so it can read straight off `props` — Vue's
+ * `computed` tracks whatever reactive properties it touches, `props.foo` included, with no need to
+ * wrap the caller's access pattern.
+ */
+declare function useControllableState<T>(getProp: () => T | undefined, defaultValue: T, onChange?: (value: T) => void): [ComputedRef<T>, (next: T | ((previous: T) => T)) => 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 click handler, so the surface appears not to close at all.
+     */
+    ignore?: Array<Ref<HTMLElement | null | undefined>>;
+}
+declare function useDismiss(target: Ref<HTMLElement | null | undefined>, open: ReadonlyRef<boolean>, onDismiss: () => void, options?: DismissOptions): void;
+declare function useScrollLock(active: ReadonlyRef<boolean>): void;
+
+/** Every tabbable descendant, in tab order. */
+declare function getTabbable(container: HTMLElement | null | undefined): 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(target: Ref<HTMLElement | null | undefined>, active: ReadonlyRef<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: ReadonlyRef<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(target: Ref<HTMLElement | null | undefined>, active: ReadonlyRef<boolean>, initialFocus?: Ref<HTMLElement | null | undefined>): 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. Returns a keydown handler to bind on the composite's container.
+ */
+declare function useRovingFocus(options: {
+    /** Items in DOM order. */
+    items: Ref<Array<HTMLElement | null>>;
+    /** Index that currently owns the tab stop. */
+    active: () => number;
+    onActiveChange: (index: number) => void;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    loop?: boolean;
+}): (event: KeyboardEvent) => void;
+
+interface AnchoredPositionOptions extends PositionOptions {
+    /** Set the floating element's width to the anchor's — what a combobox listbox wants. */
+    matchWidth?: boolean;
+}
+interface AnchoredPosition {
+    style: Record<string, string>;
+    arrowStyle: Record<string, string> | undefined;
+    placement: PositionResult['placement'];
+    side: PositionResult['side'];
+}
+/**
+ * Keep a floating element positioned against an anchor — the Vue counterpart of `@ansh-ui/react`'s
+ * `useAnchoredPosition`.
+ *
+ * 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.
+ *
+ * Bound to `open` rather than a separate `enabled` flag — every consumer in this package positions
+ * only while its surface is open, so a second flag would be unused surface area.
+ */
+declare function useAnchoredPosition(anchorRef: Ref<HTMLElement | null | undefined>, floatingRef: Ref<HTMLElement | null | undefined>, open: ReadonlyRef<boolean>, options?: AnchoredPositionOptions): {
+    position: ComputedRef<AnchoredPosition>;
+    update: () => void;
+};
+
+/**
+ * Keep an element mounted while it animates out — the Vue counterpart of `@ansh-ui/react`'s
+ * `usePresence`.
+ *
+ * The problem: `v-if="open"` cannot animate on close, because Vue removes the node the instant
+ * `open` flips (Vue's own `<Transition>` solves this for simple cases, but our overlay components
+ * need the resolved `mounted`/`state` pair to drive `data-state` for CSS *and* to gate focus
+ * trapping and scroll locking off the same signal). The fix is the same as React's: keep rendering
+ * it and unmount when the exit animation actually finishes.
+ *
+ * Finishing is detected from `animationend`/`transitionend` rather than a duration prop, which would
+ * have to be kept in sync with the CSS by hand and drifts the moment someone retimes the animation
+ * in the stylesheet. The timeout is only a safety net for the case where no animation is declared at
+ * all and no event ever fires.
+ */
+declare function usePresence(open: ReadonlyRef<boolean>, target: Ref<HTMLElement | null | undefined>): {
+    mounted: Ref<boolean>;
+    state: Ref<'open' | 'closed'>;
+};
+
+/**
+ * Observer and lifecycle composables.
+ *
+ * A consistent pattern throughout: composables that take an element accept a **ref you bind in the
+ * template**, and watch it rather than reading it once. This matters because a template ref is
+ * `null` during `setup()` and only populated after mount — and stays null across a `v-if` toggle,
+ * then repopulates. Watching handles all of that; reading once in `onMounted` silently fails for
+ * conditionally-rendered elements, which is the most common bug in hand-written Vue composables.
+ */
+/** Subscribe to the shared ticker for the current scope's lifetime. */
+declare function useTicker(callback: (state: FrameState) => void, options?: {
+    phase?: 'read' | 'compute' | 'write' | 'post';
+    priority?: number;
+    enabled?: Ref<boolean> | boolean;
+}): () => void;
+interface UseInViewOptions {
+    threshold?: number;
+    rootMargin?: string;
+    once?: boolean;
+}
+/**
+ * Is the element in view?
+ *
+ * @param target A template ref. Watched, so it works with `v-if` and with elements that mount late.
+ */
+declare function useInView(target: Ref<HTMLElement | null | undefined>, options?: UseInViewOptions): Ref<boolean>;
+/** Track an element's size as a reactive value. */
+declare function useElementSize(target: Ref<HTMLElement | null | undefined>): Ref<{
+    width: number;
+    height: number;
+}>;
+/**
+ * Track an element's scroll progress.
+ *
+ * Returns a **shallowRef holding a mutable state object**, not a reactive number. Scroll progress
+ * changes every frame; making it reactive would flush an effect per frame and undo the phase
+ * separation the kernel provides. Read `progress.value.progress` inside a `useTicker` callback, or
+ * pass `onChange` and write to the DOM directly.
+ */
+declare function useScrollProgress(target: Ref<HTMLElement | null | undefined>, options?: ScrollTrackOptions & {
+    onChange?: (progress: ScrollProgress) => void;
+}): ShallowRef<ScrollProgress>;
+/** Track the window's (or a container's) overall scroll. */
+declare function useWindowScroll(onChange?: (info: {
+    progress: number;
+    scroll: number;
+    velocity: number;
+    max: number;
+}) => void, options?: {
+    axis?: 'y' | 'x';
+    container?: HTMLElement | null;
+}): ShallowRef<{
+    progress: number;
+    scroll: number;
+    velocity: number;
+    max: number;
+}>;
+/**
+ * Track pointer position over an element.
+ *
+ * The returned object is mutated in place by the tracker each frame and is deliberately **not**
+ * reactive — reading it in a template would flush on every pointer move.
+ */
+declare function usePointer(target: Ref<HTMLElement | null | undefined>, options?: {
+    smoothing?: number;
+    trackOutside?: boolean;
+}): ShallowRef<Readonly<PointerState> | null>;
+/**
+ * Does the user prefer reduced motion?
+ *
+ * Returns `false` during SSR, which is the hydration-safe default: the server cannot know, and
+ * differing between server and first client render would be a mismatch.
+ */
+declare function useReducedMotion(): Ref<boolean>;
+/**
+ * Live frame-budget telemetry for a development overlay.
+ *
+ * Sampled at 4 Hz rather than per frame: a number changing 60 times a second is unreadable, and
+ * rendering it that often distorts the measurement it is reporting.
+ */
+declare function useFrameBudget(): Ref<BudgetReport | null>;
+
+/**
+ * Vue motion composables.
+ *
+ * The design principle mirrors the React package: animated values live **outside** Vue's
+ * reactivity. A `ref` that updates 60 times a second triggers 60 reactive effect flushes and, if
+ * anything in a template reads it, 60 patch cycles — which is precisely the cost that makes
+ * "animation in a framework" slow.
+ *
+ * So {@link useMotionValue} returns the engine's `MotionValue` directly and writes to the DOM. Where
+ * a value genuinely belongs in a template, {@link useMotionRef} bridges it into a `shallowRef` and
+ * says plainly what that costs.
+ *
+ * Cleanup uses `onScopeDispose` rather than `onBeforeUnmount`, so these compose correctly inside
+ * `effectScope()` — including in Pinia stores and outside a component instance entirely.
+ */
+/**
+ * Create a {@link MotionValue} bound to the current effect scope.
+ *
+ * Does not trigger re-renders. Pass it to `useMotionStyle` or read it in a `useTicker` callback.
+ */
+declare function useMotionValue<T>(initial: T): MotionValue<T>;
+/**
+ * Bridge a MotionValue into a Vue ref.
+ *
+ * **This makes the value reactive, which means a component update on every change.** For a value
+ * being animated continuously that is 60 updates per second. Use it for values that change at
+ * interaction rate — a settled spring, a toggle — not for anything mid-animation.
+ *
+ * A `shallowRef` rather than `ref` because the value is replaced wholesale, never mutated, so deep
+ * reactivity would be pure overhead.
+ */
+declare function useMotionRef<T>(value: MotionValue<T>): Readonly<ShallowRef<T>>;
+/**
+ * Write a MotionValue straight to an element's style property, bypassing Vue's renderer.
+ *
+ * This is the mechanism for smooth animation in Vue. Bind the returned ref to an element:
+ *
+ * ```vue
+ * <script setup>
+ * const x = useMotionValue(0)
+ * const el = useMotionStyle(x, (v) => `translateX(${v}px)`)
+ * </script>
+ * <template><div :ref="el" /></template>
+ * ```
+ */
+declare function useMotionStyle<T, El extends HTMLElement = HTMLElement>(value: MotionValue<T>, format: (value: T) => string, property?: string): ShallowRef<El | null>;
+/**
+ * A spring that continuously chases a target.
+ *
+ * The target is a plain setter rather than a reactive ref, deliberately: reading a ref inside the
+ * spring's per-frame callback would register a reactive dependency and flush an effect every
+ * frame, which defeats the purpose of keeping the animation outside the reactivity system.
+ */
+declare function useSpringValue(initial: number, options?: SpringOptions): {
+    value: MotionValue<number>;
+    set: (target: number) => void;
+};
+/**
+ * Scope-bound imperative animation.
+ *
+ * Any in-flight animation is stopped when the scope disposes, and when `start` is called again —
+ * which is the behaviour you want, since two animations driving one value fight each other.
+ */
+declare function useAnimate(): <T>(from: T | MotionValue<T>, to: T | readonly T[], options?: AnimationOptions<T>) => _ansh_ui_core.AnimationControls;
+/**
+ * Drive a MotionValue from a reactive source.
+ *
+ * The bridge in the other direction: when a `ref` in your component changes, animate toward the new
+ * value. This is the idiomatic way to connect Vue state to Ansh motion.
+ *
+ * ```ts
+ * const open = ref(false)
+ * const height = useMotionValue(0)
+ * useAnimatedFrom(open, height, (isOpen) => (isOpen ? 320 : 0), { spring: 'snappy' })
+ * ```
+ */
+declare function useAnimatedFrom<Source, T>(source: Ref<Source>, target: MotionValue<T>, map: (value: Source) => T, options?: AnimationOptions<T>): void;
+
+export { type AnchoredPosition, type AnchoredPositionOptions, type DismissOptions, PositionOptions, PositionResult, ReadonlyRef, type UseInViewOptions, getLayerStack, getTabbable, useAnchoredPosition, useAnimate, useAnimatedFrom, useAutoFocus, useControllableState, useDismiss, useElementSize, useFocusRestore, useFocusTrap, useFrameBudget, useInView, useMotionRef, useMotionStyle, useMotionValue, usePointer, usePresence, useReducedMotion, useRovingFocus, useScrollLock, useScrollProgress, useSpringValue, useTicker, useWindowScroll };