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

package/dist/index.d.ts

@@ -1,6 +1,112 @@
-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 { Alert, AlertCloseProps, AlertContentProps, AlertContextValue, AlertDescriptionProps, AlertIconProps, AlertProps, AlertSize, AlertSlot, AlertTitleProps, AlertVariant, alertRecipe, useAlert } from './components/alert/index.js';
+export { Button, ButtonContextValue, ButtonIconProps, ButtonLabelProps, ButtonProps, ButtonSize, ButtonSlot, ButtonSpinnerProps, ButtonVariant, buttonRecipe, useButton } from './components/button/index.js';
+export { CARD_BACKGROUND, Card, CardBackgroundProps, CardBodyProps, CardContextValue, CardDescriptionProps, CardFooterProps, CardHeaderProps, CardProps, CardSize, CardSlot, CardTitleProps, CardVariant, cardRecipe, markBackground, useCard } from './components/card/index.js';
+export { Checkbox, CheckboxContextValue, CheckboxIndicator, CheckboxIndicatorProps, CheckboxLabel, CheckboxLabelProps, CheckboxProps, CheckboxRoot, CheckboxSize, CheckboxSlot, CheckboxVariant, checkboxRecipe, useCheckbox } from './components/checkbox/index.js';
+export { Chip, ChipAvatarProps, ChipCloseProps, ChipContextValue, ChipDotProps, ChipIconProps, ChipLabelProps, ChipProps, ChipSize, ChipSlot, ChipVariant, chipRecipe, useChip } from './components/chip/index.js';
+export { Divider, DividerOrientation, DividerProps, DividerSize, DividerSlot, dividerRecipe } from './components/divider/index.js';
+export { Input, InputDescription, InputError, InputField, InputLabel, InputRoot, inputRecipe, useInput } from './components/input/index.js';
+export { InputGroup, InputGroupContextValue, InputGroupField, InputGroupFieldProps, InputGroupIcon, InputGroupIconProps, InputGroupPrefix, InputGroupPrefixProps, InputGroupProps, InputGroupRoot, InputGroupSide, InputGroupSuffix, InputGroupSuffixProps, decoratorPadding, useInputGroup } from './components/input-group/index.js';
+export { InputOTP, InputOTPBoxContextValue, InputOTPBoxProps, InputOTPCaretProps, InputOTPContextValue, InputOTPGroupProps, InputOTPHandle, InputOTPPattern, InputOTPPlaceholderProps, InputOTPProps, InputOTPRenderState, InputOTPSeparatorProps, InputOTPSize, InputOTPSlot, InputOTPValueProps, InputOTPVariant, OTPSlotState, OTP_ALPHANUMERIC, OTP_DIGITS, OTP_LETTERS, buildSlots, extractPastedCode, inputOTPRecipe, useInputOTP, useInputOTPBox } from './components/input-otp/index.js';
+export { Radio, RadioContextValue, RadioIndicator, RadioIndicatorProps, RadioLabel, RadioLabelProps, RadioProps, RadioRoot, RadioSize, RadioSlot, RadioVariant, radioRecipe, useRadio } from './components/radio/index.js';
+export { Spinner, SpinnerProps, SpinnerSize, SpinnerSlot, SpinnerVariant, spinnerRecipe } from './components/spinner/index.js';
+export { Switch, SwitchContextValue, SwitchLabel, SwitchLabelProps, SwitchProps, SwitchRoot, SwitchSize, SwitchSlot, SwitchThumb, SwitchThumbProps, SwitchTrack, SwitchTrackProps, SwitchVariant, switchRecipe, useSwitch } from './components/switch/index.js';
+export { TextArea, TextAreaContextValue, TextAreaFieldProps, TextAreaProps, useTextArea } from './components/text-area/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, CloseButton, CloseButtonSlots, 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, SelectionFill, SelectionFillProps, Slot, SlotProps, childrenToString, closeButtonBase, createSlotContext, markOverlay, mergeProps, mergeRefs, pressScaleFor, radiusAxis, resolveAnimation, resolveSlotAnimation, rippleRadiusFor, useFeedback, useIconContext, useStyleProps } from './system/index.js';
+import { GestureResponderEvent, ViewStyle } from 'react-native';
+export { C as CloseButtonProps } from './close-button.type-BUYuoSt2.js';
+export { b as IconComponentProps, I as IconContextValue, a as IconProps } from './icon.type-Kml72iSz.js';
+export { A as Axes, C as CompoundVariant, R as Recipe, d as RecipeConfig, b as ResolveArgs, e as ResolvedSelection, f as ResolvedStyles, g as Selection, h as SlotStyle, S as SlotStyles, i as StateName, j as States, a as StyleFn, T as TintArgs, V as VariantColors, k as VariantRole, l as VariantTokens, c as createRecipe } from './create-recipe-BdVd2ffi.js';
+export { D as DirectionalStyleKey, I as ImageStyleProps, S as StyleProps, T as TextStyleProps, V as ViewStyleProps } from './style-props.type-CfnoGEP7.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-C9bFJKFm.js';
-import 'react';
-import 'react-native';
+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';
+export { b as InputContextValue, c as InputDescriptionProps, d as InputErrorProps, I as InputFieldProps, e as InputLabelPlacement, f as InputLabelProps, a as InputProps, g as InputSize, h as InputSlot, i as InputVariant } from './input.type-D2qgi03E.js';
+export { A as AnimationConfig, a as AnimationProp, F as FeedbackContext, P as PressableFeedbackProps, R as RadiusStyle, b as ResolvedAnimation, c as RippleWave, S as SlotAnimation } from './pressable-feedback.type-Bs4dQlGj.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;
+
+/**
+ * One turn. Slow enough to read as waiting, fast enough not to read as stuck — HeroUI
+ * arrives at the same figure from the other side, a 1000ms turn played at 1.1×.
+ *
+ * It is a constant rather than a parameter because the library turns at one speed: two
+ * spinners on one screen at two rates is a bug, and the only way to be sure of that is
+ * for there to be one number.
+ */
+declare const ROTATION_DURATION = 900;
+/**
+ * A full turn, repeating, on the UI thread. Returns the animated style to merge onto the
+ * node that spins.
+ *
+ * **A caller that must animate nothing does not call it.** Hooks cannot be conditional,
+ * so "no animation" is only true if this one is never reached — which is why both call
+ * sites render two components rather than branch inside one.
+ */
+declare function useRotation(): ViewStyle;
+
+export { type ControllableStateOptions, PossibleRef, type PressHandlers, ROTATION_DURATION, useControllableState, useMergedRef, usePressState, usePrevious, useRotation };

