@webority/mobile-ui 0.0.0-stage → 0.0.33

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

@@ -0,0 +1,59 @@
+import type React from 'react';
+import type { View as RNView } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils';
+export interface TourStep {
+    /**
+     * The view the step highlights, measured when the step opens. Give it
+     * `collapsable={false}` so Android keeps it in the native tree. A step whose
+     * view is not mounted or not on screen is skipped.
+     */
+    target: React.RefObject<RNView | null>;
+    title?: string;
+    description: string;
+}
+/**
+ * Where the app remembers that a person has seen a tour: one record per tour
+ * id for the signed-in person, so one server record can serve the web tour too.
+ */
+export interface TourSeenStore {
+    isSeen: (tourId: string) => Promise<boolean>;
+    markSeen: (tourId: string) => Promise<void>;
+}
+/**
+ * - `finished`: the person stepped past the last step. Marked seen.
+ * - `skipped`: Skip, or Android back. Marked seen.
+ * - `alreadySeen`: the seen store says this tour was seen, so nothing showed.
+ * - `noTargets`: no step's view was on screen, so nothing showed. Not marked seen.
+ */
+export type TourCloseReason = 'finished' | 'skipped' | 'alreadySeen' | 'noTargets';
+export interface TourLabels {
+    back?: string;
+    next?: string;
+    skip?: string;
+    done?: string;
+}
+export interface TourProps {
+    /** Names the tour in the seen store. */
+    tourId: string;
+    steps: TourStep[];
+    /** Set true to run the tour; set it back to false from `onClose`. */
+    visible: boolean;
+    onClose: (reason: TourCloseReason) => void;
+    /** Consulted before showing and written when the tour finishes or is skipped. */
+    seenStore?: TourSeenStore;
+    labels?: TourLabels;
+    haptic?: HapticType | false;
+    testID?: string;
+}
+/**
+ * Walks through product steps one highlighted view at a time: the screen is
+ * dimmed except around the step's view, with a card holding the step text and
+ * Back, Next and Skip. Built on `Modal`; the card sits on the side of the view
+ * with more room, as `Tooltip` places its bubble, using the same tooltip gap and
+ * screen-padding tokens. Motion comes from `theme.motion`, which collapses under
+ * the OS Reduce Motion setting.
+ */
+declare const Tour: React.FC<TourProps>;
+export { Tour };
+export default Tour;
+//# sourceMappingURL=Tour.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { TourCloseReason, TourLabels, TourProps, TourSeenStore, TourStep } from './Tour';
+export { default, Tour } from './Tour';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,47 @@
+/**
+ * ZoomableImage — a standalone pinch-to-zoom / pan / double-tap-to-zoom
+ * wrapper for a single piece of content (typically one `<Image>`).
+ *
+ * Reuses the same Reanimated 3 gesture composition `ImageGallery`'s internal
+ * lightbox slide uses (pinch clamped and rubber-banded at its limits, pan
+ * gated to only engage once zoomed in, double-tap toggling between baseline
+ * and `doubleTapScale`), stripped of the carousel-slide concerns that
+ * component needs and this one does not — there is no `index`/`total`/
+ * `active` because a standalone image is always the one being viewed.
+ *
+ * USAGE:
+ *
+ * <ZoomableImage>
+ *   <Image source={{ uri }} style={styles.image} resizeMode="contain" />
+ * </ZoomableImage>
+ *
+ * Takes `children` rather than a `source`/`uri` prop: every real consumer of
+ * this pattern in the fleet wraps an already-authenticated image component
+ * (headers, caching, its own loading state) rather than a bare `<Image>`, so
+ * a `source` prop would force re-implementing that per app. Wrapping keeps
+ * this component ignorant of how the image is fetched.
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export interface ZoomableImageProps {
+    /** The content to pinch-zoom, pan, and double-tap-zoom — typically a single `<Image>`. */
+    children: React.ReactNode;
+    /** Upper bound on pinch and double-tap zoom. Default 4. */
+    maxScale?: number;
+    /** Lower bound on pinch zoom — the resting scale a pinch springs back to. Default 1. */
+    minScale?: number;
+    /** Scale a double tap zooms to; a second double tap returns to baseline. Default 2. */
+    doubleTapScale?: number;
+    /** Blocks pinch/pan/double-tap and smoothly resets any active zoom back to baseline. Default false. */
+    disabled?: boolean;
+    /** Haptic feedback on double-tap-to-zoom. Pass false to disable; pass a HapticType to override. */
+    haptic?: HapticType | false;
+    /** Style for the outer wrapping view. */
+    style?: StyleProp<ViewStyle>;
+    accessibilityLabel?: string;
+    testID?: string;
+}
+export declare const ZoomableImage: React.FC<ZoomableImageProps>;
+export default ZoomableImage;
+//# sourceMappingURL=ZoomableImage.d.ts.map

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

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

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

