@webority/mobile-ui 0.0.0-stage → 0.0.34

package/lib/typescript/module/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.js';
+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/module/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/module/form/useField.d.ts

@@ -0,0 +1,27 @@
+import type { FieldInputProps } from './types.js';
+/**
+ * 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/module/form/useForm.d.ts

@@ -0,0 +1,10 @@
+import type { FormApi, FormConfig, FormValues } from './types.js';
+/**
+ * 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/module/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/module/hooks/index.d.ts

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

package/lib/typescript/module/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/module/hooks/useDebounce.d.ts

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

package/lib/typescript/module/hooks/useDragToDismiss.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Drag-to-dismiss for the library's bottom sheets (OptionSheet behind Select,
+ * InlineSelect, PhoneNumberInput and FilePicker; the DatePicker, DateRangePicker
+ * and TimePicker sheets).
+ *
+ * Built on react-native-gesture-handler, the same as BottomSheet: RN's own
+ * PanResponder never wins the touch from a native list on Android, so a sheet
+ * that wraps a FlatList could only be dragged from its handle. Two gestures
+ * come back:
+ *   - `handleGesture` for the grab handle / title row: any downward drag
+ *     there moves the sheet, whatever the content is doing;
+ *   - `sheetGesture` for the sheet itself: a downward drag anywhere moves the
+ *     sheet while `contentAtTop()` says the content cannot scroll up any
+ *     further. Pass the list's own `Gesture.Native()` as `scrollGesture` so
+ *     the two run together: the list scrolls as usual, and once it is at its
+ *     top the same finger pulls the sheet down.
+ *
+ * Release past the distance or velocity threshold slides the sheet the rest
+ * of the way and calls `onDismiss`; a short drag springs back. The sheet's
+ * translation is a plain Animated.Value on the native driver, so the finger
+ * tracking stays off the JS thread once the value is set.
+ *
+ * Every mounting point must sit inside a `GestureHandlerRootView`; a native
+ * `<Modal>` needs its own one inside the modal (BottomSheet does the same).
+ */
+import { Animated } from 'react-native';
+import { Gesture } from 'react-native-gesture-handler';
+import type { Theme } from '../theme/types.js';
+/** The gesture types as the installed gesture-handler builds them; typed off the value so a second copy of the package cannot split them. */
+export type SheetPanGesture = ReturnType<typeof Gesture.Pan>;
+export type SheetNativeGesture = ReturnType<typeof Gesture.Native>;
+/** Release beyond this many px of downward drag dismisses. */
+export declare const DRAG_DISMISS_DISTANCE = 100;
+/** Release above this downward velocity (px/ms) dismisses. */
+export declare const DRAG_DISMISS_VELOCITY = 0.5;
+export interface UseDragToDismissOptions {
+    /** Live drag offset, added to the sheet's translateY (native driver). */
+    drag: Animated.Value;
+    /** How far the sheet must travel to be fully off-screen, px. */
+    travel: number | (() => number);
+    onDismiss: () => void;
+    /** Whether the content under the finger is scrolled to its top. Default: always. */
+    contentAtTop?: () => boolean;
+    /** The scrollable content's `Gesture.Native()`, so the sheet drag runs alongside its scroll. */
+    scrollGesture?: SheetNativeGesture;
+}
+export interface UseDragToDismissResult {
+    /** Wrap the grab handle / title row in a `GestureDetector` with this. */
+    handleGesture: SheetPanGesture;
+    /** Wrap the sheet container in a `GestureDetector` with this. */
+    sheetGesture: SheetPanGesture;
+}
+/** The drag's state machine, free of gesture-handler so it can be unit-tested. */
+export interface DragToDismissController {
+    /** Finger moved `dy` px down from where the drag started (negative ignored). */
+    move: (dy: number) => void;
+    /** Finger lifted after `dy` px at `vy` px/ms: dismiss or spring back. */
+    release: (dy: number, vy: number) => void;
+    /** Something else took the gesture: spring back. */
+    cancel: () => void;
+}
+export declare const createDragToDismissController: ({ drag, travel, onDismiss }: Pick<UseDragToDismissOptions, "drag" | "travel" | "onDismiss">, motion: Theme["motion"]) => DragToDismissController;
+export declare const useDragToDismiss: (options: UseDragToDismissOptions) => UseDragToDismissResult;
+//# sourceMappingURL=useDragToDismiss.d.ts.map

