@xaui/native 0.9.1-alpha.1 → 0.9.1-alpha.3

package/dist/index.cjs

@@ -1,6 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkKFCORXWWcjs = require('./chunk-KFCORXWW.cjs');
 
 
 
@@ -16,10 +15,9 @@ var _chunkKFCORXWWcjs = require('./chunk-KFCORXWW.cjs');
 
 
 
-var _chunkNHPQQQ7Pcjs = require('./chunk-NHPQQQ7P.cjs');
 
+var _chunkV63JO65Fcjs = require('./chunk-V63JO65F.cjs');
 
-var _chunkM7P46XKIcjs = require('./chunk-M7P46XKI.cjs');
 
 
 
@@ -30,11 +28,45 @@ var _chunkM7P46XKIcjs = require('./chunk-M7P46XKI.cjs');
 
 
 
+var _chunkAW63PTQ4cjs = require('./chunk-AW63PTQ4.cjs');
 
 
 
 
 
 
+var _chunk3QBT3Q65cjs = require('./chunk-3QBT3Q65.cjs');
 
-exports.ThemeContext = _chunkNHPQQQ7Pcjs.ThemeContext; exports.XAUIProvider = _chunkNHPQQQ7Pcjs.XAUIProvider; exports.buildRadius = _chunkNHPQQQ7Pcjs.buildRadius; exports.buildShadows = _chunkNHPQQQ7Pcjs.buildShadows; exports.createRecipe = _chunkKFCORXWWcjs.createRecipe; exports.createTheme = _chunkNHPQQQ7Pcjs.createTheme; exports.defaultTheme = _chunkNHPQQQ7Pcjs.defaultTheme; exports.deriveColors = _chunkNHPQQQ7Pcjs.deriveColors; exports.deriveTint = _chunkM7P46XKIcjs.deriveTint; exports.palette = _chunkNHPQQQ7Pcjs.palette; exports.primitives = _chunkNHPQQQ7Pcjs.primitives; exports.sourceKeys = _chunkNHPQQQ7Pcjs.sourceKeys; exports.tokens = _chunkNHPQQQ7Pcjs.tokens; exports.useColorMode = _chunkNHPQQQ7Pcjs.useColorMode; exports.useThemeColor = _chunkNHPQQQ7Pcjs.useThemeColor; exports.useXAUITheme = _chunkNHPQQQ7Pcjs.useXAUITheme;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HIGHLIGHT_OPACITY = _chunkV63JO65Fcjs.HIGHLIGHT_OPACITY; exports.PRESS_DURATION = _chunkV63JO65Fcjs.PRESS_DURATION; exports.PRESS_SCALE = _chunkV63JO65Fcjs.PRESS_SCALE; exports.PressableFeedback = _chunkV63JO65Fcjs.PressableFeedback; exports.RELEASE_DURATION = _chunkV63JO65Fcjs.RELEASE_DURATION; exports.RIPPLE_COVERAGE = _chunkV63JO65Fcjs.RIPPLE_COVERAGE; exports.RIPPLE_DURATION = _chunkV63JO65Fcjs.RIPPLE_DURATION; exports.RIPPLE_OPACITY = _chunkV63JO65Fcjs.RIPPLE_OPACITY; exports.Slot = _chunkV63JO65Fcjs.Slot; exports.ThemeContext = _chunk3QBT3Q65cjs.ThemeContext; exports.XAUIProvider = _chunkAW63PTQ4cjs.XAUIProvider; exports.buildRadius = _chunkAW63PTQ4cjs.buildRadius; exports.buildShadows = _chunkAW63PTQ4cjs.buildShadows; exports.childrenToString = _chunkV63JO65Fcjs.childrenToString; exports.createRecipe = _chunkV63JO65Fcjs.createRecipe; exports.createSlotContext = _chunkV63JO65Fcjs.createSlotContext; exports.createTheme = _chunkAW63PTQ4cjs.createTheme; exports.defaultTheme = _chunkAW63PTQ4cjs.defaultTheme; exports.deriveColors = _chunkAW63PTQ4cjs.deriveColors; exports.deriveTint = _chunk3QBT3Q65cjs.deriveTint; exports.mergeProps = _chunkV63JO65Fcjs.mergeProps; exports.mergeRefs = _chunkV63JO65Fcjs.mergeRefs; exports.palette = _chunkAW63PTQ4cjs.palette; exports.primitives = _chunkAW63PTQ4cjs.primitives; exports.resolveAnimation = _chunkV63JO65Fcjs.resolveAnimation; exports.resolveSlotAnimation = _chunkV63JO65Fcjs.resolveSlotAnimation; exports.sourceKeys = _chunkAW63PTQ4cjs.sourceKeys; exports.tokens = _chunkAW63PTQ4cjs.tokens; exports.useColorMode = _chunk3QBT3Q65cjs.useColorMode; exports.useFeedback = _chunkV63JO65Fcjs.useFeedback; exports.useThemeColor = _chunk3QBT3Q65cjs.useThemeColor; exports.useXAUITheme = _chunk3QBT3Q65cjs.useXAUITheme;

