@webority-technologies/mobile 0.0.22 → 0.0.23

package/lib/module/hooks/useReducedMotion.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { AccessibilityInfo } from 'react-native';
+
+/**
+ * Tracks the OS "Reduce Motion" accessibility setting. The library's
+ * ThemeProvider uses this to collapse `theme.motion` (durations → 0, springs →
+ * near-instant) so animations don't trigger vestibular discomfort; consumers
+ * can also read it directly to swap an animated path for a static one.
+ */
+export const useReducedMotion = () => {
+  const [reduced, setReduced] = useState(false);
+  useEffect(() => {
+    let mounted = true;
+    AccessibilityInfo.isReduceMotionEnabled().then(value => {
+      if (mounted) setReduced(value);
+    });
+    const sub = AccessibilityInfo.addEventListener('reduceMotionChanged', value => setReduced(value));
+    return () => {
+      mounted = false;
+      sub.remove();
+    };
+  }, []);
+  return reduced;
+};
+//# sourceMappingURL=useReducedMotion.js.map

package/lib/module/index.js

@@ -21,13 +21,15 @@ export { VersionCheck, useVersionCheck } from "./versionCheck/index.js";
 // Theme
 export { ThemeProvider, useTheme, useThemeMode, setTheme, setColorMode, getColorMode, getTheme, resetTheme, subscribeTheme, mergeTheme, lightTheme, darkTheme } from "./theme/index.js";
 // Hooks
-export { useToggle, useDebounce, usePressAnimation } from "./hooks/index.js";
+export { useToggle, useDebounce, usePressAnimation, useReducedMotion, useControllableState } from "./hooks/index.js";
 // Utils
 export { ScreenDimensions, Breakpoints, Responsive, isScreenSize, isTablet, Spacing, Padding, Margin, triggerHaptic, setHapticImplementation, shadowStyle, compressImage } from "./utils/index.js";
 // Formatters
 export { formatDate, formatTime, formatDateTime, formatRelativeTime, formatPhone, normalizePhone, formatCurrency, formatNumber, formatPercent, formatCompactNumber, getInitials } from "./formatters/index.js";
 // Validators
 export { isNonEmpty, isEmail, isIndianMobile, isPhone, isUrl, isNumeric, isInteger, isAlphanumeric, isStrongPassword, isIndianPincode, isPan, isGstin, isAadhaar, isIfsc, isHexColor, isBetween, minLength, maxLength } from "./validators/index.js";
+// Form engine (dependency-free; replaces Formik + Yup)
+export { useForm, useField, useFieldArray, Form, useFormContext, useOptionalFormContext, rules, getPath, setPath, deletePath } from "./form/index.js";
 // Network
 export { useNetworkStatus, getNetworkStatus, addNetworkStatusListener, NetworkStatusBanner } from "./network/index.js";
 // Permissions

package/lib/module/theme/ThemeContext.js

@@ -4,7 +4,30 @@ import React, { createContext, useContext, useEffect, useMemo, useState } from '
 import { Appearance } from 'react-native';
 import { darkTheme, lightTheme } from "./tokens.js";
 import { mergeTheme } from "./merge.js";
+import { useReducedMotion } from "../hooks/useReducedMotion.js";
 import { jsx as _jsx } from "react/jsx-runtime";