package/lib/typescript/module/hooks/useFlickGuard.d.ts

@@ -0,0 +1,22 @@
+import type { GestureResponderEvent } from 'react-native';
+/**
+ * Distance, in points, a finger may travel between press-in and release and
+ * still count as a tap. Beyond it the touch was a scroll flick.
+ */
+export declare const FLICK_TOLERANCE = 10;
+/**
+ * Tells a tap from a scroll flick that happened to start on a pressable.
+ *
+ * React Native's Pressability ignores move events until it has measured the
+ * pressable's region, and on a very fast flick the touch end reaches
+ * JavaScript before the scroll event that would have ended the press. The
+ * press therefore completes although the finger travelled far, so a flick
+ * over a button in scrolling content fired it (seen on iOS). Pressables
+ * record the touch at press-in and drop a press whose release is more than
+ * {@link FLICK_TOLERANCE} points away.
+ */
+export declare const useFlickGuard: () => {
+    onPressIn: (event: GestureResponderEvent) => void;
+    isFlick: (event: GestureResponderEvent) => boolean;
+};
+//# sourceMappingURL=useFlickGuard.d.ts.map

package/lib/typescript/module/hooks/usePressAnimation.d.ts

@@ -0,0 +1,54 @@
+import type { Animated } from 'react-native';
+/**
+ * Named press feedback. Every preset drives transform or opacity only, so it
+ * runs on the native driver, and reads its timing from `theme.motion`, so
+ * Reduce Motion collapses it with the rest of the library.
+ *
+ * - `scale`: shrinks a touch on press-in, springs back on release. The default.
+ * - `bounce`: shrinks further and comes back on the bouncy spring, overshooting once.
+ * - `fade`: dims on press-in, back to full on release. No geometry change.
+ * - `sink`: moves down two points on press-in, like a key, and springs back up.
+ * - `pulse`: nothing on press-in; a confirmed press swells the control past
+ *   its size and settles. Plays from `press()`, not `pressOut()`, so a
+ *   cancelled touch or a scroll flick does not read as a tap.
+ */
+export type PressAnimationPreset = 'scale' | 'bounce' | 'fade' | 'sink' | 'pulse';
+export declare const PRESS_ANIMATION_PRESETS: readonly PressAnimationPreset[];
+export interface UsePressAnimationOptions {
+    /** Which feedback plays. Default `'scale'`. */
+    preset?: PressAnimationPreset;
+    /**
+     * Press-in scale for the `scale` and `bounce` presets. Defaults to 0.97 for
+     * `scale` and 0.92 for `bounce`; ignored by the other presets.
+     */
+    scaleTo?: number;
+    /** Press-in duration in ms. Default `theme.motion.duration.fast`. */
+    pressDuration?: number;
+    enabled?: boolean;
+}
+export interface UsePressAnimationResult {
+    scale: Animated.Value;
+    opacity: Animated.Value;
+    translateY: Animated.Value;
+    /**
+     * The three values composed for an `Animated.View`. Callers that only ever
+     * used `scale` keep working; new callers spread this and get every preset.
+     */
+    style: {
+        transform: [{
+            scale: Animated.Value;
+        }, {
+            translateY: Animated.Value;
+        }];
+        opacity: Animated.Value;
+    };
+    pressIn: () => void;
+    pressOut: () => void;
+    /**
+     * The press counted (it was not disabled, cancelled or a flick). Only the
+     * `pulse` preset plays here; the others are already back at rest.
+     */
+    press: () => void;
+}
+export declare const usePressAnimation: ({ preset, scaleTo, pressDuration, enabled }?: UsePressAnimationOptions) => UsePressAnimationResult;
+//# sourceMappingURL=usePressAnimation.d.ts.map