package/dist/index.d.cts

@@ -1,5 +1,6 @@
-export { Axes, CompoundVariant, Recipe, RecipeConfig, ResolveArgs, ResolvedSelection, ResolvedStyles, Selection, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, createRecipe } from './system/index.cjs';
+export { AnimationConfig, AnimationProp, AsChildProps, Axes, CompoundVariant, FeedbackContext, FeedbackVariant, HIGHLIGHT_OPACITY, MergeableProps, PRESS_DURATION, PRESS_SCALE, PossibleRef, PressableFeedback, PressableFeedbackHighlightProps, PressableFeedbackProps, PressableFeedbackRippleProps, RELEASE_DURATION, RIPPLE_COVERAGE, RIPPLE_DURATION, RIPPLE_OPACITY, Recipe, RecipeConfig, ResolveArgs, ResolvedAnimation, ResolvedSelection, ResolvedStyles, Selection, Slot, SlotAnimation, SlotProps, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, childrenToString, createRecipe, createSlotContext, mergeProps, mergeRefs, resolveAnimation, resolveSlotAnimation, useFeedback } from './system/index.cjs';
 export { ColorModePreference, PaletteFamily, PaletteShade, ThemeContext, XAUIProvider, XAUIProviderProps, XAUITint, buildRadius, buildShadows, createTheme, defaultTheme, deriveColors, deriveTint, palette, primitives, sourceKeys, tokens, useColorMode, useThemeColor, useXAUITheme } from './theme/index.cjs';