+const REDUCED_SPRING = {
+  damping: 100,
+  stiffness: 1000,
+  mass: 1
+};
+// Reduce Motion: collapse timed animations to instant and make springs settle in
+// ~1 frame, so vestibular-sensitive users aren't subjected to slides/scales/bounces.
+const collapseMotion = motion => ({
+  ...motion,
+  duration: {
+    instant: 0,
+    fast: 0,
+    normal: 0,
+    slow: 0,
+    slower: 0
+  },
+  spring: {
+    gentle: REDUCED_SPRING,
+    bouncy: REDUCED_SPRING,
+    snappy: REDUCED_SPRING
+  }
+});
 const defaultValue = {
   theme: lightTheme,
   mode: 'light',
@@ -30,11 +53,16 @@ export const ThemeProvider = ({
     return () => sub.remove();
   }, []);
   const mode = preference === 'system' ? systemMode : preference;
+  const reduceMotion = useReducedMotion();
   const theme = useMemo(() => {
     const base = mode === 'dark' ? darkTheme : lightTheme;
     const overrides = mode === 'dark' ? darkOverrides : lightOverrides;
-    return overrides ? mergeTheme(base, overrides) : base;
-  }, [mode, lightOverrides, darkOverrides]);
+    const merged = overrides ? mergeTheme(base, overrides) : base;
+    return reduceMotion ? {
+      ...merged,
+      motion: collapseMotion(merged.motion)
+    } : merged;
+  }, [mode, lightOverrides, darkOverrides, reduceMotion]);
   const value = useMemo(() => ({
     theme,
     mode,

package/lib/module/theme/tokens.js

@@ -521,6 +521,12 @@ export const lightTheme = {
     warning: '#F59E0B',
     error: '#E5484D',
     info: '#3B82F6',
+    onPrimary: '#FFFFFF',
+    onSecondary: '#0F0F1A',
+    onSuccess: '#FFFFFF',
+    onWarning: '#0F0F1A',
+    onError: '#FFFFFF',
+    onInfo: '#FFFFFF',
     text: {
       primary: '#0F0F1A',
       secondary: '#52525B',
@@ -576,6 +582,12 @@ export const darkTheme = {
     warning: '#FBBF24',
     error: '#F87171',
     info: '#60A5FA',
+    onPrimary: '#0F0F1A',
+    onSecondary: '#FAFAFA',
+    onSuccess: '#0F0F1A',
+    onWarning: '#0F0F1A',
+    onError: '#0F0F1A',
+    onInfo: '#0F0F1A',
     text: {
       primary: '#FAFAFA',
       secondary: '#B4B4BB',

package/lib/typescript/commonjs/components/BottomNavigation/BottomNavigation.d.ts

@@ -20,7 +20,7 @@ export interface TabConfig {
 export interface BottomNavigationProps {
     tabs: TabConfig[];
     activeTab: string;
-    onTabPress: (tabKey: string) => void;
+    onChange: (tabKey: string) => void;
     haptic?: HapticType | false;
     showLabels?: boolean;
     variant?: BottomNavigationVariant;

package/lib/typescript/commonjs/components/Box/Box.d.ts

@@ -0,0 +1,60 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { StyleProp, ViewProps, ViewStyle } from 'react-native';
+import type { ColorPalette, RadiusScale, SpacingScale, Theme } from '../../theme/types';
+export type SpacingToken = keyof SpacingScale;
+export type RadiusToken = keyof RadiusScale;
+export type BackgroundToken = keyof ColorPalette['background'];
+export interface BoxProps extends ViewProps {
+    /** padding (all sides) */
+    p?: SpacingToken;
+    /** paddingHorizontal */
+    px?: SpacingToken;
+    /** paddingVertical */
+    py?: SpacingToken;
+    pt?: SpacingToken;
+    pr?: SpacingToken;
+    pb?: SpacingToken;
+    pl?: SpacingToken;
+    /** margin (all sides) */
+    m?: SpacingToken;
+    mx?: SpacingToken;
+    my?: SpacingToken;
+    mt?: SpacingToken;
+    mr?: SpacingToken;
+    mb?: SpacingToken;
+    ml?: SpacingToken;
+    /** Flexbox gap between children (spacing token). */
+    gap?: SpacingToken;
+    /** Background — a `colors.background.*` token or a raw colour string. */
+    bg?: BackgroundToken | (string & {});
+    radius?: RadiusToken;
+    /** Draw a hairline border in `colors.border.primary`. */
+    border?: boolean;
+    flex?: number;
+    align?: ViewStyle['alignItems'];
+    justify?: ViewStyle['justifyContent'];
+    direction?: ViewStyle['flexDirection'];
+    wrap?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+type LayoutProps = Omit<BoxProps, 'style' | 'children'>;
+export declare const resolveBoxStyle: (theme: Theme, p: LayoutProps) => ViewStyle;
+declare const Box: React.ForwardRefExoticComponent<BoxProps & React.RefAttributes<View>>;
+export type StackProps = Omit<BoxProps, 'direction'>;
+/** Vertical flex container with token spacing between children (default gap `md`). */
+declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<View>>;
+export type RowProps = Omit<BoxProps, 'direction'>;
+/** Horizontal flex container (default `align="center"`, gap `sm`). */
+declare const Row: React.ForwardRefExoticComponent<RowProps & React.RefAttributes<View>>;
+export interface SpacerProps {
+    /** Fixed spacer of this spacing token. Omit for a flexible spacer (`flex: 1`). */
+    size?: SpacingToken;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/** Fixed gap (`size`) or a flexible push (`flex: 1`) between siblings. */
+declare const Spacer: React.FC<SpacerProps>;
+export { Box, Stack, Row, Spacer };
+export default Box;
+//# sourceMappingURL=Box.d.ts.map

package/lib/typescript/commonjs/components/Box/index.d.ts

@@ -0,0 +1,3 @@
+export { Box, Stack, Row, Spacer, resolveBoxStyle } from './Box';
+export type { BoxProps, StackProps, RowProps, SpacerProps } from './Box';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/Button/Button.d.ts

@@ -4,7 +4,7 @@ import type { PressableProps, StyleProp, TextStyle, ViewStyle } from 'react-nati
 import type { GradientDefinition } from '../../theme/types';
 import type { HapticType } from '../../utils/hapticUtils';
 export type ButtonVariant = 'solid' | 'outline' | 'ghost' | 'link';
-export type ButtonTone = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'neutral';
+export type ButtonTone = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'neutral';
 export type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export interface ButtonProps extends Omit<PressableProps, 'style' | 'children'> {
     title?: string;

package/lib/typescript/commonjs/components/Checkbox/Checkbox.d.ts

@@ -5,8 +5,9 @@ import type { HapticType } from '../../utils/hapticUtils';
 export type CheckboxSize = 'sm' | 'md' | 'lg';
 export type CheckboxTone = 'primary' | 'success' | 'warning' | 'error';
 export interface CheckboxProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
-    checked: boolean;
-    onChange: (checked: boolean) => void;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
     indeterminate?: boolean;
     disabled?: boolean;
     label?: string;

package/lib/typescript/commonjs/components/DatePicker/DatePicker.d.ts

@@ -6,21 +6,21 @@ export type WeekStart = 0 | 1 | 6;
 /**
  * DatePicker operates in two modes:
  *
- * 1. **Controlled-modal mode** — pass `visible` (plus `onSelect` / `onClose`)
+ * 1. **Controlled-modal mode** — pass `visible` (plus `onChange` / `onClose`)
  *    and own the open state externally. The component renders only the modal.
  * 2. **Trigger mode** — omit `visible`. The component renders a built-in
  *    PickerTrigger field (label / value / placeholder / chevron / clear /
  *    helper / error / size / variant) and manages its own open state. The
  *    field opens the modal on press and closes it on confirm/cancel.
  *
- * `onSelect` / `onClose` are typed optional to support trigger-only usage
+ * `onChange` / `onClose` are typed optional to support trigger-only usage
  * where the consumer may not need either callback. In controlled-modal mode
  * they remain semantically required.
  */
 export interface DatePickerProps {
     visible?: boolean;
     value?: Date | null;
-    onSelect?: (date: Date) => void;
+    onChange?: (date: Date) => void;
     onClose?: () => void;
     minDate?: Date;
     maxDate?: Date;

package/lib/typescript/commonjs/components/Dialog/Dialog.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
-export type DialogVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
-export type DialogActionTone = 'primary' | 'neutral' | 'danger';
+export type DialogVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
+export type DialogActionTone = 'primary' | 'neutral' | 'error';
 export interface DialogAction {
     label: string;
     onPress: () => void;

package/lib/typescript/commonjs/components/FormField/FormField.d.ts

@@ -1,18 +1,29 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { FieldInputProps } from '../../form/types';
 export type FormFieldLayout = 'stacked' | 'inline';
 export interface FormFieldProps {
     label?: string;
     helperText?: string;
     /**
      * When truthy: helperText is hidden, error is shown in the error colour,
-     * and the container reports `accessibilityState.invalid = true`.
+     * and the container reports the invalid state to assistive tech.
+     * Ignored when `name` connects to a <Form> with an element child (the child
+     * renders its own error then).
      */
     error?: string;
     /** Appends ' *' (in theme.colors.error) to the label. */
     required?: boolean;
-    children: React.ReactNode;
+    /**
+     * Connect this field to the surrounding `<Form>` by name. With an element
+     * child (e.g. `<Input/>`) the field's value/onChangeText/onBlur/error are
+     * injected automatically — best for text inputs. For non-text controls
+     * (Select, Switch, DatePicker…) use the render-prop form:
+     * `<FormField name="x">{(f) => <Select value={f.value} onChange={f.onChange} />}</FormField>`.
+     */
+    name?: string;
+    children: React.ReactNode | ((field: FieldInputProps) => React.ReactNode);
     /** 'stacked' (default): label above input. 'inline': label left, input right. */
     layout?: FormFieldLayout;
     labelStyle?: StyleProp<TextStyle>;

package/lib/typescript/commonjs/components/KeyboardAwareScrollView/KeyboardAwareScrollView.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { ScrollView } from 'react-native';
+import type { ScrollViewProps } from 'react-native';
+export interface KeyboardAwareScrollViewProps extends ScrollViewProps {
+    /** Gap kept between the focused field and the top of the keyboard. Default 24. */
+    extraScrollHeight?: number;
+    /** Disable the keyboard-following behaviour (still a normal ScrollView). Default false. */
+    disabled?: boolean;
+}
+/**
+ * A ScrollView that keeps the focused input visible above the keyboard — no
+ * native dependency. On keyboard show it pads the content by the keyboard
+ * height and scrolls the focused TextInput so its bottom sits `extraScrollHeight`
+ * above the keyboard, but only when it would otherwise be covered (so already-
+ * visible fields don't jump). The classic measure-and-scroll approach, in pure RN.
+ */
+declare const KeyboardAwareScrollView: React.ForwardRefExoticComponent<KeyboardAwareScrollViewProps & React.RefAttributes<ScrollView>>;
+export { KeyboardAwareScrollView };
+export default KeyboardAwareScrollView;
+//# sourceMappingURL=KeyboardAwareScrollView.d.ts.map

package/lib/typescript/commonjs/components/KeyboardAwareScrollView/index.d.ts

@@ -0,0 +1,3 @@
+export { KeyboardAwareScrollView } from './KeyboardAwareScrollView';
+export type { KeyboardAwareScrollViewProps } from './KeyboardAwareScrollView';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/KeyboardToolbar/KeyboardToolbar.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface KeyboardToolbarProps {
+    /** Label for the dismiss button. Default 'Done'. */
+    doneLabel?: string;
+    /** Show the prev/next chevrons. Default: true when prev/next handlers resolve. */
+    showNavigation?: boolean;
+    /** Override the dismiss action. Default: `Keyboard.dismiss()`. */
+    onDone?: () => void;
+    /** Override "next field". Default: the surrounding `<Form>`'s `focusNext`. */
+    onNext?: () => void;
+    /** Override "previous field". Default: the surrounding `<Form>`'s `focusPrev`. */
+    onPrev?: () => void;
+    /** Custom content rendered between the nav chevrons and the Done button. */
+    leading?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * An accessory bar pinned just above the keyboard — pure RN, no native
+ * dependency. Shows a Done (dismiss) button and optional prev/next chevrons
+ * that, inside a `<Form>`, walk the registered field order. Render it at the
+ * screen root (a `flex: 1` ancestor) so its `bottom: keyboardHeight` offset
+ * lands it on top of the keyboard. Renders nothing while the keyboard is hidden.
+ */
+declare const KeyboardToolbar: React.FC<KeyboardToolbarProps>;
+export { KeyboardToolbar };
+export default KeyboardToolbar;
+//# sourceMappingURL=KeyboardToolbar.d.ts.map

package/lib/typescript/commonjs/components/KeyboardToolbar/index.d.ts

@@ -0,0 +1,3 @@
+export { KeyboardToolbar } from './KeyboardToolbar';
+export type { KeyboardToolbarProps } from './KeyboardToolbar';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/NumberInput/NumberInput.d.ts

@@ -8,8 +8,9 @@ export interface NumberInputRef {
     clear: () => void;
 }
 export interface NumberInputProps {
-    value: number;
-    onChange: (value: number) => void;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
     min?: number;
     max?: number;
     step?: number;

package/lib/typescript/commonjs/components/OTPInput/OTPInput.d.ts

@@ -7,8 +7,9 @@ export interface OTPInputRef {
     clear: () => void;
 }
 export interface OTPInputProps {
-    value: string;
-    onChange: (value: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
     onComplete?: (value: string) => void;
     length?: number;
     keyboardType?: 'number-pad' | 'default';

package/lib/typescript/commonjs/components/Radio/Radio.d.ts

@@ -7,7 +7,7 @@ export type RadioTone = 'primary' | 'success' | 'warning' | 'error';
 export type RadioValue = string | number;
 export interface RadioGroupContextValue {
     selectedValue: RadioValue | undefined;
-    onSelect: (value: RadioValue) => void;
+    onChange: (value: RadioValue) => void;
     disabled: boolean;
 }
 export declare const RadioGroupContext: React.Context<RadioGroupContextValue | null>;
@@ -15,7 +15,7 @@ export declare const useRadioGroup: () => RadioGroupContextValue | null;
 export interface RadioProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
     value: RadioValue;
     selected?: boolean;
-    onSelect?: (value: RadioValue) => void;
+    onChange?: (value: RadioValue) => void;
     disabled?: boolean;
     label?: string;
     size?: RadioSize;

package/lib/typescript/commonjs/components/Radio/RadioGroup.d.ts

@@ -2,8 +2,9 @@ import React from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
 import type { RadioValue } from './Radio';
 export interface RadioGroupProps {
-    value: RadioValue;
-    onChange: (value: RadioValue) => void;
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onChange?: (value: RadioValue) => void;
     children: React.ReactNode;
     disabled?: boolean;
     accessibilityLabel?: string;

package/lib/typescript/commonjs/components/SegmentedControl/SegmentedControl.d.ts

@@ -18,8 +18,9 @@ export interface SegmentItem {
 }
 export interface SegmentedControlProps {
     segments: SegmentItem[];
-    value: SegmentValue;
-    onChange: (value: SegmentValue) => void;
+    value?: SegmentValue;
+    defaultValue?: SegmentValue;
+    onChange?: (value: SegmentValue) => void;
     size?: SegmentedControlSize;
     fullWidth?: boolean;
     disabled?: boolean;

package/lib/typescript/commonjs/components/Slider/Slider.d.ts

@@ -29,13 +29,15 @@ interface SliderCommonProps {
 }
 interface SliderSingleProps extends SliderCommonProps {
     range?: false;
-    value: number;
-    onChange: (value: number) => void;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
 }
 interface SliderRangeProps extends SliderCommonProps {
     range: true;
-    value: [number, number];
-    onChange: (value: [number, number]) => void;
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onChange?: (value: [number, number]) => void;
 }
 export type SliderProps = SliderSingleProps | SliderRangeProps;
 declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<View>>;

package/lib/typescript/commonjs/components/Spinner/Spinner.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { View } from 'react-native';
 import type { StyleProp, ViewStyle } from 'react-native';
-export type SpinnerSize = 'small' | 'medium' | 'large';
+export type SpinnerSize = 'sm' | 'md' | 'lg';
 export type SpinnerVariant = 'circular' | 'dots';
 export interface SpinnerProps {
     size?: SpinnerSize;

package/lib/typescript/commonjs/components/Switch/Switch.d.ts

@@ -5,8 +5,9 @@ import type { HapticType } from '../../utils/hapticUtils';
 export type SwitchSize = 'sm' | 'md' | 'lg';
 export type SwitchTone = 'primary' | 'success' | 'warning' | 'error';
 export interface SwitchProps extends Omit<PressableProps, 'style' | 'children' | 'onPress'> {
-    value: boolean;
-    onValueChange: (value: boolean) => void;
+    value?: boolean;
+    defaultValue?: boolean;
+    onChange?: (value: boolean) => void;
     disabled?: boolean;
     size?: SwitchSize;
     tone?: SwitchTone;

package/lib/typescript/commonjs/components/Text/Text.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { Text as RNText } from 'react-native';
+import type { StyleProp, TextProps as RNTextProps, TextStyle } from 'react-native';
+import type { FontWeightKey } from '../../theme';
+import type { TypographyScale } from '../../theme/types';
+export type TextVariant = 'display' | 'h1' | 'h2' | 'h3' | 'title' | 'body' | 'bodySmall' | 'caption' | 'label' | 'overline';
+export type TextColor = 'primary' | 'secondary' | 'tertiary' | 'inverse' | 'disabled' | 'link' | 'success' | 'warning' | 'error' | 'info';
+export interface TextProps extends Omit<RNTextProps, 'style'> {
+    variant?: TextVariant;
+    /** Text role token, semantic tone, or a raw colour string. Defaults per variant. */
+    color?: TextColor | (string & {});
+    /** Override the variant's weight. */
+    weight?: FontWeightKey;
+    /** Override the variant's size — a typography token or a pixel number. */
+    size?: keyof TypographyScale['fontSize'] | number;
+    align?: TextStyle['textAlign'];
+    italic?: boolean;
+    underline?: boolean;
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<RNText>>;
+export { Text };
+export default Text;
+//# sourceMappingURL=Text.d.ts.map

package/lib/typescript/commonjs/components/Text/index.d.ts

@@ -0,0 +1,3 @@
+export { Text } from './Text';
+export type { TextProps, TextVariant, TextColor } from './Text';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/TimePicker/TimePicker.d.ts

@@ -11,19 +11,19 @@ export interface TimeValue {
 /**
  * TimePicker supports two modes:
  *
- * 1. Controlled-modal mode — pass `visible`, `onSelect`, `onClose`. The
+ * 1. Controlled-modal mode — pass `visible`, `onChange`, `onClose`. The
  *    component renders only the modal sheet and the caller owns open/close
  *    state plus its own trigger UI.
  * 2. Trigger mode — omit `visible`. The component renders a PickerTrigger
  *    field (label / value / placeholder / chevron / clear / helper / error)
- *    and manages its own modal open state. `onSelect` is still called on
+ *    and manages its own modal open state. `onChange` is still called on
  *    confirm.
  */
 export interface TimePickerProps {
     /** Controlled-modal visibility. When omitted, the component enters trigger mode. */
     visible?: boolean;
     value?: TimeValue | null;
-    onSelect?: (time: TimeValue) => void;
+    onChange?: (time: TimeValue) => void;
     onClose?: () => void;
     format?: TimeFormat;
     minuteStep?: MinuteStep;

package/lib/typescript/commonjs/components/index.d.ts

@@ -12,6 +12,14 @@ export { BottomSheet, useBottomSheet } from './BottomSheet';
 export type { BottomSheetContextValue, BottomSheetProps, BottomSheetRef } from './BottomSheet';
 export { Button } from './Button';
 export type { ButtonProps, ButtonVariant, ButtonTone, ButtonSize } from './Button';
+export { Box, Stack, Row, Spacer } from './Box';
+export type { BoxProps, StackProps, RowProps, SpacerProps } from './Box';
+export { Text } from './Text';
+export type { TextProps, TextVariant, TextColor } from './Text';
+export { KeyboardAwareScrollView } from './KeyboardAwareScrollView';
+export type { KeyboardAwareScrollViewProps } from './KeyboardAwareScrollView';
+export { KeyboardToolbar } from './KeyboardToolbar';
+export type { KeyboardToolbarProps } from './KeyboardToolbar';
 export { Card } from './Card';
 export type { CardProps, CardVariant, CardElevation, CardPadding, CardRadius } from './Card';
 export { Carousel } from './Carousel';

package/lib/typescript/commonjs/form/FormContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { FormApi, FormValues } from './types';
+export interface FormProps {
+    /** The object returned by {@link useForm}. */
+    form: FormApi<FormValues>;
+    children: React.ReactNode;
+}
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ */
+export declare const Form: React.FC<FormProps>;
+/** Read the surrounding form. Throws if there is no `<Form>` ancestor. */
+export declare function useFormContext<Values extends FormValues = FormValues>(): FormApi<Values>;
+/** Read the surrounding form, or null when there is no `<Form>` ancestor. */
+export declare function useOptionalFormContext(): FormApi<FormValues> | null;
+//# sourceMappingURL=FormContext.d.ts.map

package/lib/typescript/commonjs/form/index.d.ts

@@ -0,0 +1,9 @@
+export { useForm } from './useForm';
+export { useField, useFieldArray } from './useField';
+export type { FieldArrayApi } from './useField';
+export { Form, useFormContext, useOptionalFormContext } from './FormContext';
+export type { FormProps } from './FormContext';
+export { getPath, setPath, deletePath } from './path';
+export * as rules from './rules';
+export type { FormApi, FormConfig, FormValues, FormErrors, FormTouched, FieldState, FieldInputProps, FocusableNode, ValidationRule, ValidationResult, FieldRules, ValidationSchema, FormValidateFn, ValidateOn, SubmitHelpers } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/form/path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Immutable get/set/delete for dot- and bracket-notation field paths
+ * ("address.city", "phones[0]", "items[2].qty"). Lets a single flat `name`
+ * string address nested values and array items, so the form engine can treat
+ * every field uniformly regardless of how deep it lives in the value tree.
+ */
+export declare const getPath: (obj: unknown, path: string) => unknown;
+export declare const setPath: <T>(obj: T, path: string, value: unknown) => T;
+export declare const deletePath: <T>(obj: T, path: string) => T;
+//# sourceMappingURL=path.d.ts.map

package/lib/typescript/commonjs/form/rules.d.ts

@@ -0,0 +1,31 @@
+import type { PasswordRules } from '../validators';
+import type { FormValues, ValidationRule } from './types';
+export declare const required: (message?: string) => ValidationRule;
+export declare const email: (message?: string) => ValidationRule;
+export declare const mobile: (message?: string) => ValidationRule;
+export declare const phone: (message?: string) => ValidationRule;
+export declare const url: (message?: string) => ValidationRule;
+export declare const numeric: (message?: string) => ValidationRule;
+export declare const integer: (message?: string) => ValidationRule;
+export declare const alphanumeric: (message?: string) => ValidationRule;
+export declare const pincode: (message?: string) => ValidationRule;
+export declare const pan: (message?: string) => ValidationRule;
+export declare const gstin: (message?: string) => ValidationRule;
+export declare const aadhaar: (message?: string) => ValidationRule;
+export declare const ifsc: (message?: string) => ValidationRule;
+export declare const minLength: (length: number, message?: string) => ValidationRule;
+export declare const maxLength: (length: number, message?: string) => ValidationRule;
+export declare const min: (n: number, message?: string) => ValidationRule;
+export declare const max: (n: number, message?: string) => ValidationRule;
+export declare const pattern: (regex: RegExp, message?: string) => ValidationRule;
+export declare const oneOf: (allowed: readonly unknown[], message?: string) => ValidationRule;
+/** Cross-field equality (e.g. confirm-password). `otherField` is a field path. */
+export declare const matches: (otherField: string, message?: string) => ValidationRule<unknown, FormValues>;
+export declare const strongPassword: (rules?: PasswordRules, message?: string) => ValidationRule;
+/**
+ * Wrap any custom check. Return `true` (valid), `false` (invalid → default
+ * message), or a string (invalid → that message). Async is supported — return
+ * a Promise of the same.
+ */
+export declare const custom: (fn: (value: any, allValues: FormValues) => boolean | string | Promise<boolean | string>, message?: string) => ValidationRule;
+//# sourceMappingURL=rules.d.ts.map