package/lib/typescript/module/hooks/useReducedMotion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 declare const useReducedMotion: () => boolean;
+//# sourceMappingURL=useReducedMotion.d.ts.map

package/lib/typescript/module/hooks/useToggle.d.ts

@@ -0,0 +1,9 @@
+export interface UseToggleResult {
+    value: boolean;
+    toggle: () => void;
+    setOn: () => void;
+    setOff: () => void;
+    setValue: (value: boolean) => void;
+}
+export declare const useToggle: (initial?: boolean) => UseToggleResult;
+//# sourceMappingURL=useToggle.d.ts.map

package/lib/typescript/module/index.d.ts

@@ -0,0 +1,16 @@
+export * from './components/index.js';
+export type { AppIconProps, AppIconSize, CuratedIconName, IconName, IconVariant, SlotIcon, SlotIconRef, SlotIconState, SlotNode } from './components/AppIcon/index.js';
+export { APP_ICON_SIZES, AppIcon, CURATED_ICON_NAMES, defaultIcons, ICON_NAMES, renderSlotIcon } from './components/AppIcon/index.js';
+export type { FieldArrayApi, FieldInputProps, FieldRules, FieldState, FocusableNode, FormApi, FormCompletion, FormConfig, FormErrors, FormTouched, FormValidateFn, FormValues, SubmitHelpers, UseFormCompletionOptions, ValidateOn, ValidationResult, ValidationRule, ValidationSchema } from './form/index.js';
+export { deletePath, Form, getPath, isFieldFilled, rules, setPath, useField, useFieldArray, useForm, useFormCompletion, useFormContext, useOptionalFormContext } from './form/index.js';
+export type { PressAnimationPreset, UseControllableStateOptions, UsePressAnimationOptions, UsePressAnimationResult, UseToggleResult } from './hooks/index.js';
+export { FLICK_TOLERANCE, PRESS_ANIMATION_PRESETS, useControllableState, useDebounce, useFlickGuard, usePressAnimation, useReducedMotion, useToggle } from './hooks/index.js';
+export type { InitUIOptions } from './initUI.js';
+export { initUI } from './initUI.js';
+export type { NetworkStatusBannerProps } from './network/index.js';
+export { NetworkStatusBanner } from './network/index.js';
+export type { ColorMode, ColorPalette, ColorSchemePreference, DeepPartial, IconRegistry, IconRenderer, MotionScale, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, Theme, ThemeOverrides, ThemeProviderProps, TypographyScale } from './theme/index.js';
+export { darkTheme, getColorMode, getTheme, lightTheme, mergeTheme, resetTheme, setColorMode, setTheme, subscribeTheme, ThemeProvider, useTheme, useThemeMode } from './theme/index.js';
+export type { BreakpointKey, FeedbackIntent, HapticType, ResponsiveScales, ScreenInfo, SpacingToken, SquirclePathParams } from './utils/index.js';
+export { Breakpoints, configureFeedback, feedback, hapticForIntent, isFeedbackEnabled, isScreenSize, isTablet, Margin, Padding, Responsive, ScreenDimensions, Spacing, SQUIRCLE_MIN_RADIUS, SQUIRCLE_SMOOTHING, setHapticImplementation, shadowStyle, smoothCorners, squircleApplies, squircleHostRadius, squirclePath, triggerHaptic, useScreenDimensions, warnUnknownProps } from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/initUI.d.ts