@@ -0,0 +1,153 @@
+export type { AccordionGroupProps, AccordionProps, AccordionVariant } from './Accordion';
+export { Accordion, AccordionGroup } from './Accordion';
+export type { AmountSliderProps, AmountSliderUnits } from './AmountSlider';
+export { AmountSlider } from './AmountSlider';
+export type { AnimatePresenceProps, PresencePreset } from './AnimatePresence';
+export { AnimatePresence } from './AnimatePresence';
+export type { AppBarAction, AppBarProps, AppBarVariant } from './AppBar';
+export { AppBar } from './AppBar';
+export type { AsyncBlockProps } from './AsyncBlock';
+export { AsyncBlock } from './AsyncBlock';
+export type { AuthedImageCacheMeta, AuthedImageProps } from './AuthedImage';
+export { AuthedImage, authedImageCacheStats, clearAuthedImageCache, getAuthedImageCacheLimit, setAuthedImageCacheLimit } from './AuthedImage';
+export type { AutocompleteProps } from './Autocomplete';
+export { Autocomplete } from './Autocomplete';
+export type { AvatarGroupOverflowVariant, AvatarGroupProps, AvatarGroupSpacing, AvatarImageProps, AvatarProps, AvatarShape, AvatarSize, AvatarStatus, AvatarTone } from './Avatar';
+export { Avatar, AvatarGroup } from './Avatar';
+export type { BadgeAnchor, BadgeProps, BadgeTone, BadgeVariant } from './Badge';
+export { Badge } from './Badge';
+export type { BannerAction, BannerProps, BannerVariant } from './Banner';
+export { Banner } from './Banner';
+export type { BottomNavigationCenterAction, BottomNavigationElevation, BottomNavigationIndicatorPosition, BottomNavigationIndicatorRadius, BottomNavigationProps, BottomNavigationRadius, BottomNavigationVariant, TabBadge, TabConfig, TabIcon, TabIconProps } from './BottomNavigation';
+export { BottomNavigation } from './BottomNavigation';
+export type { BottomSheetContextValue, BottomSheetProps, BottomSheetRef } from './BottomSheet';
+export { BottomSheet, useBottomSheet } from './BottomSheet';
+export type { BoxProps, RowProps, SpacerProps, StackProps } from './Box';
+export { Box, Row, Spacer, Stack } from './Box';
+export type { ButtonProps, ButtonSize, ButtonTone, ButtonVariant } from './Button';
+export { Button } from './Button';
+export type { CardElevation, CardPadding, CardProps, CardRadius, CardVariant } from './Card';
+export { Card } from './Card';
+export type { CarouselProps, CarouselRef, PaginationStyle } from './Carousel';
+export { Carousel } from './Carousel';
+export type { CheckboxProps, CheckboxSize, CheckboxTone } from './Checkbox';
+export { Checkbox } from './Checkbox';
+export type { ChipProps, ChipSize, ChipTone, ChipVariant } from './Chip';
+export { Chip } from './Chip';
+export type { ChoiceGroupDirection, ChoiceGroupIndicatorPosition, ChoiceGroupProps, ChoiceGroupSize, ChoiceGroupVariant, ChoiceOption, ChoiceOptionState } from './ChoiceGroup';
+export { ChoiceGroup } from './ChoiceGroup';
+export type { ConfettiHandle, ConfettiOrigin, ConfettiPhysics, ConfettiPreset, ConfettiProps, ConfettiShape, ConfettiSpeed } from './Confetti';
+export { Confetti } from './Confetti';
+export type { DatePickerMode, DatePickerProps } from './DatePicker';
+export { DatePicker } from './DatePicker';
+export type { DateRange, DateRangePickerProps } from './DateRangePicker';
+export { DateRangePicker } from './DateRangePicker';
+export type { DescriptionItem, DescriptionsProps, DescriptionsSize } from './Descriptions';
+export { Descriptions } from './Descriptions';
+export type { DialogAction, DialogProps, DialogVariant } from './Dialog';
+export { Dialog } from './Dialog';
+export type { DividerOrientation, DividerProps, DividerSpacing } from './Divider';
+export { Divider } from './Divider';
+export type { DrawerProps, DrawerRef, DrawerSide } from './Drawer';
+export { Drawer } from './Drawer';
+export type { EmptyStateAction, EmptyStateProps, EmptyStateSize } from './EmptyState';
+export { EmptyState } from './EmptyState';
+export type { ErrorBoundaryInfo, ErrorBoundaryProps } from './ErrorBoundary';
+export { ErrorBoundary, useErrorHandler, withErrorBoundary } from './ErrorBoundary';
+export type { FilePickerFile, FilePickerFileState, FilePickerFileStatus, FilePickerLabels, FilePickerProps, FilePickerRef, FilePickerSource, FilePickerTriggerState, FilePickerVariant, PickedFileInput } from './FilePicker';
+export { FilePicker, formatFileSize } from './FilePicker';
+export type { FileViewerProps, FileViewerSource } from './FileViewer';
+export { FileViewer } from './FileViewer';
+export type { FloatingActionButtonGroupAction, FloatingActionButtonGroupProps, FloatingActionButtonPosition, FloatingActionButtonProps, FloatingActionButtonSize, FloatingActionButtonTone } from './FloatingActionButton';
+export { FloatingActionButton, FloatingActionButtonGroup } from './FloatingActionButton';
+export type { ForceUpdateDialogProps } from './ForceUpdateDialog';
+export { ForceUpdateDialog } from './ForceUpdateDialog';
+export type { FormFieldLayout, FormFieldProps } from './FormField';
+export { FormField } from './FormField';
+export type { IconButtonProps, IconButtonShape, IconButtonSize, IconButtonTone, IconButtonVariant } from './IconButton';
+export { IconButton } from './IconButton';
+export type { GalleryImage, ImageGalleryProps } from './ImageGallery';
+export { ImageGallery } from './ImageGallery';
+export type { InlineSelectProps, InlineSelectSize } from './InlineSelect';
+export { InlineSelect } from './InlineSelect';
+export type { InputAction, InputProps, InputSize, InputSlotIcon, InputSlotState, InputVariant } from './Input';
+export { Input } from './Input';
+export type { KeyboardAwareScrollViewProps } from './KeyboardAwareScrollView';
+export { KeyboardAwareScrollView } from './KeyboardAwareScrollView';
+export type { KeyboardToolbarProps } from './KeyboardToolbar';
+export { KeyboardToolbar } from './KeyboardToolbar';
+export type { ListItemProps, ListItemSize } from './ListItem';
+export { ListItem } from './ListItem';
+export type { LoaderOverlayProps } from './LoaderOverlay';
+export { LoaderOverlay, loader, useLoader } from './LoaderOverlay';
+export type { MarkdownProps } from './Markdown';
+export { Markdown } from './Markdown';
+export type { ModalPresentation, ModalProps } from './Modal';
+export { MODAL_DISMISS_GRACE_MS, Modal } from './Modal';
+export type { NumberInputProps, NumberInputRef, NumberInputSize, NumberInputVariant } from './NumberInput';
+export { NumberInput } from './NumberInput';
+export type { OTPInputProps, OTPInputRef, OTPInputSize } from './OTPInput';
+export { OTPInput } from './OTPInput';
+export type { CallingCode, PhoneNumberInputLabelMode, PhoneNumberInputProps, PhoneNumberInputRef, PhoneNumberValidation, PhoneNumberValue } from './PhoneNumberInput';
+export { DEFAULT_CALLING_CODES, formatE164, PhoneNumberInput } from './PhoneNumberInput';
+export type { PickerTriggerProps, PickerTriggerSize, PickerTriggerVariant } from './PickerTrigger';
+export { PickerTrigger } from './PickerTrigger';
+export type { ProfileCompletionAvatarTone, ProfileCompletionProps, ProfileCompletionRingVariant } from './ProfileCompletion';
+export { ProfileCompletion } from './ProfileCompletion';
+export type { ProfilePickerLabels, ProfilePickerLayout, ProfilePickerProps, ProfilePickerShape, ProfilePickerSize, ProfilePickerTone, ProfilePickerVariant } from './ProfilePicker';
+export { ProfilePicker } from './ProfilePicker';
+export type { ProgressBarProps, ProgressBarSegment, ProgressBarTone } from './ProgressBar';
+export { ProgressBar } from './ProgressBar';
+export type { ProgressRingProps, ProgressRingTone } from './ProgressRing';
+export { ProgressRing } from './ProgressRing';
+export type { RadioDotProps, RadioGroupProps, RadioProps, RadioSize, RadioTone, RadioValue } from './Radio';
+export { Radio, RadioDot, RadioGroup } from './Radio';
+export type { RatingProps, RatingSize, RatingTone } from './Rating';
+export { Rating } from './Rating';
+export type { RepeaterProps, RepeaterRenderArgs } from './Repeater';
+export { Repeater } from './Repeater';
+export type { BlockMarkdownAction, EditorSelection, EditorState, InlineMarkdownAction, MarkdownAction, RichTextEditorProps } from './RichTextEditor';
+export { applyMarkdownAction, RichTextEditor } from './RichTextEditor';
+export type { SearchBarProps, SearchBarSize, SearchBarVariant } from './SearchBar';
+export { SearchBar } from './SearchBar';
+export type { SegmentedControlProps, SegmentedControlRadius, SegmentedControlSize, SegmentedControlTone, SegmentedControlVariant, SegmentIcon, SegmentIconState, SegmentItem, SegmentValue } from './SegmentedControl';
+export { SegmentedControl } from './SegmentedControl';
+export type { SelectOption, SelectProps, SelectSize, SelectValue } from './Select';
+export { Select } from './Select';
+export type { SkeletonCircleProps, SkeletonClockProviderProps, SkeletonClockValue, SkeletonColors, SkeletonContentProps, SkeletonListProps, SkeletonProps, SkeletonProviderDefaults, SkeletonProviderProps, SkeletonRadius, SkeletonShape, SkeletonSkipProps, SkeletonSpeed, SkeletonStaticOf, SkeletonTextProps, SkeletonVariant, SkeletonWidth } from './Skeleton';
+export { Skeleton, SkeletonCircle, SkeletonClockProvider, SkeletonContent, SkeletonList, SkeletonProvider, SkeletonSkip, SkeletonText, useReduceMotion, useSkeletonClock, useSkeletonDefaults } from './Skeleton';
+export type { SliderProps, SliderSize, SliderTone, SliderVariant } from './Slider';
+export { Slider } from './Slider';
+export type { SliderFieldProps } from './SliderField';
+export { SliderField } from './SliderField';
+export type { SlideToConfirmProps, SlideToConfirmSize, SlideToConfirmTone } from './SlideToConfirm';
+export { SlideToConfirm } from './SlideToConfirm';
+export type { SpinnerProps, SpinnerSize, SpinnerVariant } from './Spinner';
+export { Spinner } from './Spinner';
+export type { StatusBadgeProps, StatusBadgeSize, StatusBadgeTone, StatusBadgeVariant } from './StatusBadge';
+export { StatusBadge } from './StatusBadge';
+export type { StepperPressMode, StepperProps, StepperStep, StepperTone, StepperVariant } from './Stepper';
+export { Stepper } from './Stepper';
+export type { SwipeableAction, SwipeableProps, SwipeableTone } from './Swipeable';
+export { Swipeable } from './Swipeable';
+export type { SwitchProps, SwitchSize, SwitchTone } from './Switch';
+export { Switch } from './Switch';
+export type { TabItem, TabItemIcon, TabItemIconState, TabsAlign, TabsProps, TabsRadius, TabsSize, TabsVariant } from './Tabs';
+export { Tabs } from './Tabs';
+export type { TagInputProps } from './TagInput';
+export { TagInput } from './TagInput';
+export type { TextColor, TextProps, TextVariant } from './Text';
+export { Text } from './Text';
+export type { TimelineItem, TimelineOrientation, TimelineProps, TimelineStatus, TimelineVariant } from './Timeline';
+export { Timeline } from './Timeline';
+export type { MinuteStep, Period, TimeFormat, TimePickerProps, TimeValue } from './TimePicker';
+export { TimePicker } from './TimePicker';
+export type { ToastApi, ToastOptions, ToastPosition, ToastProps, ToastProviderProps, ToastVariant } from './Toast';
+export { Toast, ToastProvider, toast, useToast } from './Toast';
+export type { TooltipPlacement, TooltipProps, TooltipTrigger } from './Tooltip';
+export { Tooltip } from './Tooltip';
+export type { TourCloseReason, TourLabels, TourProps, TourSeenStore, TourStep } from './Tour';
+export { Tour } from './Tour';
+export type { ZoomableImageProps } from './ZoomableImage';
+export { ZoomableImage } from './ZoomableImage';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { FormApi, FormValues } from './types';
+export interface FormProps<Values extends FormValues = FormValues> {
+    /** The object returned by {@link useForm}. */
+    form: FormApi<Values>;
+    children: React.ReactNode;
+}
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ *
+ * Generic in `Values`, and it has to be. `FormApi` is invariant in `Values`
+ * because `setValues` accepts a `(prev: Values) => Values`, so a
+ * `FormApi<MyValues>` is not assignable to a `FormApi<FormValues>`. While the
+ * prop was declared at the base type, `useForm<MyValues>()` could not be handed
+ * to `<Form>` by ANY consumer, which is most of the reason to type a form at
+ * all. Untyped callers are unaffected: `Values` defaults to `FormValues`.
+ */
+export declare const Form: {
+    <Values extends FormValues = FormValues>({ form, children }: FormProps<Values>): React.ReactElement;
+    displayName: string;
+};
+/** 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,12 @@
+export type { FormProps } from './FormContext';
+export { Form, useFormContext, useOptionalFormContext } from './FormContext';
+export { deletePath, getPath, setPath } from './path';
+import * as rules from './rules';
+export type { FieldInputProps, FieldRules, FieldState, FocusableNode, FormApi, FormConfig, FormErrors, FormTouched, FormValidateFn, FormValues, SubmitHelpers, ValidateOn, ValidationResult, ValidationRule, ValidationSchema } from './types';
+export type { FieldArrayApi } from './useField';
+export { useField, useFieldArray } from './useField';
+export { useForm } from './useForm';
+export type { FormCompletion, UseFormCompletionOptions } from './useFormCompletion';
+export { isFieldFilled, useFormCompletion } from './useFormCompletion';
+export { rules };
+//# 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,37 @@
+/**
+ * Validation rule presets — the dependency-free replacement for Yup chains.
+ * Each factory returns a {@link ValidationRule}. Rules built on the project's
+ * `validators` module skip empty values (so `required()` owns emptiness and you
+ * don't get duplicate errors), and accept an optional custom message.
+ */
+import type { PasswordRules } from '@webority/mobile-core';
+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: <V = unknown>(fn: (value: V, allValues: FormValues) => boolean | string | Promise<boolean | string>, message?: string) => ValidationRule<V>;
+//# sourceMappingURL=rules.d.ts.map

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