-export { C as ColorMode, F as FontSizeKey, a as FontWeightKey, R as RadiusKey, S as Size, X as XAUIColors, b as XAUIDerivedColors, c as XAUIPrimitiveColors, d as XAUIRadius, e as XAUIShadow, f as XAUISourceColors, g as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-B3ODSLbB.cjs';
-import 'react-native';
+export { C as ColorMode, F as FontSizeKey, a as FontWeightKey, R as RadiusKey, S as Size, X as XAUIColors, b as XAUIDerivedColors, c as XAUIPrimitiveColors, d as XAUIRadius, e as XAUIShadow, f as XAUISourceColors, g as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-C9bFJKFm.cjs';
 import 'react';
+import 'react-native';
+import 'react-native-reanimated';

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { Axes, CompoundVariant, Recipe, RecipeConfig, ResolveArgs, ResolvedSelection, ResolvedStyles, Selection, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, createRecipe } from './system/index.js';
+export { AnimationConfig, AnimationProp, AsChildProps, Axes, CompoundVariant, FeedbackContext, FeedbackVariant, HIGHLIGHT_OPACITY, MergeableProps, PRESS_DURATION, PRESS_SCALE, PossibleRef, PressableFeedback, PressableFeedbackHighlightProps, PressableFeedbackProps, PressableFeedbackRippleProps, RELEASE_DURATION, RIPPLE_COVERAGE, RIPPLE_DURATION, RIPPLE_OPACITY, Recipe, RecipeConfig, ResolveArgs, ResolvedAnimation, ResolvedSelection, ResolvedStyles, Selection, Slot, SlotAnimation, SlotProps, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, childrenToString, createRecipe, createSlotContext, mergeProps, mergeRefs, resolveAnimation, resolveSlotAnimation, useFeedback } from './system/index.js';
 export { ColorModePreference, PaletteFamily, PaletteShade, ThemeContext, XAUIProvider, XAUIProviderProps, XAUITint, buildRadius, buildShadows, createTheme, defaultTheme, deriveColors, deriveTint, palette, primitives, sourceKeys, tokens, useColorMode, useThemeColor, useXAUITheme } from './theme/index.js';
-export { C as ColorMode, F as FontSizeKey, a as FontWeightKey, R as RadiusKey, S as Size, X as XAUIColors, b as XAUIDerivedColors, c as XAUIPrimitiveColors, d as XAUIRadius, e as XAUIShadow, f as XAUISourceColors, g as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-B3ODSLbB.js';
-import 'react-native';
+export { C as ColorMode, F as FontSizeKey, a as FontWeightKey, R as RadiusKey, S as Size, X as XAUIColors, b as XAUIDerivedColors, c as XAUIPrimitiveColors, d as XAUIRadius, e as XAUIShadow, f as XAUISourceColors, g as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-C9bFJKFm.js';
 import 'react';
+import 'react-native';
+import 'react-native-reanimated';

package/dist/index.js

@@ -1,8 +1,23 @@
 import {
-  createRecipe
-} from "./chunk-N357EQCZ.js";
+  HIGHLIGHT_OPACITY,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  PressableFeedback,
+  RELEASE_DURATION,
+  RIPPLE_COVERAGE,
+  RIPPLE_DURATION,
+  RIPPLE_OPACITY,
+  Slot,
+  childrenToString,
+  createRecipe,
+  createSlotContext,
+  mergeProps,
+  mergeRefs,
+  resolveAnimation,
+  resolveSlotAnimation,
+  useFeedback
+} from "./chunk-QAMNNTGM.js";
 import {
-  ThemeContext,
   XAUIProvider,
   buildRadius,
   buildShadows,
@@ -12,29 +27,46 @@ import {
   palette,
   primitives,
   sourceKeys,
-  tokens,
+  tokens
+} from "./chunk-2KXQATVL.js";
+import {
+  ThemeContext,
+  deriveTint,
   useColorMode,
   useThemeColor,
   useXAUITheme
-} from "./chunk-PBVPOX7D.js";
-import {
-  deriveTint
-} from "./chunk-RBNCR5KB.js";
+} from "./chunk-X2K2FX3W.js";
 export {
+  HIGHLIGHT_OPACITY,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  PressableFeedback,
+  RELEASE_DURATION,
+  RIPPLE_COVERAGE,
+  RIPPLE_DURATION,
+  RIPPLE_OPACITY,
+  Slot,
   ThemeContext,
   XAUIProvider,
   buildRadius,
   buildShadows,
+  childrenToString,
   createRecipe,
+  createSlotContext,
   createTheme,
   defaultTheme,
   deriveColors,
   deriveTint,
+  mergeProps,
+  mergeRefs,
   palette,
   primitives,
+  resolveAnimation,
+  resolveSlotAnimation,
   sourceKeys,
   tokens,
   useColorMode,
+  useFeedback,
   useThemeColor,
   useXAUITheme
 };

package/dist/system/index.cjs

@@ -1,7 +1,39 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkKFCORXWWcjs = require('../chunk-KFCORXWW.cjs');
-require('../chunk-M7P46XKI.cjs');
 
 
-exports.createRecipe = _chunkKFCORXWWcjs.createRecipe;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkV63JO65Fcjs = require('../chunk-V63JO65F.cjs');
+require('../chunk-3QBT3Q65.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HIGHLIGHT_OPACITY = _chunkV63JO65Fcjs.HIGHLIGHT_OPACITY; exports.PRESS_DURATION = _chunkV63JO65Fcjs.PRESS_DURATION; exports.PRESS_SCALE = _chunkV63JO65Fcjs.PRESS_SCALE; exports.PressableFeedback = _chunkV63JO65Fcjs.PressableFeedback; exports.RELEASE_DURATION = _chunkV63JO65Fcjs.RELEASE_DURATION; exports.RIPPLE_COVERAGE = _chunkV63JO65Fcjs.RIPPLE_COVERAGE; exports.RIPPLE_DURATION = _chunkV63JO65Fcjs.RIPPLE_DURATION; exports.RIPPLE_OPACITY = _chunkV63JO65Fcjs.RIPPLE_OPACITY; exports.Slot = _chunkV63JO65Fcjs.Slot; exports.childrenToString = _chunkV63JO65Fcjs.childrenToString; exports.createRecipe = _chunkV63JO65Fcjs.createRecipe; exports.createSlotContext = _chunkV63JO65Fcjs.createSlotContext; exports.mergeProps = _chunkV63JO65Fcjs.mergeProps; exports.mergeRefs = _chunkV63JO65Fcjs.mergeRefs; exports.resolveAnimation = _chunkV63JO65Fcjs.resolveAnimation; exports.resolveSlotAnimation = _chunkV63JO65Fcjs.resolveSlotAnimation; exports.useFeedback = _chunkV63JO65Fcjs.useFeedback;

package/dist/system/index.d.cts

@@ -1,5 +1,186 @@
-import { g as XAUITheme, X as XAUIColors } from '../theme.type-B3ODSLbB.cjs';
-import { ViewStyle, TextStyle } from 'react-native';
+import * as react from 'react';
+import { ReactNode, Provider, Ref, RefCallback } from 'react';
+import * as react_native from 'react-native';
+import { PressableProps, StyleProp, ViewStyle, TextStyle } from 'react-native';
+import { SharedValue } from 'react-native-reanimated';
+import { g as XAUITheme, X as XAUIColors } from '../theme.type-C9bFJKFm.cjs';
+
+/**
+ * What the root does under the finger. `scale-highlight` and `scale-ripple` mount their
+ * overlay themselves; `scale` mounts none, which is what a root picks when it renders its
+ * own `<PressableFeedback.Highlight>` to style it (R1: no prop reaches into another
+ * component's insides).
+ */
+type FeedbackVariant = 'scale-highlight' | 'scale-ripple' | 'scale' | 'none';
+type AnimationConfig = {
+    scale?: boolean;
+    highlight?: boolean;
+    ripple?: boolean;
+};
+/**
+ * `false` and `'disabled'` turn this component's animations off. `'disable-all'` turns
+ * them off for its descendants too — a long list kills every row's worklets with one
+ * prop instead of threading it down. An object switches them off one at a time.
+ */
+type AnimationProp = boolean | 'disabled' | 'disable-all' | AnimationConfig;
+/** `animation` once normalised — what the components actually read. */
+type ResolvedAnimation = {
+    scale: boolean;
+    highlight: boolean;
+    ripple: boolean;
+    /** True when every sub-animation is off: the branch that mounts no worklet at all. */
+    none: boolean;
+    /** Propagated to descendants through context. */
+    disableAll: boolean;
+};
+type PressableFeedbackProps = Omit<PressableProps, 'style' | 'children' | 'disabled'> & {
+    /** Controlled: the root owns the state, because its recipe resolves on it (R5). */
+    isPressed?: boolean;
+    /** R8: `disabled` is not part of the public vocabulary, `isX` is. */
+    isDisabled?: boolean;
+    /**
+     * Merge into the single child instead of rendering a pressable (R12) — **keeping the
+     * feedback**. Swapping this component out for a bare `Slot` would silently drop the
+     * touch feedback of every `asChild` control.
+     */
+    asChild?: boolean;
+    feedbackVariant?: FeedbackVariant;
+    animation?: AnimationProp;
+    style?: StyleProp<ViewStyle>;
+    /**
+     * `Pressable`'s function form is dropped on purpose. It exists to hand the press state
+     * to children; here the root above already owns that state and this publishes it
+     * through context, so the function form would be a second, quieter source of truth.
+     */
+    children?: ReactNode;
+};
+/**
+ * A slot's own animation, overriding the blanket one on the root. `false` switches that
+ * slot off; the object tunes it. Deliberately two knobs rather than a full timing
+ * surface — anything past this is a different animation, and that is a component's job,
+ * not a prop's.
+ */
+type SlotAnimation = boolean | {
+    /** Milliseconds. Falls back to the shared press timing. */
+    duration?: number;
+    /** How far the overlay goes at full press, 0 to 1. */
+    opacity?: number;
+};
+type FeedbackContext = {
+    isPressed: boolean;
+    animation: ResolvedAnimation;
+    /** Absent on the static branch, where nothing animates and no worklet is mounted. */
+    progress?: SharedValue<number>;
+    /**
+     * Bumped on every press-in. The ripple starts from this rather than from a `useEffect`
+     * on `isPressed`: a one-shot driven by a boolean depends on React re-rendering between
+     * the two touch events, and starting it from the event that carries the coordinates is
+     * both simpler and impossible to miss.
+     */
+    pressCount?: SharedValue<number>;
+    /** Where the finger landed, and how big the root is — the ripple needs both. */
+    origin?: SharedValue<{
+        x: number;
+        y: number;
+    }>;
+    size?: SharedValue<{
+        width: number;
+        height: number;
+    }>;
+};
+
+type PressableFeedbackHighlightProps = {
+    style?: StyleProp<ViewStyle>;
+    /** Overrides the blanket `animation` on the root, for this overlay only. */
+    animation?: SlotAnimation;
+};
+/**
+ * The press wash: one flat overlay fading in under the finger.
+ *
+ * It is a **neutral** wash, not the variant's pressed colour. A component picks one or
+ * the other — this overlay, or a `pressed` state in its recipe swapping `bg` for
+ * `bgPressed` — never both, or a pressed button darkens twice.
+ */
+declare function PressableFeedbackHighlight({ style, animation: override, }: PressableFeedbackHighlightProps): react.JSX.Element;
+declare namespace PressableFeedbackHighlight {
+    var displayName: string;
+}
+
+type PressableFeedbackRippleProps = {
+    style?: StyleProp<ViewStyle>;
+    /** Overrides the blanket `animation` on the root, for this overlay only. */
+    animation?: SlotAnimation;
+};
+/**
+ * A circle washing outwards from where the finger landed.
+ *
+ * It is a **one-shot, independent of how long the press lasts**: the wave runs its course
+ * and ends, the way a ripple in water does. Tying it to the press would leave a disc
+ * parked on the control for as long as a finger rests there.
+ *
+ * It needs the root to clip — `PressableFeedback` sets `overflow: 'hidden'` when it
+ * mounts one — and it renders nothing on the static branch: a ripple that cannot expand
+ * is a coloured disc sitting on the control, which reads as a defect rather than as
+ * reduced motion.
+ */
+declare function PressableFeedbackRipple({ style, animation: override, }: PressableFeedbackRippleProps): react.JSX.Element | null;
+declare namespace PressableFeedbackRipple {
+    var displayName: string;
+}
+
+declare const useFeedback: () => FeedbackContext;
+
+/**
+ * The values the v0 tree shipped with (`Animated.spring` to `0.975`, `bounciness: 0`,
+ * over roughly 100ms). Kept identical on purpose: the touch feedback is the part of a
+ * library users feel rather than read, and changing its timing in a rewrite would be a
+ * regression nobody asked for. `bounciness: 0` is why a duration replaces the spring —
+ * a spring with no bounce is a curve.
+ */
+declare const PRESS_SCALE = 0.975;
+declare const PRESS_DURATION = 100;
+declare const RELEASE_DURATION = 150;
+/** How far the wash and the ripple go at full press. */
+declare const HIGHLIGHT_OPACITY = 0.08;
+declare const RIPPLE_OPACITY = 0.12;
+declare const RIPPLE_DURATION = 350;
+/**
+ * The circle's radius as a multiple of the control's diagonal. Above 1 it covers from
+ * any point on the control, so where the finger landed never enters the calculation.
+ */
+declare const RIPPLE_COVERAGE = 1.25;
+/**
+ * One shape out of four accepted ones, so the components read a record instead of
+ * re-deciding what `'disable-all'` meant.
+ *
+ * `inheritedDisableAll` comes from an ancestor that asked for it, and it wins: a list
+ * that switched its rows' animations off cannot be overridden by a row.
+ */
+declare function resolveAnimation(animation: AnimationProp | undefined, inheritedDisableAll?: boolean): ResolvedAnimation;
+type ResolvedSlotAnimation = {
+    enabled: boolean;
+    duration: number;
+    opacity: number;
+};
+/**
+ * A slot's own `animation` over the root's blanket one, with the root winning when it
+ * switched everything off — `animation="disable-all"` on an ancestor cannot be undone by
+ * an overlay that asks nicely.
+ */
+declare function resolveSlotAnimation(override: SlotAnimation | undefined, enabledByRoot: boolean, defaultOpacity: number, defaultDuration?: number): ResolvedSlotAnimation;
+
+declare const PressableFeedback: react.ForwardRefExoticComponent<Omit<react_native.PressableProps, "disabled" | "style" | "children"> & {
+    isPressed?: boolean;
+    isDisabled?: boolean;
+    asChild?: boolean;
+    feedbackVariant?: FeedbackVariant;
+    animation?: AnimationProp;
+    style?: react_native.StyleProp<react_native.ViewStyle>;
+    children?: react.ReactNode;
+} & react.RefAttributes<react_native.View>> & {
+    Highlight: typeof PressableFeedbackHighlight;
+    Ripple: typeof PressableFeedbackRipple;
+};
 
 /**
  * A slot is a view or a text node, and a recipe writes one object per slot, so the two
@@ -80,4 +261,93 @@ type Recipe<Slot extends string, Variant extends string, A extends Axes<Slot>> =
  */
 declare function createRecipe<Slot extends string, Variant extends string, const A extends Axes<Slot>>(config: RecipeConfig<Slot, Variant, A>): Recipe<Slot, Variant, A>;
 
-export { type Axes, type CompoundVariant, type Recipe, type RecipeConfig, type ResolveArgs, type ResolvedSelection, type ResolvedStyles, type Selection, type SlotStyle, type SlotStyles, type StateName, type States, type StyleFn, type TintArgs, type VariantColors, type VariantRole, type VariantTokens, createRecipe };
+/**
+ * R3: the string a root should wrap in its default text slot, or `null` when it should
+ * render its children as they are.
+ *
+ * The whole tree is stringified recursively rather than the first child inspected. That
+ * is what makes `<Button>{count} items</Button>` work — children there are the array
+ * `[3, ' items']`, and an `isValidElement` check on the first entry would call it an
+ * element-free tree only by accident, while a check for "is the first child a string"
+ * would miss it outright.
+ *
+ * `null` for an empty result as much as for a tree containing an element: in both cases
+ * there is nothing to wrap, and a root's fallback — render the children — is right for
+ * both. It also keeps `<Button>{false}</Button>` from mounting an empty text node.
+ */
+declare function childrenToString(children: ReactNode): string | null;
+
+/**
+ * A context a slot cannot read by accident. Every compound gets one, and it carries
+ * **resolved** values — style references the root already computed, not tokens for the
+ * slot to resolve again (R5).
+ *
+ * ```ts
+ * const [ButtonProvider, useButton] = createSlotContext<ButtonContext>('Button')
+ * ```
+ *
+ * The tuple is what lets each compound name its own hook, which R10 requires it to
+ * export. `name` gives both halves of the error, so there is one place to spell it.
+ */
+declare function createSlotContext<T>(name: string): readonly [Provider<T | null>, () => T];
+
+/** Anything React accepts as a ref, plus the absence of one. */
+type PossibleRef<T> = Ref<T> | undefined;
+/**
+ * The props `mergeProps` knows how to combine. Deliberately loose: it merges whatever a
+ * root hands to whatever child it was given, and neither side is knowable from here.
+ */
+type MergeableProps = Record<string, unknown>;
+type AsChildProps = {
+    /**
+     * Merge this component's props into its single child instead of rendering an element
+     * of its own — a navigation `Link` as a `Button`, a bespoke trigger as a `Select`.
+     */
+    asChild?: boolean;
+};
+
+/**
+ * Merges a root's own props into the child it renders through `asChild` (R12). Four
+ * rules, and the child wins wherever they do not apply — it is the more specific intent:
+ *
+ * - **Event handlers compose.** Both run, ours first: the component's own behaviour (the
+ *   press state that drives its styles) happens before the child's side effect (the
+ *   navigation). Replacing one with the other is the bug this exists to prevent.
+ * - **Styles stack**, ours under the child's, so the child can override.
+ * - **`ref`s merge** through `mergeRefs`. React 19 passes `ref` as an ordinary prop, so
+ *   it arrives here rather than beside the props, and dropping it would sever the root's
+ *   handle on the node.
+ * - **Everything else: the child's value wins**, and ours fills in what it left unset.
+ */
+declare function mergeProps(ours: MergeableProps, theirs: MergeableProps): MergeableProps;
+
+/**
+ * One callback that feeds several refs — what lets a root keep its own handle on a node
+ * while still honouring the ref its caller passed (R9), and what `asChild` needs to
+ * forward a ref into the child it merges into (R12).
+ *
+ * It returns nothing on purpose. React 19 reads a ref callback's return value as a
+ * cleanup function while React 18 ignores it, and this package supports both; letting
+ * a merged cleanup through would behave differently on each. React calls every ref with
+ * `null` on unmount anyway, which this forwards.
+ */
+declare function mergeRefs<T>(...refs: Array<PossibleRef<T>>): RefCallback<T>;
+
+type SlotProps = MergeableProps & {
+    children?: ReactNode;
+};
+/**
+ * The render branch behind `asChild` (R12). A root picks it instead of its own element:
+ *
+ * ```tsx
+ * const Root = asChild ? Slot : Pressable
+ * return <Root ref={ref} {...rootProps}>{children}</Root>
+ * ```
+ *
+ * One line per root, which is the point — forty-seven roots each hand-rolling a
+ * `cloneElement` and a ref merge would drift, and R12 has to hold uniformly from the
+ * first component or the ref signature of the whole core changes later.
+ */
+declare const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<unknown>>;
+
+export { type AnimationConfig, type AnimationProp, type AsChildProps, type Axes, type CompoundVariant, type FeedbackContext, type FeedbackVariant, HIGHLIGHT_OPACITY, type MergeableProps, PRESS_DURATION, PRESS_SCALE, type PossibleRef, PressableFeedback, type PressableFeedbackHighlightProps, type PressableFeedbackProps, type PressableFeedbackRippleProps, RELEASE_DURATION, RIPPLE_COVERAGE, RIPPLE_DURATION, RIPPLE_OPACITY, type Recipe, type RecipeConfig, type ResolveArgs, type ResolvedAnimation, type ResolvedSelection, type ResolvedStyles, type Selection, Slot, type SlotAnimation, type SlotProps, type SlotStyle, type SlotStyles, type StateName, type States, type StyleFn, type TintArgs, type VariantColors, type VariantRole, type VariantTokens, childrenToString, createRecipe, createSlotContext, mergeProps, mergeRefs, resolveAnimation, resolveSlotAnimation, useFeedback };