package/dist/index.js

@@ -1,22 +1,8 @@
 import {
-  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";
+  Portal,
+  PortalContext,
+  PortalHost
+} from "./chunk-7SEZGVTY.js";
 import {
   XAUIProvider,
   buildRadius,
@@ -28,45 +14,307 @@ import {
   primitives,
   sourceKeys,
   tokens
-} from "./chunk-2KXQATVL.js";
+} from "./chunk-TZG3DERP.js";
+import {
+  InputOTP,
+  OTP_ALPHANUMERIC,
+  OTP_DIGITS,
+  OTP_LETTERS,
+  buildSlots,
+  extractPastedCode,
+  inputOTPRecipe,
+  useInputOTP,
+  useInputOTPBox
+} from "./chunk-X4HQ4H2V.js";
+import {
+  Radio,
+  RadioIndicator,
+  RadioLabel,
+  RadioRoot,
+  radioRecipe,
+  useRadio
+} from "./chunk-IHOCANCQ.js";
+import {
+  Spinner,
+  spinnerRecipe
+} from "./chunk-KOC3KQIT.js";
+import {
+  Switch,
+  SwitchLabel,
+  SwitchRoot,
+  SwitchThumb,
+  SwitchTrack,
+  switchRecipe,
+  useSwitch
+} from "./chunk-42FMGB5M.js";
+import {
+  TextArea,
+  useTextArea
+} from "./chunk-GVQOD3VW.js";
+import {
+  TextSpan,
+  Typography,
+  typographyRecipe
+} from "./chunk-NYRXUGVL.js";
+import {
+  Column,
+  Grid,
+  Row,
+  Stack,
+  useGrid
+} from "./chunk-G7K652GC.js";
+import {
+  Alert,
+  alertRecipe,
+  useAlert
+} from "./chunk-Q3WFY5N3.js";
+import {
+  Button,
+  buttonRecipe,
+  useButton
+} from "./chunk-MDVSCWJI.js";
+import {
+  ROTATION_DURATION,
+  useMergedRef,
+  usePrevious,
+  useRotation
+} from "./chunk-BVJQ3UPZ.js";
+import {
+  CARD_BACKGROUND,
+  Card,
+  cardRecipe,
+  markBackground,
+  useCard
+} from "./chunk-VJEER76X.js";
+import {
+  Checkbox,
+  CheckboxIndicator,
+  CheckboxLabel,
+  CheckboxRoot,
+  checkboxRecipe,
+  useCheckbox
+} from "./chunk-RDTKAAHX.js";
+import {
+  SelectionFill
+} from "./chunk-BA2DBSAN.js";
+import {
+  useControllableState
+} from "./chunk-F6W3JQ7K.js";
+import {
+  Chip,
+  chipRecipe,
+  useChip
+} from "./chunk-ZH6BHLQR.js";
+import {
+  CloseButton,
+  closeButtonBase
+} from "./chunk-V4WDMM6Z.js";
+import {
+  FEEDBACK_OVERLAY,
+  HIGHLIGHT_DURATION,
+  HIGHLIGHT_OPACITY,
+  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
+} from "./chunk-BFMTUMTU.js";
+import {
+  usePressState
+} from "./chunk-423RQBOX.js";
+import "./chunk-EGLLDKN6.js";
+import {
+  Divider,
+  dividerRecipe
+} from "./chunk-ZH5XVNHG.js";
+import {
+  InputGroup,
+  InputGroupField,
+  InputGroupIcon,
+  InputGroupPrefix,
+  InputGroupRoot,
+  InputGroupSuffix,
+  decoratorPadding,
+  useInputGroup
+} from "./chunk-DFME724B.js";
+import {
+  Input,
+  InputDescription,
+  InputError,
+  InputField,
+  InputLabel,
+  InputRoot,
+  inputRecipe,
+  useInput
+} from "./chunk-A5OCK3C2.js";
+import {
+  Icon,
+  IconContext,
+  useIconContext
+} from "./chunk-3FV4COTM.js";
+import {
+  createRecipe,
+  radiusAxis
+} from "./chunk-4GTAZM2C.js";
 import {
   ThemeContext,
   deriveTint,
   useColorMode,
   useThemeColor,
   useXAUITheme
-} from "./chunk-X2K2FX3W.js";
+} from "./chunk-A3EGFI6T.js";
+import {
+  Slot,
+  childrenToString,
+  createSlotContext,
+  mergeProps
+} from "./chunk-E2CWBQTV.js";
+import {
+  mergeRefs,
+  useStyleProps
+} from "./chunk-URSKA2VR.js";
+import "./chunk-GGW42MY4.js";
 export {
+  Alert,
+  Button,
+  CARD_BACKGROUND,
+  Card,
+  Checkbox,
+  CheckboxIndicator,
+  CheckboxLabel,
+  CheckboxRoot,
+  Chip,
+  CloseButton,
+  Column,
+  Divider,
+  FEEDBACK_OVERLAY,
+  Grid,
+  HIGHLIGHT_DURATION,
   HIGHLIGHT_OPACITY,
+  Icon,
+  IconContext,
+  Input,
+  InputDescription,
+  InputError,
+  InputField,
+  InputGroup,
+  InputGroupField,
+  InputGroupIcon,
+  InputGroupPrefix,
+  InputGroupRoot,
+  InputGroupSuffix,
+  InputLabel,
+  InputOTP,
+  InputRoot,
+  OTP_ALPHANUMERIC,
+  OTP_DIGITS,
+  OTP_LETTERS,
   PRESS_DURATION,
   PRESS_SCALE,
+  Portal,
+  PortalContext,
+  PortalHost,
   PressableFeedback,
-  RELEASE_DURATION,
-  RIPPLE_COVERAGE,
-  RIPPLE_DURATION,
+  RIPPLE_CONFIRM_DURATION,
+  RIPPLE_EXPAND_DURATION,
+  RIPPLE_FADE_IN,
+  RIPPLE_FADE_OUT,
+  RIPPLE_FADE_OUT_DELAY,
   RIPPLE_OPACITY,
+  RIPPLE_START_SCALE,
+  ROTATION_DURATION,
+  Radio,
+  RadioIndicator,
+  RadioLabel,
+  RadioRoot,
+  Row,
+  SCALE_REFERENCE_WIDTH,
+  SelectionFill,
   Slot,
+  Spinner,
+  Stack,
+  Switch,
+  SwitchLabel,
+  SwitchRoot,
+  SwitchThumb,
+  SwitchTrack,
+  TextArea,
+  TextSpan,
   ThemeContext,
+  Typography,
   XAUIProvider,
+  alertRecipe,
   buildRadius,
   buildShadows,
+  buildSlots,
+  buttonRecipe,
+  cardRecipe,
+  checkboxRecipe,
   childrenToString,
+  chipRecipe,
+  closeButtonBase,
   createRecipe,
   createSlotContext,
   createTheme,
+  decoratorPadding,
   defaultTheme,
   deriveColors,
   deriveTint,
+  dividerRecipe,
+  extractPastedCode,
+  inputOTPRecipe,
+  inputRecipe,
+  markBackground,
+  markOverlay,
   mergeProps,
   mergeRefs,
   palette,
+  pressScaleFor,
   primitives,
+  radioRecipe,
+  radiusAxis,
   resolveAnimation,
   resolveSlotAnimation,
+  rippleRadiusFor,
   sourceKeys,
+  spinnerRecipe,
+  switchRecipe,
   tokens,
+  typographyRecipe,
+  useAlert,
+  useButton,
+  useCard,
+  useCheckbox,
+  useChip,
   useColorMode,
+  useControllableState,
   useFeedback,
+  useGrid,
+  useIconContext,
+  useInput,
+  useInputGroup,
+  useInputOTP,
+  useInputOTPBox,
+  useMergedRef,
+  usePressState,
+  usePrevious,
+  useRadio,
+  useRotation,
+  useStyleProps,
+  useSwitch,
+  useTextArea,
   useThemeColor,
   useXAUITheme
 };