@@ -0,0 +1,94 @@
+export type FormValues = Record<string, unknown>;
+export type FormErrors = Record<string, string | undefined>;
+export type FormTouched = Record<string, boolean>;
+export type ValidationResult = string | undefined | null | false;
+/**
+ * A single validation rule. Receives the field value and the whole values
+ * object (so cross-field rules work). Return an error message string when
+ * invalid, or any falsy value when valid. May be async — return a Promise for
+ * server-side checks ("is this email already registered?").
+ */
+export type ValidationRule<V = any, Values extends FormValues = FormValues> = (value: V, allValues: Values) => ValidationResult | Promise<ValidationResult>;
+export type FieldRules<V = any, Values extends FormValues = FormValues> = ValidationRule<V, Values> | ValidationRule<V, Values>[];
+/** Per-field rule map keyed by field path (e.g. `{ email: [rules.required(), rules.email()] }`). */
+export type ValidationSchema<Values extends FormValues = FormValues> = Record<string, FieldRules<any, Values>>;
+/** Form-level validate function returning an errors map keyed by field path. */
+export type FormValidateFn<Values extends FormValues = FormValues> = (values: Values) => FormErrors | Promise<FormErrors>;
+export type ValidateOn = 'change' | 'blur' | 'submit';
+export interface SubmitHelpers<Values extends FormValues = FormValues> {
+    setErrors: (errors: FormErrors) => void;
+    setFieldError: (name: string, error?: string) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    setSubmitting: (submitting: boolean) => void;
+}
+export interface FormConfig<Values extends FormValues = FormValues> {
+    initialValues: Values;
+    /** Either a per-field rule map or a single form-level validate function. */
+    validate?: ValidationSchema<Values> | FormValidateFn<Values>;
+    /** When validation first runs for a field. Library default: 'submit'. */
+    validateOn?: ValidateOn;
+    /** After a field has surfaced an error once, how it re-validates. Library default: 'change'. */
+    revalidateOn?: 'change' | 'blur';
+    onSubmit: (values: Values, helpers: SubmitHelpers<Values>) => void | Promise<void>;
+    /** Re-initialise values when `initialValues` changes (e.g. async-loaded edit form). Default: false. */
+    enableReinitialize?: boolean;
+}
+export interface FieldState<V = unknown> {
+    value: V;
+    /** Error the UI should show (gated by touched / submit). */
+    error: string | undefined;
+    /** Error regardless of touched — useful for `isValid`-style logic. */
+    rawError: string | undefined;
+    touched: boolean;
+    dirty: boolean;
+}
+/** Props an input needs to bind to a form field. Covers text and non-text controls. */
+export interface FieldInputProps<V = unknown> {
+    name: string;
+    value: V;
+    error: string | undefined;
+    touched: boolean;
+    /** Generic change handler (Select/Switch/DatePicker/Slider…). */
+    onChange: (value: V) => void;
+    /** Text-input alias of `onChange` (TextInput's `onChangeText`). */
+    onChangeText: (text: string) => void;
+    onBlur: () => void;
+    /** Marks this field as the focused one (drives KeyboardToolbar next/prev). */
+    onFocus: () => void;
+    setValue: (value: V, shouldValidate?: boolean) => void;
+}
+export interface FocusableNode {
+    focus?: () => void;
+    measureInWindow?: (cb: (x: number, y: number, w: number, h: number) => void) => void;
+}
+export interface FormApi<Values extends FormValues = FormValues> {
+    values: Values;
+    /** Touched/submit-gated errors — what the UI shows. */
+    errors: FormErrors;
+    /** Every current error regardless of touched. */
+    rawErrors: FormErrors;
+    touched: FormTouched;
+    dirty: boolean;
+    isValid: boolean;
+    isSubmitting: boolean;
+    isValidating: boolean;
+    submitCount: number;
+    setFieldValue: (name: string, value: unknown, shouldValidate?: boolean) => void;
+    setFieldTouched: (name: string, touched?: boolean, shouldValidate?: boolean) => void;
+    setFieldError: (name: string, error?: string) => void;
+    setValues: (next: Partial<Values> | ((prev: Values) => Values), shouldValidate?: boolean) => void;
+    setErrors: (errors: FormErrors) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    validate: () => Promise<FormErrors>;
+    validateField: (name: string) => Promise<string | undefined>;
+    submit: () => void;
+    getFieldState: (name: string) => FieldState;
+    getFieldProps: (name: string) => FieldInputProps;
+    handleBlur: (name: string) => void;
+    /** Move focus to the next / previous registered field (used by KeyboardToolbar). */
+    focusNext: () => void;
+    focusPrev: () => void;
+    /** Registers a focusable node so a failed submit can focus the first error. */
+    registerField: (name: string, node: FocusableNode | null) => void;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { FieldInputProps } from './types';
+/**
+ * Bind a single field by name. Returns everything an input needs; pick the
+ * handler your control uses:
+ *   const email = useField('email');
+ *   <Input value={email.value} onChangeText={email.onChangeText} onBlur={email.onBlur} error={email.error} />
+ *   <Select value={country.value} onChange={country.onChange} error={country.error} />
+ *   <Switch value={!!agree.value} onChange={agree.onChange} />
+ */
+export declare function useField<V = unknown>(name: string): FieldInputProps<V>;
+export interface FieldArrayApi<T = unknown> {
+    /** Current array value (empty array when unset). */
+    fields: T[];
+    length: number;
+    push: (item: T) => void;
+    remove: (index: number) => void;
+    insert: (index: number, item: T) => void;
+    move: (from: number, to: number) => void;
+    replace: (index: number, item: T) => void;
+}
+/**
+ * Manage a repeating list field (phone numbers, line items, etc.) by name.
+ * Each helper writes the whole array back through the form so validation and
+ * dirty-tracking stay correct.
+ */
+export declare function useFieldArray<T = unknown>(name: string): FieldArrayApi<T>;
+//# sourceMappingURL=useField.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { FormApi, FormConfig, FormValues } from './types';
+/**
+ * Dependency-free form engine. Tracks values/errors/touched/dirty, runs
+ * synchronous and async validation (per-field rule maps or a form-level
+ * function), gates error display behind touched/submit, and on a failed submit
+ * focuses the first errored field. The returned object is rebuilt every render
+ * so `<Form>` consumers re-render on state changes.
+ */
+export declare function useForm<Values extends FormValues = FormValues>(config: FormConfig<Values>): FormApi<Values>;
+//# sourceMappingURL=useForm.d.ts.map

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

@@ -0,0 +1,45 @@
+export interface FormCompletion {
+    /** Fraction of the counted fields that hold a value, 0 to 1. `0` when no field is counted. */
+    progress: number;
+    /** The same share as a percentage, 0 to 100: what ProfileCompletion's `progress` takes. */
+    percent: number;
+    /** How many of the counted fields hold a value. */
+    filled: number;
+    /** How many fields are counted. */
+    total: number;
+    /** The counted fields that hold no value yet, in the order given. */
+    missing: string[];
+}
+export interface UseFormCompletionOptions {
+    /**
+     * Decide whether a field holds a value. Overrides the default rule for
+     * every field; return `true` to count the field as filled.
+     */
+    isFilled?: (value: unknown, name: string) => boolean;
+}
+/**
+ * The default rule for "this field holds a value": everything counts except
+ * `undefined`, `null`, `NaN`, a string that is empty or only whitespace, an
+ * empty array, and `false`. `false` is empty on purpose: a field is listed
+ * because completing the profile needs it, and for a switch or a checkbox
+ * that means it must be on ("accept the terms"). An optional toggle should
+ * not be listed. `0` is a value.
+ */
+export declare const isFieldFilled: (value: unknown) => boolean;
+/**
+ * How much of a form is filled in: `progress` as a fraction for a
+ * ProgressRing, `percent` for a ProfileCompletion header. Give it the form's `values` and the
+ * names of the fields that count; nested names (`address.city`, `phones[0]`)
+ * resolve the way the form engine's own paths do.
+ *
+ * ```tsx
+ * const form = useForm({ initialValues });
+ * const { percent } = useFormCompletion(form.values, ['name', 'email', 'gstin']);
+ * <ProfileCompletion progress={percent} … />
+ * ```
+ *
+ * Memoised on the values object and on the field list's contents, so a
+ * literal array written in render does not recompute on every render.
+ */
+export declare const useFormCompletion: (values: unknown, fields: readonly string[], options?: UseFormCompletionOptions) => FormCompletion;
+//# sourceMappingURL=useFormCompletion.d.ts.map

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

@@ -0,0 +1,12 @@
+export type { UseControllableStateOptions } from './useControllableState';
+export { useControllableState } from './useControllableState';
+export { useDebounce } from './useDebounce';
+export type { DragToDismissController, SheetNativeGesture, SheetPanGesture, UseDragToDismissOptions, UseDragToDismissResult } from './useDragToDismiss';
+export { createDragToDismissController, DRAG_DISMISS_DISTANCE, DRAG_DISMISS_VELOCITY, useDragToDismiss } from './useDragToDismiss';
+export { FLICK_TOLERANCE, useFlickGuard } from './useFlickGuard';
+export type { PressAnimationPreset, UsePressAnimationOptions, UsePressAnimationResult } from './usePressAnimation';
+export { PRESS_ANIMATION_PRESETS, usePressAnimation } from './usePressAnimation';
+export { useReducedMotion } from './useReducedMotion';
+export type { UseToggleResult } from './useToggle';
+export { useToggle } from './useToggle';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/hooks/useControllableState.d.ts

@@ -0,0 +1,17 @@
+export interface UseControllableStateOptions<T> {
+    /** Controlled value. When `undefined`, the hook manages state internally. */
+    value?: T;
+    /** Initial value used in uncontrolled mode. */
+    defaultValue: T;
+    /** Called on every change (both modes). */
+    onChange?: (value: T) => void;
+}
+/**
+ * Bridges controlled and uncontrolled usage for a value+onChange pair. When
+ * `value` is provided the component is controlled (the hook just forwards it
+ * and calls `onChange`); otherwise the hook owns the state, seeded from
+ * `defaultValue`. The controlled/uncontrolled decision is locked on first
+ * render so a component never flips modes mid-life.
+ */
+export declare function useControllableState<T>({ value, defaultValue, onChange }: UseControllableStateOptions<T>): [T, (next: T) => void];
+//# sourceMappingURL=useControllableState.d.ts.map

package/lib/typescript/commonjs/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+export declare const useDebounce: <T>(value: T, delay?: number) => T;
+//# sourceMappingURL=useDebounce.d.ts.map