@@ -0,0 +1,12 @@
+import type { ColorMode, ThemeOverrides } from './theme/types.js';
+export interface InitUIOptions {
+    light?: ThemeOverrides;
+    dark?: ThemeOverrides;
+    defaultMode?: ColorMode;
+}
+/**
+ * Configure the global functional theme API used outside of React tree
+ * (use ThemeProvider for React-tree consumers; both can coexist).
+ */
+export declare const initUI: (options?: InitUIOptions) => void;
+//# sourceMappingURL=initUI.d.ts.map

package/lib/typescript/module/network/NetworkStatusBanner.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { ViewStyle } from 'react-native';
+export interface NetworkStatusBannerProps {
+    /** Override the default offline message. */
+    message?: string;
+    /** Render at the top (default) or bottom of the screen. */
+    position?: 'top' | 'bottom';
+    /** Optional style override for the banner container. */
+    style?: ViewStyle;
+    /** Hide the banner entirely (useful for screens that handle offline themselves). */
+    disabled?: boolean;
+}
+/**
+ * A subtle animated banner that slides in when the device goes offline.
+ * Mount once near the app root (above your navigation tree).
+ */
+export declare const NetworkStatusBanner: React.FC<NetworkStatusBannerProps>;
+export default NetworkStatusBanner;
+//# sourceMappingURL=NetworkStatusBanner.d.ts.map

package/lib/typescript/module/network/index.d.ts

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

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/specs/NativePdfRasterizer.d.ts