package/dist/input.type-BUMDlzL9.d.cts

@@ -0,0 +1,167 @@
+import { ReactNode } from 'react';
+import { StyleProp, TextStyle, ViewStyle, TextInputProps, TextProps, ViewProps } from 'react-native';
+import { T as TextStyleProps, V as ViewStyleProps } from './style-props.type-CfnoGEP7.cjs';
+import { S as Size, R as RadiusKey } from './theme.type-C2gNHpEx.cjs';
+
+type InputSlot = 'root' | 'label' | 'field' | 'textArea' | 'placeholder' | 'description' | 'error' | 'prefix' | 'suffix' | 'icon';
+/**
+ * The library's four emphasis levels, narrowed like the `Card`'s (§1 bis). A field
+ * **reports nothing** — an error is `isInvalid`, which is a state and not a variant — so
+ * `success`, `warning` and `danger` are absent here for the same reason they are there.
+ *
+ * This is where the theme's `field*` family is finally read, and the four names split
+ * HeroUI's two-name `primary | secondary` by saying what each of their ends already is:
+ *
+ * - **`primary`** — the `fieldBackground` fill plus the theme's `field` shadow. HeroUI's
+ *   `primary`, with the elevation their flat token only implies.
+ * - **`secondary`** — the neutral `default` fill. HeroUI's `secondary`, and the default
+ *   here: on a plain background a white field is its border and nothing else, while on a
+ *   card the `fieldBackground` token *is* the card's own colour.
+ * - **`tertiary`** — the border alone, no fill. The same drop the `Button`'s `tertiary`
+ *   makes.
+ * - **`ghost`** — neither. A bare field for a toolbar or an inline edit; it has no border
+ *   to move, so its focus shows in the caret alone.
+ *
+ * The first three name the `fieldBorder` edge and `ghost` gives it up. Its width is the
+ * theme's `borderWidth.field` — HeroUI's `--field-border-width`, which they ship at `0`
+ * and we ship at `1`. That is the one shipped default where the two differ;
+ * `createTheme({ borderWidth: { field: 0 } })` reproduces theirs.
+ */
+type InputVariant = 'primary' | 'secondary' | 'tertiary' | 'ghost';
+/**
+ * Where the label sits relative to the field's box.
+ *
+ * `outside` is the label above the box, in the column's flow. `inside` lifts it into the
+ * box, above the text — the label is taken **out of flow** and placed against the box's
+ * own padding, so the JSX is identical either way and nothing is reparented (R4).
+ *
+ * Because the inside label positions itself against the top of the root, it assumes the
+ * field is the first thing in the column's flow: write `Input.Description` and
+ * `Input.Error` after the field, which is where they belong anyway.
+ */
+type InputLabelPlacement = 'outside' | 'inside';
+type InputSize = Size;
+/**
+ * What the `Input` itself understands. R14 — a name in here is the component's, so the
+ * style prop that shares it is not exposed: `size` is the field's scale and never
+ * `ViewStyle`'s, and `color` is R7's tint.
+ */
+type InputOwnProps = {
+    variant?: InputVariant;
+    /** The field's height, its padding, the gaps and the type. Never width. */
+    size?: InputSize;
+    /** Overrides the `field` radius the theme chose for every size. */
+    radius?: RadiusKey;
+    /** Above the box, or lifted into it. @default 'outside' */
+    labelPlacement?: InputLabelPlacement;
+    /**
+     * A raw tint (`'#7c3aed'`), never a token (R7). It lands where the variant put its
+     * tokens — the fill of a `default`, the border of a `tertiary` — and, because the focus
+     * colour is a role like any other, it is also what the field borders on focus.
+     */
+    color?: string;
+    /**
+     * Paints the border, the label and the description in `danger`, and takes the focus
+     * treatment off: an error outranks focus, and a field that is both should read as
+     * wrong rather than as busy.
+     *
+     * It does **not** mount or unmount `Input.Error`. That stays the caller's — a slot that
+     * silently renders nothing is a slot you cannot debug.
+     */
+    isInvalid?: boolean;
+    /** Dims the field and makes it uneditable. */
+    isDisabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+};
+/**
+ * R14 — the input's own props, the wrapper `View`'s, and every `ViewStyle` key neither
+ * already claims. **`TextInputProps` are not here**: they belong to `Input.Field`, which
+ * is the node that has them.
+ */
+type InputProps = InputOwnProps & Omit<ViewProps, keyof InputOwnProps> & Omit<ViewStyleProps, keyof InputOwnProps | keyof ViewProps> & {
+    /** R12 — merge into the single child instead of rendering a `View`. */
+    asChild?: boolean;
+};
+/**
+ * Everything `TextInput` accepts, plus the `TextStyle` keys as props (R14).
+ *
+ * `editable` is absent: it is `disabled` under another name, and R8 keeps that off the
+ * public surface — `isDisabled` on the root is what stops the field.
+ */
+type InputFieldProps = Omit<TextInputProps, 'editable'> & Omit<TextStyleProps, keyof TextInputProps>;
+/** `Text`'s own props win over the `TextStyle` keys of the same name (R14). */
+type InputTextProps = TextProps & Omit<TextStyleProps, keyof TextProps> & {
+    children?: ReactNode;
+};
+type InputLabelProps = InputTextProps;
+type InputDescriptionProps = InputTextProps;
+type InputErrorProps = InputTextProps;
+/**
+ * Read off `TextInput`'s own props rather than spelled out: React Native has renamed the
+ * payload of these two more than once, and a hand-written `NativeSyntheticEvent<…>` here
+ * would be a second declaration free to drift from the node that actually fires them.
+ */
+type FieldFocusEvent = Parameters<NonNullable<TextInputProps['onFocus']>>[0];
+type FieldBlurEvent = Parameters<NonNullable<TextInputProps['onBlur']>>[0];
+/**
+ * R5 — resolved styles, not props for a slot to resolve a second time. Each entry is the
+ * cached `StyleSheet` reference with the uncached tint pass layered over it, so a slot
+ * merges its own `style` on top and does no work of its own.
+ */
+type InputContextValue = {
+    labelStyle: StyleProp<TextStyle>;
+    fieldStyle: StyleProp<TextStyle>;
+    /** Layered *over* `fieldStyle` by `Input.TextArea`: only what a multiline field adds. */
+    textAreaStyle: StyleProp<TextStyle>;
+    /**
+     * Values, not a style: `rows` is a raw number, so the height it implies is arithmetic
+     * the slot does — and these are the two measurements it needs, flattened once here
+     * rather than in every text area on the screen.
+     */
+    textArea: {
+        lineHeight: number;
+        paddingVertical: number;
+    };
+    descriptionStyle: StyleProp<TextStyle>;
+    errorStyle: StyleProp<TextStyle>;
+    /**
+     * The two decorators of an `InputGroup`, already pinned to their edge and inset by the
+     * field's own padding. They are resolved here, on the root, because the size that
+     * decides that padding is the root's — the group itself adds no axis of its own.
+     */
+    prefixStyle: StyleProp<ViewStyle>;
+    suffixStyle: StyleProp<ViewStyle>;
+    /**
+     * Values, not a style: an icon is a third party's component, and `size` and `color` are
+     * props it takes rather than a style it accepts. Flattened once here, the way the `Chip`
+     * and the `Alert` publish theirs.
+     */
+    icon: {
+        size: number | undefined;
+        color: string | undefined;
+    };
+    /**
+     * A value and not a style: `placeholderTextColor` is a `TextInput` prop, so the root
+     * flattens its placeholder slot once here rather than in the field.
+     */
+    placeholderTextColor?: string;
+    /**
+     * The focus state lives on the **root**, because the root's recipe resolves on it (R5)
+     * and it needs the value before it renders — but the node that hears the event is
+     * `Input.Field`, three levels down. These are how it reports back. Their identity is
+     * stable, so publishing them costs no re-render of a memoized slot.
+     */
+    onFieldFocus: (event: FieldFocusEvent) => void;
+    onFieldBlur: (event: FieldBlurEvent) => void;
+    /**
+     * The id the label carries and the field points at, so a screen reader reads "Courriel,
+     * champ de saisie" rather than just the placeholder.
+     */
+    labelId: string;
+    descriptionId: string;
+    isDisabled: boolean;
+    isInvalid: boolean;
+};
+
+export type { InputFieldProps as I, InputProps as a, InputContextValue as b, InputDescriptionProps as c, InputErrorProps as d, InputLabelPlacement as e, InputLabelProps as f, InputSize as g, InputSlot as h, InputVariant as i };