@xaui/native 0.9.1-alpha.2 → 0.9.1-alpha.20

package/dist/index.d.cts

@@ -1,5 +1,78 @@
-export { AsChildProps, Axes, CompoundVariant, MergeableProps, PossibleRef, Recipe, RecipeConfig, ResolveArgs, ResolvedSelection, ResolvedStyles, Selection, Slot, SlotProps, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, childrenToString, createRecipe, createSlotContext, mergeProps, mergeRefs } from './system/index.cjs';
+export { Button, ButtonContextValue, ButtonIconProps, ButtonLabelProps, ButtonProps, ButtonSize, ButtonSlot, ButtonSpinnerProps, ButtonVariant, buttonRecipe, useButton } from './components/button/index.cjs';
+export { TextSpan, TextSpanProps, Typography, TypographyProps, TypographySlot, TypographyVariant, typographyRecipe } from './components/typography/index.cjs';
+export { AxisProps, Column, ColumnProps, Grid, GridContextValue, GridItemProps, GridProps, Row, RowProps, Stack, StackItemProps, StackProps, useGrid } from './components/view/index.cjs';
+import { RefCallback } from 'react';
+import { PossibleRef } from './system/index.cjs';
+export { AsChildProps, FEEDBACK_OVERLAY, HIGHLIGHT_DURATION, HIGHLIGHT_OPACITY, Icon, IconContext, MergeableProps, PRESS_DURATION, PRESS_SCALE, Portal, PortalContext, PortalHost, PortalHostProps, PortalMethods, PortalProps, PressableFeedback, PressableFeedbackHighlightProps, PressableFeedbackRippleProps, RIPPLE_CONFIRM_DURATION, RIPPLE_EXPAND_DURATION, RIPPLE_FADE_IN, RIPPLE_FADE_OUT, RIPPLE_FADE_OUT_DELAY, RIPPLE_OPACITY, RIPPLE_START_SCALE, SCALE_REFERENCE_WIDTH, Slot, SlotProps, childrenToString, createSlotContext, markOverlay, mergeProps, mergeRefs, pressScaleFor, resolveAnimation, resolveSlotAnimation, rippleRadiusFor, useFeedback, useIconContext, useStyleProps } from './system/index.cjs';
+import { GestureResponderEvent } from 'react-native';
+export { A as AnimationConfig, c as AnimationProp, F as FeedbackContext, I as IconComponentProps, a as IconContextValue, b as IconProps, P as PressableFeedbackProps, R as RadiusStyle, d as ResolvedAnimation, e as RippleWave, S as SlotAnimation } from './pressable-feedback.type-1K8YEOb8.cjs';
+export { A as Axes, C as CompoundVariant, R as Recipe, b as RecipeConfig, a as ResolveArgs, d as ResolvedSelection, e as ResolvedStyles, S as Selection, f as SlotStyle, g as SlotStyles, h as StateName, i as States, j as StyleFn, T as TintArgs, V as VariantColors, k as VariantRole, l as VariantTokens, c as createRecipe } from './create-recipe-C0XXjuow.cjs';
+export { D as DirectionalStyleKey, I as ImageStyleProps, S as StyleProps, T as TextStyleProps, V as ViewStyleProps } from './style-props.type-B1BG5TCm.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';
-import 'react';
+export { C as ColorMode, F as FontSizeKey, b as FontWeightKey, R as RadiusKey, S as Size, a as XAUIColors, c as XAUIDerivedColors, d as XAUIPrimitiveColors, e as XAUIRadius, f as XAUIShadow, g as XAUISourceColors, X as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-C2gNHpEx.cjs';
+import 'react-native-reanimated';
+
+type ControllableStateOptions<T> = {
+    /** Present means controlled: the caller owns the value and this never stores one. */
+    value?: T;
+    /** The starting value when uncontrolled. */
+    defaultValue: T;
+    /** Called with every new value, controlled or not. */
+    onChange?: (value: T) => void;
+};
+/**
+ * One state that works both ways, so a component never has two code paths for "the
+ * caller drives this" and "we do".
+ *
+ * The setter is stable across renders and reads the current value from a ref, so a
+ * handler built on it can be passed to a memoized child without rebuilding it on every
+ * render — which is the whole reason components reach for this rather than a local
+ * `useState` plus an `if`.
+ */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((current: T) => T)) => void];
+
+/**
+ * `mergeRefs` for a component that renders: memoized on the refs it was given, so React
+ * does not detach and reattach every one of them on each render — which it does whenever
+ * a ref callback changes identity, and which costs a node measurement every time.
+ */
+declare function useMergedRef<T>(...refs: Array<PossibleRef<T>>): RefCallback<T>;
+
+/**
+ * `null` as much as `undefined`: that is how `PressableProps` types its handlers, and a
+ * root forwarding what it was given should not have to launder them first.
+ */
+type PressHandlers = {
+    onPressIn?: PressHandler | null;
+    onPressOut?: PressHandler | null;
+};
+type PressHandler = (event: GestureResponderEvent) => void;
+/**
+ * The press state a root owns, with the handlers that maintain it.
+ *
+ * It exists because every pressable component needs the same three things and gets one
+ * of them wrong on its own: the state has to be *up here* — the recipe resolves on it
+ * (R5) — the caller's handlers must be **composed, never replaced**, and the returned
+ * handlers must keep their identity so passing them down does not defeat a memo.
+ *
+ * ```tsx
+ * const [isPressed, pressHandlers] = usePressState(props)
+ * const styles = recipe.resolve({ theme, selection, states: { pressed: isPressed } })
+ * <PressableFeedback isPressed={isPressed} {...pressHandlers} />
+ * ```
+ */
+declare function usePressState(handlers?: PressHandlers): [boolean, {
+    onPressIn: PressHandler;
+    onPressOut: PressHandler;
+}];
+
+/**
+ * The value from the render before this one, `undefined` on the first.
+ *
+ * Written in an effect rather than during render on purpose: reading it mid-render would
+ * make "previous" mean something different depending on whether React re-ran the render,
+ * which under StrictMode it does.
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+
+export { type ControllableStateOptions, PossibleRef, type PressHandlers, useControllableState, useMergedRef, usePressState, usePrevious };

package/dist/index.d.ts

@@ -1,5 +1,78 @@
-export { AsChildProps, Axes, CompoundVariant, MergeableProps, PossibleRef, Recipe, RecipeConfig, ResolveArgs, ResolvedSelection, ResolvedStyles, Selection, Slot, SlotProps, SlotStyle, SlotStyles, StateName, States, StyleFn, TintArgs, VariantColors, VariantRole, VariantTokens, childrenToString, createRecipe, createSlotContext, mergeProps, mergeRefs } from './system/index.js';
+export { Button, ButtonContextValue, ButtonIconProps, ButtonLabelProps, ButtonProps, ButtonSize, ButtonSlot, ButtonSpinnerProps, ButtonVariant, buttonRecipe, useButton } from './components/button/index.js';
+export { TextSpan, TextSpanProps, Typography, TypographyProps, TypographySlot, TypographyVariant, typographyRecipe } from './components/typography/index.js';
+export { AxisProps, Column, ColumnProps, Grid, GridContextValue, GridItemProps, GridProps, Row, RowProps, Stack, StackItemProps, StackProps, useGrid } from './components/view/index.js';
+import { RefCallback } from 'react';
+import { PossibleRef } from './system/index.js';
+export { AsChildProps, FEEDBACK_OVERLAY, HIGHLIGHT_DURATION, HIGHLIGHT_OPACITY, Icon, IconContext, MergeableProps, PRESS_DURATION, PRESS_SCALE, Portal, PortalContext, PortalHost, PortalHostProps, PortalMethods, PortalProps, PressableFeedback, PressableFeedbackHighlightProps, PressableFeedbackRippleProps, RIPPLE_CONFIRM_DURATION, RIPPLE_EXPAND_DURATION, RIPPLE_FADE_IN, RIPPLE_FADE_OUT, RIPPLE_FADE_OUT_DELAY, RIPPLE_OPACITY, RIPPLE_START_SCALE, SCALE_REFERENCE_WIDTH, Slot, SlotProps, childrenToString, createSlotContext, markOverlay, mergeProps, mergeRefs, pressScaleFor, resolveAnimation, resolveSlotAnimation, rippleRadiusFor, useFeedback, useIconContext, useStyleProps } from './system/index.js';
+import { GestureResponderEvent } from 'react-native';
+export { A as AnimationConfig, c as AnimationProp, F as FeedbackContext, I as IconComponentProps, a as IconContextValue, b as IconProps, P as PressableFeedbackProps, R as RadiusStyle, d as ResolvedAnimation, e as RippleWave, S as SlotAnimation } from './pressable-feedback.type-BwkKLQlX.js';
+export { A as Axes, C as CompoundVariant, R as Recipe, b as RecipeConfig, a as ResolveArgs, d as ResolvedSelection, e as ResolvedStyles, S as Selection, f as SlotStyle, g as SlotStyles, h as StateName, i as States, j as StyleFn, T as TintArgs, V as VariantColors, k as VariantRole, l as VariantTokens, c as createRecipe } from './create-recipe-CPXFo2rk.js';
+export { D as DirectionalStyleKey, I as ImageStyleProps, S as StyleProps, T as TextStyleProps, V as ViewStyleProps } from './style-props.type-B1BG5TCm.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';
-import 'react';
+export { C as ColorMode, F as FontSizeKey, b as FontWeightKey, R as RadiusKey, S as Size, a as XAUIColors, c as XAUIDerivedColors, d as XAUIPrimitiveColors, e as XAUIRadius, f as XAUIShadow, g as XAUISourceColors, X as XAUITheme, h as XAUIThemeConfig, i as XAUIThemeSet } from './theme.type-C2gNHpEx.js';
+import 'react-native-reanimated';
+
+type ControllableStateOptions<T> = {
+    /** Present means controlled: the caller owns the value and this never stores one. */
+    value?: T;
+    /** The starting value when uncontrolled. */
+    defaultValue: T;
+    /** Called with every new value, controlled or not. */
+    onChange?: (value: T) => void;
+};
+/**
+ * One state that works both ways, so a component never has two code paths for "the
+ * caller drives this" and "we do".
+ *
+ * The setter is stable across renders and reads the current value from a ref, so a
+ * handler built on it can be passed to a memoized child without rebuilding it on every
+ * render — which is the whole reason components reach for this rather than a local
+ * `useState` plus an `if`.
+ */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((current: T) => T)) => void];
+
+/**
+ * `mergeRefs` for a component that renders: memoized on the refs it was given, so React
+ * does not detach and reattach every one of them on each render — which it does whenever
+ * a ref callback changes identity, and which costs a node measurement every time.
+ */
+declare function useMergedRef<T>(...refs: Array<PossibleRef<T>>): RefCallback<T>;
+
+/**
+ * `null` as much as `undefined`: that is how `PressableProps` types its handlers, and a
+ * root forwarding what it was given should not have to launder them first.
+ */
+type PressHandlers = {
+    onPressIn?: PressHandler | null;
+    onPressOut?: PressHandler | null;
+};
+type PressHandler = (event: GestureResponderEvent) => void;
+/**
+ * The press state a root owns, with the handlers that maintain it.
+ *
+ * It exists because every pressable component needs the same three things and gets one
+ * of them wrong on its own: the state has to be *up here* — the recipe resolves on it
+ * (R5) — the caller's handlers must be **composed, never replaced**, and the returned
+ * handlers must keep their identity so passing them down does not defeat a memo.
+ *
+ * ```tsx
+ * const [isPressed, pressHandlers] = usePressState(props)
+ * const styles = recipe.resolve({ theme, selection, states: { pressed: isPressed } })
+ * <PressableFeedback isPressed={isPressed} {...pressHandlers} />
+ * ```
+ */
+declare function usePressState(handlers?: PressHandlers): [boolean, {
+    onPressIn: PressHandler;
+    onPressOut: PressHandler;
+}];
+
+/**
+ * The value from the render before this one, `undefined` on the first.
+ *
+ * Written in an effect rather than during render on purpose: reading it mid-render would
+ * make "previous" mean something different depending on whether React re-ran the render,
+ * which under StrictMode it does.
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+
+export { type ControllableStateOptions, PossibleRef, type PressHandlers, useControllableState, useMergedRef, usePressState, usePrevious };

package/dist/index.js

@@ -1,13 +1,64 @@
+import {
+  Button,
+  buttonRecipe,
+  useButton,
+  usePressState,
+  warnDev
+} from "./chunk-4EPS7UBO.js";
+import {
+  TextSpan,
+  Typography,
+  typographyRecipe
+} from "./chunk-RMLFMRWL.js";
+import {
+  Column,
+  Grid,
+  Row,
+  Stack,
+  useGrid
+} from "./chunk-JXLRHKCQ.js";
+import {
+  Portal,
+  PortalContext,
+  PortalHost
+} from "./chunk-XHZBXYVU.js";
+import {
+  FEEDBACK_OVERLAY,
+  HIGHLIGHT_DURATION,
+  HIGHLIGHT_OPACITY,
+  Icon,
+  IconContext,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  PressableFeedback,
+  RIPPLE_CONFIRM_DURATION,
+  RIPPLE_EXPAND_DURATION,
+  RIPPLE_FADE_IN,
+  RIPPLE_FADE_OUT,
+  RIPPLE_FADE_OUT_DELAY,
+  RIPPLE_OPACITY,
+  RIPPLE_START_SCALE,
+  SCALE_REFERENCE_WIDTH,
+  markOverlay,
+  pressScaleFor,
+  resolveAnimation,
+  resolveSlotAnimation,
+  rippleRadiusFor,
+  useFeedback,
+  useIconContext
+} from "./chunk-WXAME7KB.js";
+import {
+  createRecipe
+} from "./chunk-N7C4UNUL.js";
 import {
   Slot,
   childrenToString,
-  createRecipe,
   createSlotContext,
   mergeProps,
-  mergeRefs
-} from "./chunk-RCP3SD26.js";
+  mergeRefs,
+  useStyleProps
+} from "./chunk-EXX6ATAS.js";
 import {
-  ThemeContext,
   XAUIProvider,
   buildRadius,
   buildShadows,
@@ -17,20 +68,100 @@ import {
   palette,
   primitives,
   sourceKeys,
-  tokens,
+  tokens
+} from "./chunk-MWXE7D4L.js";
+import {
+  ThemeContext,
+  deriveTint,
   useColorMode,
   useThemeColor,
   useXAUITheme
-} from "./chunk-PBVPOX7D.js";
-import {
-  deriveTint
-} from "./chunk-RBNCR5KB.js";
+} from "./chunk-A3EGFI6T.js";
+import "./chunk-GGW42MY4.js";
+
+// src/hooks/use-controllable-state.ts
+import { useCallback, useRef, useState } from "react";
+function useControllableState({
+  value,
+  defaultValue,
+  onChange
+}) {
+  const [uncontrolled, setUncontrolled] = useState(defaultValue);
+  const isControlled = value !== void 0;
+  const current = isControlled ? value : uncontrolled;
+  useControlWarning(isControlled);
+  const latest = useRef(current);
+  latest.current = current;
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const controlled = useRef(isControlled);
+  controlled.current = isControlled;
+  const set = useCallback((next) => {
+    const resolved = typeof next === "function" ? next(latest.current) : next;
+    if (resolved === latest.current) return;
+    if (!controlled.current) setUncontrolled(resolved);
+    onChangeRef.current?.(resolved);
+  }, []);
+  return [current, set];
+}
+function useControlWarning(isControlled) {
+  const wasControlled = useRef(isControlled);
+  if (wasControlled.current !== isControlled) {
+    warnDev(
+      `a component switched from ${wasControlled.current ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}. Decide for the life of the component: pass \`value\` always, or never. Passing \`undefined\` for a value you do control reads as "uncontrolled" here.`
+    );
+    wasControlled.current = isControlled;
+  }
+}
+
+// src/hooks/use-merged-ref.ts
+import { useMemo } from "react";
+function useMergedRef(...refs) {
+  return useMemo(() => mergeRefs(...refs), refs);
+}
+
+// src/hooks/use-previous.ts
+import { useEffect, useRef as useRef2 } from "react";
+function usePrevious(value) {
+  const previous = useRef2(void 0);
+  useEffect(() => {
+    previous.current = value;
+  }, [value]);
+  return previous.current;
+}
 export {
+  Button,
+  Column,
+  FEEDBACK_OVERLAY,
+  Grid,
+  HIGHLIGHT_DURATION,
+  HIGHLIGHT_OPACITY,
+  Icon,
+  IconContext,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  Portal,
+  PortalContext,
+  PortalHost,
+  PressableFeedback,
+  RIPPLE_CONFIRM_DURATION,
+  RIPPLE_EXPAND_DURATION,
+  RIPPLE_FADE_IN,
+  RIPPLE_FADE_OUT,
+  RIPPLE_FADE_OUT_DELAY,
+  RIPPLE_OPACITY,
+  RIPPLE_START_SCALE,
+  Row,
+  SCALE_REFERENCE_WIDTH,
   Slot,
+  Stack,
+  TextSpan,
   ThemeContext,
+  Typography,
   XAUIProvider,
   buildRadius,
   buildShadows,
+  buttonRecipe,
   childrenToString,
   createRecipe,
   createSlotContext,
@@ -38,13 +169,28 @@ export {
   defaultTheme,
   deriveColors,
   deriveTint,
+  markOverlay,
   mergeProps,
   mergeRefs,
   palette,
+  pressScaleFor,
   primitives,
+  resolveAnimation,
+  resolveSlotAnimation,
+  rippleRadiusFor,
   sourceKeys,
   tokens,
+  typographyRecipe,
+  useButton,
   useColorMode,
+  useControllableState,
+  useFeedback,
+  useGrid,
+  useIconContext,
+  useMergedRef,
+  usePressState,
+  usePrevious,
+  useStyleProps,
   useThemeColor,
   useXAUITheme
 };

package/dist/pressable-feedback.type-1K8YEOb8.d.cts

@@ -0,0 +1,195 @@
+import { ComponentType, ReactNode } from 'react';
+import { ImageSourcePropType, StyleProp, ImageStyle, PressableProps, ViewStyle } from 'react-native';
+import { I as ImageStyleProps, V as ViewStyleProps } from './style-props.type-B1BG5TCm.cjs';
+import { SharedValue } from 'react-native-reanimated';
+
+/**
+ * The props Lucide, Ionicons and `react-native-vector-icons` all accept — the shape
+ * `as` is handed. It is a convention rather than an interface anyone published, which is
+ * exactly why `Icon` exists: without it every call site computes the two values by hand.
+ */
+type IconComponentProps = {
+    size?: number;
+    color?: string;
+};
+/** What every form takes, and the only lever the two non-rendering ones have. */
+type IconBase = {
+    /** Overrides what the surrounding slot asked for. */
+    size?: number;
+    /** A raw value (R7), never a token. Overrides the slot's. */
+    color?: string;
+};
+/**
+ * An icon component — `size` and `color` are injected into it.
+ *
+ * No style props and no `style`: we do not render this node, the third party does, and
+ * there is no published interface that says it would accept either. Wrapping it in a view
+ * to make them work would add a level of depth to every icon in the library.
+ */
+type IconAsProps = IconBase & {
+    as: ComponentType<IconComponentProps>;
+    children?: never;
+    source?: never;
+};
+/**
+ * A raw `react-native-svg` element, cloned with the resolved size and colour.
+ *
+ * No style props and no `style` either: the node is the caller's own element, and they can
+ * style it where they wrote it.
+ */
+type IconChildrenProps = IconBase & {
+    as?: never;
+    children: ReactNode;
+    source?: never;
+};
+/**
+ * An image, tinted with the resolved colour — **the one form that carries R14**, because
+ * it is the one where we render the node.
+ */
+type IconSourceProps = IconBase & ImageStyleProps & {
+    as?: never;
+    children?: never;
+    source: ImageSourcePropType;
+    style?: StyleProp<ImageStyle>;
+};
+/**
+ * Three forms, and the type says which one you are in.
+ *
+ * The union is what makes R14's boundary checkable rather than merely documented. When
+ * every form declared the style props, `<Icon as={Trash2} marginEnd={8} />` compiled and
+ * did nothing at all — the prop was dropped on the two forms that do not render the node,
+ * silently, and only a comment said so. Now it is a compile error that points at `size`
+ * and `color`, which are the levers those forms actually have.
+ *
+ * It also makes the three mutually exclusive, which they always were at runtime: `as`
+ * wins over children, and children over `source`.
+ */
+type IconProps = IconAsProps | IconChildrenProps | IconSourceProps;
+/** What a component root publishes so the icons inside it need no props at all. */
+type IconContextValue = {
+    size?: number;
+    color?: string;
+};
+
+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;
+};
+/**
+ * R14 — it renders a `Pressable`, so it takes that node's style keys as props. The
+ * primitive every pressable component in the library is built on cannot be the one place
+ * where `padding={16}` has to become an object again.
+ */
+type PressableFeedbackProps = Omit<PressableProps, 'style' | 'children' | 'disabled'> & ViewStyleProps & {
+    /** 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;
+    animation?: AnimationProp;
+    style?: StyleProp<ViewStyle>;
+    /**
+     * The overlays are children, not a prop — `<PressableFeedback.Highlight />` or
+     * `<PressableFeedback.Ripple />`, in any order: the root paints them under everything
+     * else wherever they sit. The scale is the root's own and needs nothing rendered.
+     *
+     * `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;
+};
+/** One ripple wave. Two of them, so a rapid double tap does not cut the one in flight. */
+type RippleWave = {
+    /** `0 → 1` as the circle opens. */
+    expand: SharedValue<number>;
+    /** `0 → 1` as the ink arrives, on its own curve. */
+    alpha: SharedValue<number>;
+    /** Where the finger landed, in the root's coordinates. */
+    origin: SharedValue<{
+        x: number;
+        y: number;
+    }>;
+};
+/**
+ * The corner keys an overlay copies off the root. The `Left`/`Right` forms are absent
+ * rather than forgotten: R13 bans them, because RN mirrors only the logical ones under RTL.
+ */
+type RadiusStyle = Pick<ViewStyle, 'borderRadius' | 'borderStartStartRadius' | 'borderStartEndRadius' | 'borderEndStartRadius' | 'borderEndEndRadius'>;
+type FeedbackContext = {
+    /**
+     * The overlay's ink, resolved by the root from its own background.
+     *
+     * A wash or a wave has to contrast with what it sits on, and only the root knows that —
+     * it flattens its own `style` and reads `backgroundColor`, then takes the contrasting
+     * side the same way a tint does. Black ink at 10% on a saturated fill is close to
+     * invisible, which is the one thing a press indicator cannot be.
+     */
+    ink: string;
+    /**
+     * The root's own corners, so an overlay rounds itself to match. `corners` and not
+     * `radius`: the ripple already has a radius, and it is a length in points rather than a
+     * shape.
+     *
+     * An absolute fill has square corners and every control here is rounded, so without this
+     * both the wash and the wave paint outside the surface at each corner. The overlay
+     * carries the clip rather than the root: clipping the root would also cut a child that
+     * legitimately overflows — a badge on a button's corner — and that child has nothing to
+     * do with the press.
+     */
+    corners: RadiusStyle;
+    isPressed: boolean;
+    animation: ResolvedAnimation;
+    /** Absent on the static branch, where nothing animates and no worklet is mounted. */
+    progress?: SharedValue<number>;
+    /** How big the root is — what the scale coefficient is computed from. */
+    size?: SharedValue<{
+        width: number;
+        height: number;
+    }>;
+    /**
+     * The two ripple waves, driven by the **root**.
+     *
+     * They belong to the root because the root is the touch surface. An overlay carrying its
+     * own handlers only hears touches that land on *it* — and it is a sibling of the label,
+     * not its parent, so pressing the text of a button would do nothing. Touches bubble to
+     * the `Pressable`, which is why the handlers live there and the waves are published down.
+     */
+    waves?: readonly [RippleWave, RippleWave];
+};
+
+export type { AnimationConfig as A, FeedbackContext as F, IconComponentProps as I, PressableFeedbackProps as P, RadiusStyle as R, SlotAnimation as S, IconContextValue as a, IconProps as b, AnimationProp as c, ResolvedAnimation as d, RippleWave as e };