@webority/mobile-ui 0.9.1 → 0.11.0

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

@@ -0,0 +1,75 @@
+import type React from 'react';
+import type { AccessibilityActionEvent, RefreshControlProps } from 'react-native';
+import type { HapticType } from '../utils/hapticUtils';
+export type UseRefreshControlLabels = {
+    /** Name of the refresh accessibility action. Default `'Refresh'`. */
+    refresh?: string;
+    /** Spoken when a button or accessibility-action refresh starts. Default `'Refreshing'`. */
+    refreshing?: string;
+    /** Spoken when that refresh ends. Default `'Updated'`. */
+    refreshed?: string;
+};
+export type UseRefreshControlOptions = {
+    /**
+     * Reloads the data. Return the promise (an RTK Query `refetch` already does)
+     * and the spinner stays until it settles. A rejection is logged and ends the
+     * spinner; show the user a curated message from the call itself.
+     */
+    onRefresh: () => unknown;
+    /**
+     * The screen's own loading flag, when the data is already tracked elsewhere.
+     * The spinner shows while this is true or a refresh started here is running.
+     */
+    refreshing?: boolean;
+    /**
+     * Haptic when a pull starts the refresh. Default: `'gestureStart'` on Android
+     * and none on iOS or web (no iOS haptic until a device check shows whether the
+     * system already taps). `false` turns it off; a type fires on every native
+     * platform.
+     */
+    haptic?: HapticType | false;
+    /**
+     * iOS only: the line under the spinner, for what changed ("Updated 2 minutes
+     * ago"). Never use it to explain how to refresh.
+     */
+    title?: string;
+    /** A refresh started here keeps the spinner at least this long. Default 400. */
+    minVisibleMs?: number;
+    labels?: UseRefreshControlLabels;
+};
+export type UseRefreshControlResult = {
+    /** Pass as `refreshControl` to a FlatList, SectionList, ScrollView or KeyboardAwareScrollView. */
+    refreshControl: React.ReactElement<RefreshControlProps>;
+    /** True while the spinner shows. Give an AppBar action or IconButton this as `loading`. */
+    refreshing: boolean;
+    /**
+     * Starts a refresh without a pull: the single-pointer path for an AppBar
+     * action or a button. Ignored while one is running. Fires no haptic (the
+     * button gives its own) and announces the start and the end. Never rejects.
+     */
+    refresh: () => Promise<void>;
+    /** Spread on a focusable element so a screen reader offers Refresh in its actions menu. */
+    accessibilityProps: {
+        accessibilityActions: {
+            name: 'refresh';
+            label: string;
+        }[];
+        onAccessibilityAction: (event: AccessibilityActionEvent) => void;
+    };
+};
+/**
+ * Themed pull to refresh plus the way to refresh without pulling.
+ *
+ * React Native's RefreshControl reports only that a refresh started, never that
+ * the pull crossed the trigger, so the haptic fires at that start. Web draws no
+ * pull at all, and a swipe is not available to everyone: pair the control with
+ * an AppBar action that calls `refresh()` so a person on any platform, or with a
+ * screen reader or keyboard, can reload.
+ *
+ *   const { refreshControl, refresh, refreshing } = useRefreshControl({ onRefresh: refetch });
+ *   <FlatList refreshControl={refreshControl} ... />
+ *   <AppBar rightActions={[{ icon: <AppIcon name="refresh" />, onPress: refresh,
+ *     accessibilityLabel: 'Refresh' }]} />
+ */
+export declare const useRefreshControl: (options: UseRefreshControlOptions) => UseRefreshControlResult;
+//# sourceMappingURL=useRefreshControl.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { NativeScrollEvent, NativeSyntheticEvent } from 'react-native';
+export type ScrollDirection = 'up' | 'down' | 'idle';
+export type UseScrollDirectionOptions = {
+    /** Points of travel in one direction before the direction flips. Default 8. */
+    threshold?: number;
+};
+export type UseScrollDirectionResult = {
+    direction: ScrollDirection;
+    onScroll: (e: NativeSyntheticEvent<NativeScrollEvent>) => void;
+};
+/**
+ * Direction of the user's scroll, for bars that hide on scroll down and return
+ * on scroll up. `'idle'` until the list has moved past the top; it returns to
+ * `'idle'` when the offset reaches the top. Rubber-band overscroll at either
+ * end is clamped away, so a bounce never reads as a reversal. State changes
+ * only when the direction changes, not on every scroll event.
+ *
+ * Pass `onScroll` to a ScrollView or FlatList with `scrollEventThrottle={16}`.
+ */
+export declare const useScrollDirection: (options?: UseScrollDirectionOptions) => UseScrollDirectionResult;
+//# sourceMappingURL=useScrollDirection.d.ts.map

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