@@ -0,0 +1,40 @@
+import type { TurboModule } from 'react-native';
+export interface PdfDocumentInfo {
+    /** Opaque handle for every subsequent call (getPageInfo/renderPage/close) — NOT the file path. */
+    handle: string;
+    pageCount: number;
+    /** Points (1/72 in), the unrotated page size of page 0 — a per-page size read happens in renderPage. */
+    pageWidth: number;
+    pageHeight: number;
+}
+export interface PdfPageInfo {
+    width: number;
+    height: number;
+}
+export interface Spec extends TurboModule {
+    /**
+     * Opens a LOCAL pdf file (a file:// path or bare absolute path — no http(s), no
+     * headers, no auth: callers download remote documents with mobile-core's
+     * `downloadFile` first). Returns a handle used by every other call. Throws
+     * (rejects) on a missing file, a corrupt PDF, or a password-protected PDF.
+     */
+    open(path: string): Promise<PdfDocumentInfo>;
+    /**
+     * Reads one page's own size without rasterizing it (pages in a PDF can each
+     * have a different size/rotation).
+     */
+    getPageInfo(handle: string, pageIndex: number): Promise<PdfPageInfo>;
+    /**
+     * Rasterizes one page to a PNG file in the cache directory and returns its
+     * absolute path. `scale` is a multiplier on the page's own point size (pass
+     * the view width / page width ratio, capped by the caller — see
+     * react-native.md's "RGBA_8888 is 4 bytes/px" guidance). Renders are
+     * serialized per handle on both platforms; call sequentially per document.
+     */
+    renderPage(handle: string, pageIndex: number, scale: number): Promise<string>;
+    /** Releases the native document and evicts any cached page renders for it. */
+    close(handle: string): Promise<void>;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativePdfRasterizer.d.ts.map

package/lib/typescript/module/theme/Gradient.d.ts

@@ -0,0 +1,26 @@
+import type React from 'react';
+import type { LinearGradientValue, StyleProp, ViewStyle } from 'react-native';
+import type { GradientDefinition } from './types.js';
+/**
+ * Render a linear gradient with React Native's own `experimental_backgroundImage`
+ * style prop. `GradientDefinition` keeps its vector-based `start`/`end` shape,
+ * which is translated to a CSS angle here.
+ */
+type GradientVector = {
+    x: number;
+    y: number;
+};
+/**
+ * CSS gradient angles are measured clockwise from "to top", while the vectors
+ * live in a y-down 0..1 space, so the y delta is negated before the atan2.
+ */
+export declare const gradientAngle: (start?: GradientVector, end?: GradientVector) => number;
+export declare const toBackgroundImage: (gradient: GradientDefinition) => LinearGradientValue;
+export interface GradientProps {
+    gradient: GradientDefinition;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+export declare const Gradient: React.FC<GradientProps>;
+export {};
+//# sourceMappingURL=Gradient.d.ts.map

package/lib/typescript/module/theme/ThemeContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ColorMode, Theme, ThemeOverrides } from './types.js';
+export type ColorSchemePreference = 'light' | 'dark' | 'system';
+export interface ThemeProviderProps {
+    children: React.ReactNode;
+    initialPreference?: ColorSchemePreference;
+    lightOverrides?: ThemeOverrides;
+    darkOverrides?: ThemeOverrides;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => Theme;
+export declare const useThemeMode: () => {
+    mode: ColorMode;
+    preference: ColorSchemePreference;
+    setPreference: (preference: ColorSchemePreference) => void;
+    toggleColorMode: () => void;
+};
+//# sourceMappingURL=ThemeContext.d.ts.map

package/lib/typescript/module/theme/animatedValue.d.ts

@@ -0,0 +1,47 @@
+import { Animated } from 'react-native';
+/**
+ * Create an `Animated.Value` that survives RN 0.85's dev-mode prop deepFreeze.
+ *
+ * RN's Fabric renderer deep-freezes prop trees on host components. If an
+ * `Animated.Value` is reachable from a `style` prop via interpolation chains
+ * (the `_parent` ref on `AnimatedInterpolation` nodes), the recursive freeze
+ * converts the value's `_animation` slot into a throwing setter — the next
+ * `Animated.timing(v).start()` then crashes with
+ *   "_animation: object that is meant to be immutable".
+ *
+ * Sealing the value at construction makes `Object.isSealed(v) === true`,
+ * which causes `deepFreezeAndThrowOnMutationInDev` to skip-and-return at
+ * its top guard. Existing-property mutation (`_animation`, `_value`,
+ * `_listeners`, `_tracking`) keeps working — seal only blocks adding NEW
+ * properties, which `Animated.Value` does only once: `_tracking` is declared
+ * as a type but never assigned in the constructor, so `stopTracking()` (run by
+ * every `timing().start()`) adds it. On a sealed value that add throws
+ * "Cannot add new property '_tracking'" when RN's module runs strict. It does
+ * in an app on Expo's Metro config: its `experimentalImportSupport` leaves the
+ * modules as ESM, and Metro then prepends "use strict". The RN babel preset
+ * turns that directive off (`strictMode: false`), so the showcase and jest run
+ * RN sloppy, where the write is dropped silently and nothing fails. So the
+ * slot is declared here, before the seal.
+ *
+ * Use everywhere the library would otherwise call `new Animated.Value(...)`.
+ *
+ * NOT on web. The reasoning above ("Animated.Value doesn't add any properties
+ * post-construction") holds for React Native but not for react-native-web,
+ * whose `stopTracking()` assigns `_tracking` on an instance that never declared
+ * it — on a sealed object that throws, and the throw happens during unmount, so
+ * it takes the whole tree down. There is no Fabric deep-freeze on web either,
+ * so the seal has nothing to protect against there.
+ */
+export declare const createAnimatedValue: (initial: number, config?: ConstructorParameters<typeof Animated.Value>[1]) => Animated.Value;
+/**
+ * Set an `Animated.Value` to a target without going through JS.
+ *
+ * Once a value has been driven by `useNativeDriver: true`, the underlying
+ * native node owns it — calling `value.setValue(x)` from JS throws
+ *   "Attempting to run JS driven animation on animated node that has been moved to native".
+ * Use this helper for any value that is *also* used in a native-driven
+ * `Animated.timing/spring`. A zero-duration native timing routes the update
+ * through the same driver and stays valid across re-mounts and re-runs.
+ */
+export declare const setNativeValue: (value: Animated.Value, to: number) => void;
+//# sourceMappingURL=animatedValue.d.ts.map