@@ -3,14 +3,14 @@ export type { AppIconName, AppIconProps, AppIconSize, CuratedIconName, IconName,
 export { APP_ICON_SIZES, AppIcon, CURATED_ICON_NAMES, defaultIcons, ICON_NAMES, ICONSAX_SUFFIX, renderSlotIcon } from './components/AppIcon';
 export type { FieldArrayApi, FieldInputProps, FieldRules, FieldState, FocusableNode, FormApi, FormCompletion, FormConfig, FormErrors, FormTouched, FormValidateFn, FormValues, HookFieldProps, HookFormFieldProps, SubmitHelpers, UseFormCompletionOptions, ValidateOn, ValidationResult, ValidationRule, ValidationSchema } from './form';
 export { deletePath, Form, getPath, HookFormField, isFieldFilled, rules, setPath, useField, useFieldArray, useForm, useFormCompletion, useFormContext, useHookFormField, useOptionalFormContext } from './form';
-export type { PressAnimationPreset, UseControllableStateOptions, UsePressAnimationOptions, UsePressAnimationResult, UseToggleResult } from './hooks';
-export { FLICK_TOLERANCE, PRESS_ANIMATION_PRESETS, useControllableState, useDebounce, useFlickGuard, usePressAnimation, useReducedMotion, useToggle } from './hooks';
+export type { PressAnimationPreset, ScrollDirection, UseControllableStateOptions, UsePressAnimationOptions, UsePressAnimationResult, UseRefreshControlLabels, UseRefreshControlOptions, UseRefreshControlResult, UseScrollDirectionOptions, UseScrollDirectionResult, UseToggleResult } from './hooks';
+export { FLICK_TOLERANCE, PRESS_ANIMATION_PRESETS, useControllableState, useDebounce, useFlickGuard, usePressAnimation, useReducedMotion, useRefreshControl, useScrollDirection, useToggle } from './hooks';
 export type { InitUIOptions } from './initUI';
 export { initUI } from './initUI';
 export type { NetworkStatusBannerProps } from './network';
 export { NetworkStatusBanner } from './network';
 export type { ColorMode, ColorPalette, ColorSchemePreference, DeepPartial, IconRegistry, IconRenderer, MotionScale, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, TextVariantSpec, Theme, ThemeOverrides, ThemeProviderProps, TypographyScale } from './theme';
 export { darkTheme, getColorMode, getTheme, lightTheme, mergeTheme, resetTheme, setColorMode, setTheme, subscribeTheme, ThemeProvider, useTheme, useThemeMode } from './theme';
-export type { BreakpointKey, FeedbackIntent, HapticType, ResponsiveScales, ScreenInfo, SpacingToken, SquirclePathParams } from './utils';
-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';
+export type { AnnounceOptions, BreakpointKey, FeedbackIntent, HapticType, ResponsiveScales, ScreenInfo, SpacingToken, SquirclePathParams } from './utils';
+export { announce, 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';
 //# sourceMappingURL=index.d.ts.map

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

@@ -3,7 +3,7 @@ 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. */
+    /** Points (1/72 in), the page size of page 0 as displayed (after the page's /Rotate) — a per-page size read happens in renderPage. */
     pageWidth: number;
     pageHeight: number;
 }

package/lib/typescript/commonjs/utils/announce.d.ts

@@ -0,0 +1,14 @@
+export type AnnounceOptions = {
+    /** Polite (default) waits for current speech; `false` interrupts. Use `false` only for errors. */
+    polite?: boolean;
+};
+/**
+ * Speaks `message` through the screen reader without moving focus.
+ *
+ * iOS: queued behind current speech when polite, high priority and interrupting
+ * when not. Android: React Native exposes one announcement path with no
+ * priority, so polite and assertive both go through it. Web: a hidden
+ * `aria-live` region, `polite` or `assertive` (role `alert`).
+ */
+export declare const announce: (message: string, options?: AnnounceOptions) => void;
+//# sourceMappingURL=announce.d.ts.map

package/lib/typescript/commonjs/utils/hapticUtils.d.ts

@@ -1,4 +1,4 @@
-export type HapticType = 'selection' | 'impactLight' | 'impactMedium' | 'impactHeavy' | 'notificationSuccess' | 'notificationWarning' | 'notificationError';
+export type HapticType = 'selection' | 'impactLight' | 'impactMedium' | 'impactHeavy' | 'notificationSuccess' | 'notificationWarning' | 'notificationError' | 'longPress' | 'tick' | 'denseTick' | 'confirm' | 'reject' | 'gestureStart';
 export declare const triggerHaptic: (type?: HapticType) => void;
 /**
  * Replace the haptic backend. Intended for TESTS and for the showcase; an app

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

@@ -1,3 +1,5 @@
+export type { AnnounceOptions } from './announce';
+export { announce } from './announce';
 export { blendOf, tintOf } from './color';
 export { smoothCorners } from './corners';
 export type { FeedbackIntent } from './feedback';

package/lib/typescript/commonjs/utils/placement.d.ts

@@ -0,0 +1,55 @@
+import type { LayoutRectangle } from 'react-native';
+import type { EdgeInsets } from 'react-native-safe-area-context';
+/**
+ * The anchored-surface engine: where a menu, a context menu or a tooltip sits
+ * against the view that opened it. Pure geometry in window coordinates (what
+ * `measureInWindow` reports), so it runs the same on iOS, Android and web.
+ */
+export type PlacementPreference = 'top' | 'bottom' | 'auto';
+export type ResolvedPlacement = 'top' | 'bottom';
+export type PlacementAlign = 'center' | 'start' | 'end';
+export interface PlacementViewport {
+    width: number;
+    height: number;
+    insets: EdgeInsets;
+}
+export interface PlacementOptions {
+    /** Space between the anchor and the surface. Default 8. */
+    gap?: number;
+    /** Least distance from each safe edge of the viewport. Default 8. */
+    margin?: number;
+    /** Horizontal alignment against the anchor, in left-to-right terms. Default `'center'`. */
+    align?: PlacementAlign;
+}
+export interface PlacementResult {
+    x: number;
+    y: number;
+    placement: ResolvedPlacement;
+}
+export interface PlacementRoom {
+    above: number;
+    below: number;
+}
+export declare const PLACEMENT_GAP = 8;
+export declare const PLACEMENT_MARGIN = 8;
+/** Height free above and below the anchor, inside the safe area and the margin. */
+export declare const placementRoom: (anchor: LayoutRectangle, viewport: PlacementViewport, options?: PlacementOptions) => PlacementRoom;
+/**
+ * Places a surface of `content` size against `anchor`. `'top'` and `'bottom'`
+ * are preferences that flip when the surface does not fit and the other side
+ * has more room; `'auto'` takes the side with more room. The surface never
+ * covers a visible anchor: when it is taller than the room on its side the
+ * caller caps its height to `placementRoom(...)` and lets it scroll. The
+ * horizontal position is clamped inside the safe area.
+ */
+export declare const computePlacement: (anchor: LayoutRectangle, content: {
+    width: number;
+    height: number;
+}, viewport: PlacementViewport, preferred: PlacementPreference, options?: PlacementOptions) => PlacementResult;
+/**
+ * Where along a surface's edge an arrow sits so it points at the anchor's
+ * centre, kept `cornerPadding` away from the surface's corners.
+ */
+export declare const arrowOffset: (anchorCenter: number, surfaceStart: number, surfaceLength: number, cornerPadding: number) => number;
+export declare const claimAnchoredSurface: (close: () => void) => (() => void);
+//# sourceMappingURL=placement.d.ts.map

package/lib/typescript/module/components/BarChart/BarChart.d.ts

@@ -0,0 +1,62 @@
+/**
+ * BarChart: a simple vertical bar chart for a dashboard.
+ *
+ * Zero is always on the axis, so a bar's length is its value. The point of the
+ * chart is readable without touching it: bars carry their value when there are
+ * few of them, and a summary line names the main message. Touching it adds
+ * detail: a tap picks a bar, and dragging along the plot picks the bar under
+ * the finger with one haptic tick per bar crossed. The picked bar's label and
+ * value are written above the plot.
+ *
+ * A screen reader gets one adjustable element: swipe up or down to move from
+ * bar to bar, each one read as "label, value". Bars are Views, not SVG, so the
+ * labels follow the app's font scale and nothing is drawn in a fixed pixel box.
+ *
+ * Values may be negative; the zero line then sits inside the plot.
+ */
+import type { View as RNView, StyleProp, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils/index.js';
+export type BarChartTone = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
+export interface BarChartDatum {
+    /** The full name of the bar, read aloud and written in the callout: "Mon 06-Oct-2026". */
+    label: string;
+    /** The bar's value. A value that is not a finite number draws as zero. */
+    value: number;
+    /** A shorter label drawn under the bar: "Mon". Default `label`. */
+    axisLabel?: string;
+    /** Replaces the spoken text of the bar. Default `"label, value"`. */
+    accessibilityLabel?: string;
+}
+export interface BarChartProps {
+    data: ReadonlyArray<BarChartDatum>;
+    /** Colour of the bars. Default `'primary'`. Drawn in the tone's text ink so it holds 3:1 on the page in light and dark. */
+    tone?: BarChartTone;
+    /** Bar colour override; wins over `tone`. */
+    color?: string;
+    /** Height of the plot in points. Default `160`. */
+    height?: number;
+    /** What the chart shows, read first by a screen reader: "Approvals per day". */
+    label?: string;
+    /** The main message in a sentence, visible while no bar is picked: "Approvals peaked on Thursday". Default: the highest bar. */
+    summary?: string;
+    /** Write a value in full, for the callout and the spoken text. Default: the house number format (Indian grouping). */
+    formatValue?: (value: number) => string;
+    /** Write a value short, for the axis and the figures on the bars. Default: compact Indian form (1.5L, 2.3Cr). */
+    formatTick?: (value: number) => string;
+    /** Draw each bar's value on it. Default: when there are 7 bars or fewer. */
+    showValues?: boolean;
+    /** Picked bar (controlled); `null` for none. */
+    selection?: number | null;
+    /** Picked bar when uncontrolled. Default none. */
+    defaultSelection?: number | null;
+    /** Called when a bar is picked, or `null` when the picked bar is tapped again. */
+    onSelect?: (index: number | null) => void;
+    /** Haptic tick for each bar a drag crosses and for a tap. `false` turns it off. Default `'tick'`. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const BarChart: import("react").ForwardRefExoticComponent<BarChartProps & import("react").RefAttributes<RNView>>;
+export { BarChart };
+export default BarChart;
+//# sourceMappingURL=BarChart.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { BarChartDatum, BarChartProps, BarChartTone } from './BarChart.js';
+export { BarChart, default } from './BarChart.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/BarChart/scale.d.ts

@@ -0,0 +1,15 @@
+export interface BarScale {
+    /** Lowest value on the axis; never above zero. */
+    min: number;
+    /** Highest value on the axis; never below zero. */
+    max: number;
+    /** Axis ticks from `min` to `max`, on round steps (1, 2 or 5 times a power of ten). */
+    ticks: number[];
+}
+/**
+ * The axis of a bar chart: zero is always on it (a bar's length is its value),
+ * the other end rounds up to a familiar step (0, 5, 10 ...), and values that
+ * are not finite numbers are ignored.
+ */
+export declare const barScale: (values: ReadonlyArray<number>, targetTicks?: number) => BarScale;
+//# sourceMappingURL=scale.d.ts.map

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

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { View as RNView, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { ScrollDirection } from '../../hooks/useScrollDirection.js';
 import type { ShadowScale } from '../../theme/types.js';
 import type { HapticType } from '../../utils/index.js';
 import type { SlotIcon, SlotIconState } from '../AppIcon/index.js';
@@ -114,6 +115,11 @@ export interface BottomNavigationCenterAction {
     haptic?: HapticType | false;
     testID?: string;
 }
+/** What the bar tells a function `accessory` when it draws. */
+export interface BottomNavigationAccessoryState {
+    /** True while the bar is minimised: the accessory sits inline beside the tabs. */
+    minimized: boolean;
+}
 export interface BottomNavigationProps {
     tabs: TabConfig[];
     /** A pressable button in the middle of the bar, between the tabs. */
@@ -200,6 +206,32 @@ export interface BottomNavigationProps {
      * Off unless set.
      */
     border?: boolean;
+    /**
+     * Opt in to minimising the bar while the person scrolls down: the labels go
+     * and the bar shrinks to its icons (it never hides), and it restores on
+     * scroll up, on reaching the top, or on a tap on a tab. Needs
+     * `scrollDirection` from the scroll view's `useScrollDirection`. Stays
+     * expanded while a screen reader is on, and snaps with no animation under
+     * Reduce Motion. Off by default.
+     */
+    minimizeOnScroll?: boolean;
+    /**
+     * The scroll view's direction, from `useScrollDirection().direction`. Only
+     * read while `minimizeOnScroll` is set: `down` minimises, `up` and `idle`
+     * (at the top) restore. Default `idle`. A tap on a tab restores the bar
+     * until the direction next changes, so keep one hook per screen: sharing one
+     * across tab screens leaves `down` unchanged when the person returns to
+     * the top of another.
+     */
+    scrollDirection?: ScrollDirection;
+    /**
+     * A compact strip tied to the bar, such as a "clocked in" status. Expanded,
+     * it sits above the tabs across the bar's width; minimised, it moves inline
+     * to the left of the tabs, so keep it small there. Pass a function to draw
+     * a smaller version when `minimized`. Drawn whether or not
+     * `minimizeOnScroll` is set; `testID` gives it `${testID}-accessory`.
+     */
+    accessory?: React.ReactNode | ((state: BottomNavigationAccessoryState) => React.ReactNode);
     style?: StyleProp<ViewStyle>;
     /** Style applied to the active indicator of every variant (pill, line, bubble or expanded pill). */
     indicatorStyle?: StyleProp<ViewStyle>;

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

@@ -1,3 +1,3 @@
-export type { BottomNavigationCenterAction, BottomNavigationElevation, BottomNavigationIndicatorPosition, BottomNavigationIndicatorRadius, BottomNavigationProps, BottomNavigationRadius, BottomNavigationVariant, TabBadge, TabConfig, TabIcon, TabIconProps } from './BottomNavigation.js';
+export type { BottomNavigationAccessoryState, BottomNavigationCenterAction, BottomNavigationElevation, BottomNavigationIndicatorPosition, BottomNavigationIndicatorRadius, BottomNavigationProps, BottomNavigationRadius, BottomNavigationVariant, TabBadge, TabConfig, TabIcon, TabIconProps } from './BottomNavigation.js';
 export { BottomNavigation, default } from './BottomNavigation.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/BottomNavigation/useScreenReaderEnabled.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether VoiceOver or TalkBack is running. Subscribes only while `active`, so
+ * a bar that never minimises keeps no listener. Always false on web: React
+ * Native Web's `isScreenReaderEnabled` resolves `true` unconditionally and
+ * fires no change event, so it cannot tell a reader from none.
+ */
+export declare const useScreenReaderEnabled: (active: boolean) => boolean;
+//# sourceMappingURL=useScreenReaderEnabled.d.ts.map

package/lib/typescript/module/components/BottomSheet/BottomSheet.d.ts

@@ -14,7 +14,8 @@
  * ref.current?.expand();   // open at first snap point (or `index` prop)
  * ref.current?.expand(2);  // open at specific index
  * ref.current?.collapse(); // animate to smallest snap point
- * ref.current?.close();    // dismiss
+ * ref.current?.close();    // dismiss (never asks `confirmDismiss`)
+ * ref.current?.requestClose(); // dismiss the way a drag or the scrim would: asks first
  */
 import type React from 'react';
 import type { LayoutChangeEvent, NativeScrollEvent, NativeSyntheticEvent, StyleProp, ViewStyle } from 'react-native';
@@ -49,6 +50,23 @@ export interface BottomSheetProps {
     onAfterClose?: () => void;
     enablePanDownToClose?: boolean;
     enableBackdropPress?: boolean;
+    /**
+     * Asked before the user dismisses the sheet: a handle drag past the close
+     * threshold or a fast swipe down, a tap on the scrim, hardware Back (Android)
+     * and Escape (web), and `requestClose()`. Return `true` (or resolve `true`)
+     * to let it close, `false` to keep it open. A refused drag springs back to
+     * the snap point it started from, and `onChange(-1)` does not fire.
+     *
+     * Show the question with a `Dialog` or `OptionSheet` rendered inside this
+     * sheet's children (a second native modal beside the sheet's own does not
+     * present on iOS), and resolve a Promise from its buttons. While a Promise
+     * is pending, further dismissals are ignored, so it must settle. A rejected
+     * Promise leaves the sheet open and surfaces as an unhandled rejection.
+     *
+     * `ref.close()`, `useBottomSheet().close` and a controlled `index={-1}` are
+     * the app's own decision (a Save button, say) and never ask.
+     */
+    confirmDismiss?: () => boolean | Promise<boolean>;
     /**
      * Wrap `children` in a vertical ScrollView sized to the space between header
      * and footer. Off by default; a plain View then holds the content. The sheet
@@ -130,7 +148,19 @@ export interface BottomSheetProps {
 export interface BottomSheetRef {
     expand: (index?: number) => void;
     collapse: () => void;
-    close: () => void;
+    /**
+     * Closes without asking `confirmDismiss`. Resolves once the close has
+     * finished (when `onAfterClose` fires); resolves at once on a sheet that is
+     * not open, and when a reopen overtakes the close or the sheet unmounts.
+     */
+    close: () => Promise<void>;
+    /**
+     * Closes the way a drag or the scrim would: asks `confirmDismiss` first.
+     * Resolves `true` once the sheet has closed (or was not open), `false` when
+     * the dismissal was refused, ignored while another is being decided, or
+     * overtaken by a reopen or unmount.
+     */
+    requestClose: () => Promise<boolean>;
 }
 /**
  * State + actions exposed to anything rendered inside a `<BottomSheet>` —
@@ -148,7 +178,8 @@ export interface BottomSheetContextValue {
     snapPoints: number[];
     expand: (index?: number) => void;
     collapse: () => void;
-    close: () => void;
+    close: () => Promise<void>;
+    requestClose: () => Promise<boolean>;
 }
 /**
  * Access the enclosing `<BottomSheet>`'s state and imperative actions.

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

@@ -1,3 +1,5 @@
 export type { BottomSheetContextValue, BottomSheetPresentation, BottomSheetProps, BottomSheetRef, SnapPoint } from './BottomSheet.js';
 export { BottomSheet, default, useBottomSheet } from './BottomSheet.js';
+export type { SheetSwap, SheetSwapOptions } from './useSheetSwap.js';
+export { useSheetSwap } from './useSheetSwap.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/BottomSheet/useSheetSwap.d.ts

@@ -0,0 +1,24 @@
+import type { RefObject } from 'react';
+import type { BottomSheetRef } from './BottomSheet.js';
+export interface SheetSwapOptions {
+    /** Snap index the next sheet opens at. Defaults to its first snap point. */
+    index?: number;
+    /** Ask the first sheet's `confirmDismiss` before closing it. Off by default (the app chose to swap). */
+    confirm?: boolean;
+}
+export type SheetSwap = (from: RefObject<BottomSheetRef | null>, to: RefObject<BottomSheetRef | null>, options?: SheetSwapOptions) => Promise<boolean>;
+/**
+ * Replaces one bottom sheet with another: closes `from`, waits until it is
+ * fully gone (on iOS, until its native modal window is dismissed, which UIKit
+ * needs before it presents another), then opens `to`. One sheet is on screen
+ * at a time and there is no window where both are mounted.
+ *
+ * Resolves `true` once `to` has been asked to open, `false` when nothing was
+ * swapped: the close was refused or overtaken by a reopen (`confirm: true`),
+ * the component unmounted, `to` is not mounted, or another swap is running.
+ *
+ * const swap = useSheetSwap();
+ * swap(listRef, detailRef, { index: 1 });
+ */
+export declare const useSheetSwap: () => SheetSwap;
+//# sourceMappingURL=useSheetSwap.d.ts.map

package/lib/typescript/module/components/Card/Card.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import type { GestureResponderEvent, ImageSourcePropType, PressableProps, View as RNView, StyleProp, ViewStyle } from 'react-native';
 import type { ColorPalette, GradientDefinition } from '../../theme/types.js';
 import type { HapticType } from '../../utils/hapticUtils.js';
+import type { ContextMenuConfig } from '../Menu/useContextMenu.js';
 export type CardVariant = 'elevated' | 'outlined' | 'filled' | 'flat';
 /** A text action in the card header, drawn with a 44 pt hit target. */
 export interface CardTextAction {
@@ -71,6 +72,14 @@ export interface CardProps extends Omit<PressableProps, 'style' | 'children'> {
     onPress?: (event: GestureResponderEvent) => void;
     /** Haptic feedback for interactions. Pass false to disable; pass a HapticType to override the default. */
     haptic?: HapticType | false;
+    /**
+     * A long-press menu. Long press (right-click or Shift+F10 on the web) lifts
+     * the card over a dimmed screen with the menu beside it, and every item is
+     * also a screen reader action on the card. Unavailable items are hidden
+     * unless `unavailable: 'disable'`. The menu takes the long press: an
+     * `onLongPress` passed beside it is not called.
+     */
+    contextMenu?: ContextMenuConfig;
     accessibilityLabel?: string;
     style?: StyleProp<ViewStyle>;
     /** Alias for `style` — applied to the outer card element. */

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

@@ -16,7 +16,10 @@ export interface CheckboxProps extends Omit<PressableProps, 'style' | 'children'
     label?: React.ReactNode;
     /** Secondary line under the label. A string or a node; a node description adds nothing to the accessibility hint. */
     description?: React.ReactNode;
-    /** Error line under the label (and description); also draws the box in the error colour. A string or a node. */
+    /**
+     * Error line under the label (and description); also draws the box in the error colour. A string
+     * or a node; `true` shows the error state without a message.
+     */
     error?: React.ReactNode;
     /**
      * Drawn beside the label, after it (a glossary info button, say). It sits

package/lib/typescript/module/components/Composer/Composer.d.ts

@@ -0,0 +1,61 @@
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import { TextInput } from 'react-native';
+import type { HapticType } from '../../utils/hapticUtils.js';
+export interface ComposerProps {
+    /** Called with the trimmed text; the box clears once it is handed over. */
+    onSend: (text: string) => unknown;
+    /** Controlled draft. Leave unset and the composer keeps its own. */
+    value?: string;
+    onChangeText?: (text: string) => void;
+    placeholder?: string;
+    /** The text box's screen-reader name. Default: `placeholder`. */
+    accessibilityLabel?: string;
+    /** The send button's screen-reader name. Default 'Send'. */
+    sendLabel?: string;
+    /** A reply is arriving: the person can type but not send, and send shows a spinner. */
+    busy?: boolean;
+    /** Nothing can be typed or sent. */
+    disabled?: boolean;
+    maxLength?: number;
+    /** The box grows to this many lines, then scrolls. Default 5. */
+    maxLines?: number;
+    /** Before the box, e.g. an attach button. */
+    leading?: React.ReactNode;
+    /** Between the box and send, e.g. a microphone button. */
+    trailing?: React.ReactNode;
+    /** Inside the bar, above the row: a banner, a "questions left" note. Rides the keyboard too. */
+    above?: React.ReactNode;
+    /** Inside the bar, below the row: a disclaimer. */
+    below?: React.ReactNode;
+    /**
+     * Rides the keyboard (react-native-keyboard-controller's `KeyboardStickyView`).
+     * Default true. Turn it off inside a sheet that already moves with the
+     * keyboard. Pair it with a `MessageList` given the same `keyboardOffset`.
+     */
+    keyboardAware?: boolean;
+    /**
+     * How far below the bar the keyboard's top edge starts: the bottom safe area
+     * the bar pads for, plus anything under it such as a tab bar. Default: the
+     * bottom safe-area inset when `safeArea` is on, else 0.
+     */
+    keyboardOffset?: number;
+    /** Pad the bar for the bottom safe area. Default true; off above a tab bar. */
+    safeArea?: boolean;
+    autoFocus?: boolean;
+    /** Send haptic. Default `'selection'`. */
+    haptic?: HapticType | false;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The message box of a chat: a text box that grows to `maxLines` and then
+ * scrolls, a send button that is disabled while the trimmed text is empty,
+ * and slots for an attach or microphone button. The return key adds a line,
+ * as phone keyboards expect; only the button sends. By default the bar rides
+ * the keyboard and pads for the bottom safe area, so a chat screen is a
+ * `MessageList` above a `Composer` with no keyboard wiring of its own.
+ */
+export declare const Composer: React.ForwardRefExoticComponent<ComposerProps & React.RefAttributes<TextInput>>;
+export default Composer;
+//# sourceMappingURL=Composer.d.ts.map

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

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

package/lib/typescript/module/components/DateSeparator/DateSeparator.d.ts

@@ -0,0 +1,37 @@
+import { type DateValue } from '@webority/mobile-core';
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface DateSeparatorLabels {
+    today: string;
+    yesterday: string;
+}
+export declare const DEFAULT_DATE_SEPARATOR_LABELS: Readonly<DateSeparatorLabels>;
+export interface DateSeparatorProps {
+    /** The day to name. An instant is read in the configured zone (IST by default). */
+    date?: DateValue;
+    /** Draws this text instead of a day, e.g. "New messages" above the first unread. */
+    label?: string;
+    /** Draws the text and rules in the brand colour, for an unread divider. */
+    emphasis?: boolean;
+    labels?: Partial<DateSeparatorLabels>;
+    /** The reference for Today and Yesterday. Default: now. */
+    now?: Date;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * "Today", "Yesterday" or "10-Oct-2026" for a day, in the configured zone.
+ * Exported so a list can key its separators on the same text it shows.
+ */
+export declare const dayLabel: (date: DateValue, options?: {
+    now?: Date;
+    labels?: Partial<DateSeparatorLabels>;
+}) => string;
+/**
+ * A centred day name between two hairlines, for a message list. It is a
+ * header to screen readers, so a person can move through a conversation by
+ * day. With `label` and `emphasis` it draws an unread divider instead.
+ */
+export declare const DateSeparator: React.FC<DateSeparatorProps>;
+export default DateSeparator;
+//# sourceMappingURL=DateSeparator.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { DateSeparatorLabels, DateSeparatorProps } from './DateSeparator.js';
+export { DateSeparator, DEFAULT_DATE_SEPARATOR_LABELS, dayLabel, default } from './DateSeparator.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/components/FileViewer/FileViewer.d.ts

@@ -25,7 +25,7 @@ export interface FileViewerProps {
     accessibilityLabel?: string;
 }
 /**
- * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Renders a PDF via our own native rasterizer (Core Graphics on iOS, PdfRenderer on
  * Android) — no third-party PDF dependency. Pages are paged through a plain
  * `ScrollView` with manual windowed mounting (render the visible page ±
  * `RENDER_WINDOW`), not a `FlatList` — a `VirtualizedList`-based component

package/lib/typescript/module/components/FloatingActionButton/FloatingActionButton.d.ts

@@ -29,7 +29,8 @@ declare const FloatingActionButton: React.ForwardRefExoticComponent<FloatingActi
 export interface FloatingActionButtonGroupAction {
     key: string;
     icon: React.ReactNode;
-    label?: string;
+    /** Visible text beside the action. Required: an icon-only menu item is not allowed. */
+    label: string;
     onPress: () => void;
     tone?: FloatingActionButtonTone;
     accessibilityLabel: string;
@@ -37,6 +38,7 @@ export interface FloatingActionButtonGroupAction {
 export interface FloatingActionButtonGroupProps {
     primaryIcon: React.ReactNode;
     primaryActiveIcon?: React.ReactNode;
+    /** 2 to 6 actions, each with a visible label. Only the first 6 are drawn. */
     actions: FloatingActionButtonGroupAction[];
     open?: boolean;
     defaultOpen?: boolean;