@webority-technologies/mobile-ui 0.0.1 → 0.0.3

package/lib/module/utils/hapticUtils.js

@@ -1,24 +1,18 @@
 "use strict";
 
+import * as Haptics from 'expo-haptics';
 import { Platform, Vibration } from 'react-native';
 let hapticImpl = null;
-const tryLoadOptional = () => {
-  if (hapticImpl) {
-    return;
-  }
-  try {
-    // Lazily try to load the user's optional haptic dep without making it a hard requirement.
-    const haptic = require('react-native-haptic-feedback');
-    const trigger = haptic.default?.trigger ?? haptic.trigger;
-    if (typeof trigger === 'function') {
-      hapticImpl = type => trigger(type, {
-        enableVibrateFallback: true
-      });
-    }
-  } catch {
-    // Ignored: not installed; fall back to Vibration on Android, no-op on iOS.
-  }
-};
+
+/**
+ * Only what a test or the showcase injected. The default is expo-haptics, which
+ * this module imports directly: `expo` is a required peer, so the 48 components
+ * that fire haptics get them without any app wiring anything.
+ *
+ * The Vibration fallback below is now only the FAILURE path — a device whose
+ * haptic engine is disabled rejects, and Android still gets something.
+ */
+
 const fallback = type => {
   if (Platform.OS === 'android') {
     const map = {
@@ -33,8 +27,23 @@ const fallback = type => {
     Vibration.vibrate(map[type] ?? 10);
   }
 };
+
+/**
+ * expo-haptics, which splits what this module treats as one vocabulary across
+ * three functions. The promises are deliberately swallowed: the seam is
+ * synchronous, a device with the engine disabled rejects, and an unhandled
+ * rejection from a button press must never become a crash.
+ */
+const EXPO_HANDLERS = {
+  selection: () => Haptics.selectionAsync(),
+  impactLight: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light),
+  impactMedium: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium),
+  impactHeavy: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Heavy),
+  notificationSuccess: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success),
+  notificationWarning: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Warning),
+  notificationError: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error)
+};
 export const triggerHaptic = (type = 'selection') => {
-  tryLoadOptional();
   if (hapticImpl) {
     try {
       hapticImpl(type);
@@ -43,8 +52,18 @@ export const triggerHaptic = (type = 'selection') => {
       /* ignore */
     }
   }
+  const handler = EXPO_HANDLERS[type];
+  if (handler) {
+    handler().catch(() => fallback(type));
+    return;
+  }
   fallback(type);
 };
+
+/**
+ * Replace the haptic backend. Intended for TESTS and for the showcase; an app
+ * gets expo-haptics without wiring anything. Pass `null` to restore it.
+ */
 export const setHapticImplementation = impl => {
   hapticImpl = impl;
 };

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

@@ -0,0 +1,22 @@
+import type React from 'react';
+import type { ImageProps } from 'react-native';
+export interface AuthedImageProps extends Omit<ImageProps, 'source' | 'onError'> {
+    uri: string;
+    headers?: Record<string, string>;
+    /** Attach the stored bearer token. Default true. */
+    authenticated?: boolean;
+    /** Cache lifetime. Default 7 days. */
+    ttlMs?: number;
+    placeholder?: React.ReactNode;
+    fallback?: React.ReactNode;
+    onLoadStart?: () => void;
+    onLoadEnd?: () => void;
+    onError?: (error: Error) => void;
+    /** Override the key derived from `uri`. */
+    cacheKey?: string;
+    testID?: string;
+}
+declare const AuthedImage: React.FC<AuthedImageProps>;
+export { AuthedImage };
+export default AuthedImage;
+//# sourceMappingURL=AuthedImage.d.ts.map

package/lib/typescript/commonjs/components/AuthedImage/authedImageCache.d.ts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_TTL_MS: number;
+export interface AuthedImageCacheMeta {
+    fetchedAt: number;
+    bytes: number;
+    contentType: string;
+    lastAccessedAt: number;
+}
+export interface CachedImage {
+    dataUri: string;
+    meta: AuthedImageCacheMeta;
+}
+/**
+ * Ceiling for the total stored size of cached images. Exceeding it evicts the
+ * least recently used entries. An image cache with no ceiling grows until the
+ * OS reclaims the app's storage, which is the defect this replaces.
+ */
+export declare const setAuthedImageCacheLimit: (bytes: number) => void;
+export declare const getAuthedImageCacheLimit: () => number;
+/**
+ * Hex only by construction, so it is always a safe storage key segment.
+ */
+export declare const deriveCacheKey: (uri: string, override?: string) => string;
+export declare const readEntry: (cacheKey: string) => Promise<CachedImage | null>;
+export declare const isFresh: (meta: AuthedImageCacheMeta, ttlMs: number, now?: number) => boolean;
+export declare const touchEntry: (cacheKey: string, meta: AuthedImageCacheMeta) => Promise<void>;
+export declare const clearAuthedImageCache: () => Promise<void>;
+export declare const authedImageCacheStats: () => Promise<{
+    entries: number;
+    bytes: number;
+}>;
+export interface FetchOptions {
+    uri: string;
+    headers?: Record<string, string>;
+    authenticated: boolean;
+}
+export interface InFlightFetch {
+    promise: Promise<CachedImage>;
+    controller: AbortController;
+    waiters: number;
+}
+/**
+ * Two mounts of the same image share one request. The controller is aborted
+ * only when the last waiter releases, so one unmount cannot cancel the fetch
+ * another mount is still waiting on.
+ */
+export declare const acquireFetch: (cacheKey: string, options: FetchOptions) => InFlightFetch;
+export declare const releaseFetch: (cacheKey: string, entry: InFlightFetch) => void;
+//# sourceMappingURL=authedImageCache.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { AuthedImageProps } from './AuthedImage';
+export { AuthedImage, default } from './AuthedImage';
+export type { AuthedImageCacheMeta } from './authedImageCache';
+export { authedImageCacheStats, clearAuthedImageCache, getAuthedImageCacheLimit, setAuthedImageCacheLimit } from './authedImageCache';
+//# sourceMappingURL=index.d.ts.map

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

@@ -25,9 +25,7 @@ export interface ButtonProps extends Omit<PressableProps, 'style' | 'children'>
     rounded?: boolean;
     /**
      * Optional gradient background. Pass either a key from `theme.gradients`
-     * (e.g. `"primary"`) or a `GradientDefinition` literal. Requires
-     * `react-native-linear-gradient` to be installed; without it the button
-     * falls back to flat colour with a dev warning.
+     * (e.g. `"primary"`) or a `GradientDefinition` literal.
      */
     gradient?: string | GradientDefinition;
     style?: StyleProp<ViewStyle>;

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

@@ -28,8 +28,7 @@ export interface CardProps extends Omit<PressableProps, 'style' | 'children'> {
     /**
      * Optional gradient background. Pass a key from `theme.gradients` or a
      * literal `GradientDefinition`. Layered behind the card's content so
-     * existing variant/elevation/radius continue to work. Requires
-     * `react-native-linear-gradient` to be installed.
+     * existing variant/elevation/radius continue to work.
      */
     gradient?: string | GradientDefinition;
     onPress?: (event: GestureResponderEvent) => void;

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

@@ -0,0 +1,38 @@
+import React from 'react';
+export interface ErrorBoundaryInfo {
+    componentStack: string;
+}
+export interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    /** Custom fallback. Receives the error and a reset callback. Defaults to a themed EmptyState with a retry action. */
+    fallback?: React.ReactNode | ((error: Error, reset: () => void) => React.ReactNode);
+    /** Called on every caught error, after the error is recorded to the Logger. */
+    onError?: (error: Error, info: ErrorBoundaryInfo) => void;
+    /** Changing any value in this array resets the boundary. Standard escape hatch for route changes. */
+    resetKeys?: unknown[];
+    /** Called when the boundary resets, however it was triggered. */
+    onReset?: () => void;
+    /** Title and message for the default fallback. */
+    title?: string;
+    message?: string;
+    testID?: string;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+/**
+ * Catches render errors in its subtree and shows a themed fallback instead of
+ * a white screen. Mount this once near the navigation root per the fleet
+ * convention, and optionally again around any subtree that should recover
+ * independently (a single failed card should not blank the whole screen).
+ */
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    componentDidCatch(error: Error, info: ErrorBoundaryInfo): void;
+    reset: () => void;
+    render(): React.ReactNode;
+}
+export {};
+//# sourceMappingURL=ErrorBoundary.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { ErrorBoundaryInfo, ErrorBoundaryProps } from './ErrorBoundary';
+export { ErrorBoundary } from './ErrorBoundary';
+export { useErrorHandler } from './useErrorHandler';
+export { withErrorBoundary } from './withErrorBoundary';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/ErrorBoundary/useErrorHandler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a stable callback for surfacing an error caught outside React's
+ * render/commit cycle (an async callback, a rejected promise, a native event
+ * handler) to the nearest ErrorBoundary. React only catches synchronous
+ * render errors on its own; re-throwing during a state update is the
+ * documented way to route an async error into that same path.
+ */
+export declare const useErrorHandler: () => ((error: unknown) => void);
+//# sourceMappingURL=useErrorHandler.d.ts.map

package/lib/typescript/commonjs/components/ErrorBoundary/withErrorBoundary.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ErrorBoundaryProps } from './ErrorBoundary';
+/**
+ * Wraps a component in an `ErrorBoundary`. Prefer this over hand-wrapping a
+ * screen at every call site when the same fallback/reset behaviour applies
+ * everywhere that component is rendered.
+ */
+export declare const withErrorBoundary: <P extends object>(Component: React.ComponentType<P>, boundaryProps?: Omit<ErrorBoundaryProps, "children">) => React.ComponentType<P>;
+//# sourceMappingURL=withErrorBoundary.d.ts.map

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

@@ -1,11 +1,26 @@
 import React from 'react';
 import type { ScrollViewProps } from 'react-native';
 import { ScrollView } from 'react-native';
+export type SafeAreaEdge = 'top' | 'bottom' | 'left' | 'right';
 export interface KeyboardAwareScrollViewProps extends ScrollViewProps {
     /** Gap kept between the focused field and the top of the keyboard. Default 24. */
     extraScrollHeight?: number;
     /** Disable the keyboard-following behaviour (still a normal ScrollView). Default false. */
     disabled?: boolean;
+    /** Safe-area edges to pad. Default ['bottom']. */
+    safeAreaEdges?: SafeAreaEdge[];
+    /** Standard RefreshControl pass-through convenience. Ignored when `refreshControl` is set. */
+    refreshing?: boolean;
+    onRefresh?: () => void;
+    /** iOS keyboard animation duration to match when scrolling. Default 250. */
+    keyboardOpeningTime?: number;
+    /** Adds the extra bottom inset a tab bar needs. Default false. */
+    viewIsInsideTabBar?: boolean;
+    /** Scroll back to a fixed offset when the keyboard hides. */
+    resetScrollToCoords?: {
+        x: number;
+        y: number;
+    };
 }
 /**
  * A ScrollView that keeps the focused input visible above the keyboard — no

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

@@ -0,0 +1,25 @@
+import React from 'react';
+export declare const loader: {
+    show: (message?: string) => void;
+    hide: () => void;
+    wrap: <T>(work: Promise<T> | (() => Promise<T>), message?: string) => Promise<T>;
+    isVisible: () => boolean;
+    reset: () => void;
+};
+export declare const useLoader: () => typeof loader;
+export interface LoaderOverlayProps {
+    /**
+     * Replaces the default themed spinner. Lets an app supply a Lottie or brand
+     * animation without the library taking that dependency.
+     */
+    renderIndicator?: (message?: string) => React.ReactNode;
+    /** Overlay dim colour override; defaults to a themed scrim. */
+    backdropColor?: string;
+    /** Delay before the overlay actually appears, so a fast request never flashes it. Default 150ms. */
+    showDelayMs?: number;
+    /** Once visible, stay visible at least this long, so it never flickers. Default 400ms. */
+    minVisibleMs?: number;
+    testID?: string;
+}
+export declare const LoaderOverlay: React.FC<LoaderOverlayProps>;
+//# sourceMappingURL=LoaderOverlay.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { LoaderOverlayProps } from './LoaderOverlay';
+export { LoaderOverlay, loader, useLoader } from './LoaderOverlay';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export interface MarkdownProps {
+    /** The markdown source. An empty or missing string renders nothing. */
+    children?: string;
+    /** Called instead of Linking.openURL when a link is pressed. */
+    onLinkPress?: (href: string) => void;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * when data arrives. Use this while the data driving the component is being fetched.
+     */
+    loading?: boolean;
+    style?: StyleProp<ViewStyle>;
+    /** Applied to every text block, so a caller can set the base size or colour. */
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+/**
+ * Renders a small, deliberate subset of markdown using the theme's own type
+ * scale and colours, with no dependency.
+ *
+ * It exists because Expo has no markdown module and the alternative on npm has
+ * not shipped since 2022. What it covers is what our content contains: release
+ * notes, help text and descriptions written by people. Nested lists, tables and
+ * inline HTML are out of scope on purpose — see parse.ts.
+ */
+export declare const Markdown: React.FC<MarkdownProps>;
+//# sourceMappingURL=Markdown.d.ts.map

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

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

package/lib/typescript/commonjs/components/Markdown/parse.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A deliberately small CommonMark subset, parsed without a dependency.
+ *
+ * The scope is what our own content actually contains — release notes, help
+ * text, descriptions written by people in a web editor — not a spec-complete
+ * renderer. Nested lists, tables, footnotes, HTML blocks and reference links
+ * are out of scope on purpose: supporting them means a parser nobody here can
+ * maintain, and content that needs them is a sign it should not be markdown.
+ *
+ * Kept separate from the component so the grammar can be tested as data, with
+ * no rendering involved.
+ */
+export type InlineNode = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'strong';
+    children: InlineNode[];
+} | {
+    type: 'em';
+    children: InlineNode[];
+} | {
+    type: 'code';
+    value: string;
+} | {
+    type: 'strike';
+    children: InlineNode[];
+} | {
+    type: 'link';
+    href: string;
+    children: InlineNode[];
+};
+export type BlockNode = {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+} | {
+    type: 'paragraph';
+    children: InlineNode[];
+} | {
+    type: 'listItem';
+    ordered: boolean;
+    index: number;
+    depth: number;
+    children: InlineNode[];
+} | {
+    type: 'quote';
+    children: InlineNode[];
+} | {
+    type: 'codeBlock';
+    value: string;
+    language?: string;
+} | {
+    type: 'rule';
+};
+export declare const parseInline: (input: string) => InlineNode[];
+export declare const parseMarkdown: (source: string) => BlockNode[];
+//# sourceMappingURL=parse.d.ts.map

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

@@ -30,7 +30,14 @@ export interface OptionSheetProps {
     title?: string;
     options: ReadonlyArray<unknown>;
     labelOf: (option: unknown) => string;
-    valueOf: (option: unknown) => SelectValue;
+    /**
+     * Named `getValue`, not `valueOf`. Every object literal inherits
+     * `Object.prototype.valueOf`, so a prop of that name makes even
+     * `{ open: false }` fail to satisfy `Partial<OptionSheetProps>`, which poisons
+     * any wrapper or props-merge over this component. Its siblings labelOf,
+     * disabledOf and iconOf are safe; only this one collides.
+     */
+    getValue: (option: unknown) => SelectValue;
     disabledOf: (option: unknown) => boolean;
     descriptionOf: (option: unknown) => string | undefined;
     iconOf: (option: unknown) => React.ReactNode;

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

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { TextInput as RNTextInput, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+import type { MarkdownAction } from './markdownActions';
+export interface RichTextEditorProps {
+    /** The markdown source. Controlled, like any other input. */
+    value?: string;
+    /** Fires with the full markdown source after typing or a toolbar action. */
+    onChangeText?: (text: string) => void;
+    placeholder?: string;
+    /**
+     * Which toolbar actions to show, in the order given. Defaults to the full
+     * set the paired `<Markdown>` renderer can read.
+     */
+    actions?: MarkdownAction[];
+    /** Blocks typing and every toolbar action, and dims the editor. */
+    disabled?: boolean;
+    /**
+     * When true, renders the component as its authored skeleton placeholder shape.
+     * The placeholder mirrors the real layout's footprint so the UI doesn't reflow
+     * when data arrives. Use this while the data driving the component is being fetched.
+     */
+    loading?: boolean;
+    /** Minimum height of the text area in pixels. Default 160. */
+    minHeight?: number;
+    autoFocus?: boolean;
+    accessibilityLabel?: string;
+    /** Haptic feedback for toolbar presses. Pass false to disable; pass a HapticType to override. */
+    haptic?: HapticType | false;
+    /** Style for the outer bordered box. */
+    style?: StyleProp<ViewStyle>;
+    /** Style for the toolbar row. */
+    toolbarStyle?: StyleProp<ViewStyle>;
+    /** Style for the multiline TextInput. */
+    inputStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+/**
+ * A markdown editor: a themed multiline field plus a toolbar that wraps the
+ * current selection in the markers our own `<Markdown>` renderer reads back.
+ *
+ * Deliberately NOT a WYSIWYG surface. Rich-text-on-RN means a WebView, which is
+ * exactly what replacing the stale `react-native-pell-rich-editor` was meant to
+ * escape: markdown in, markdown out, one plain TextInput, no bridge.
+ */
+export declare const RichTextEditor: React.ForwardRefExoticComponent<RichTextEditorProps & React.RefAttributes<RNTextInput>>;
+export default RichTextEditor;
+//# sourceMappingURL=RichTextEditor.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { BlockMarkdownAction, EditorSelection, EditorState, InlineMarkdownAction, MarkdownAction } from './markdownActions';
+export { applyMarkdownAction } from './markdownActions';
+export type { RichTextEditorProps } from './RichTextEditor';
+export { RichTextEditor } from './RichTextEditor';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/RichTextEditor/markdownActions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The text transforms behind the editor's toolbar, kept out of the component so
+ * the behaviour people actually notice — toggling bold OFF again, and where the
+ * caret lands when nothing is selected — can be tested as data, with no
+ * rendering involved. Same split as Markdown/parse.ts.
+ *
+ * The output targets our own `<Markdown>` renderer, so the vocabulary is the
+ * subset that parser reads: `**`, `*`, `~~`, backtick, `[](…)`, `#`, `##`,
+ * `- `, `1. `, `> `. Nothing here emits anything that renderer would show as
+ * literal text.
+ */
+export interface EditorSelection {
+    start: number;
+    end: number;
+}
+export interface EditorState {
+    text: string;
+    selection: EditorSelection;
+}
+export type InlineMarkdownAction = 'bold' | 'italic' | 'strikethrough' | 'code' | 'link';
+export type BlockMarkdownAction = 'heading1' | 'heading2' | 'bulletList' | 'numberedList' | 'quote';
+export type MarkdownAction = InlineMarkdownAction | BlockMarkdownAction;
+/** Selection as given can be reversed, unset, or past the end after an edit. */
+export declare const normalizeSelection: (selection: EditorSelection, length: number) => EditorSelection;
+/**
+ * Applies one toolbar action to the current text + selection and returns the
+ * next pair. Pure: the caller owns the state.
+ *
+ * Wrapping applies to the selection; with nothing selected the markers are
+ * inserted and the caret lands between them. Applying an action to text that
+ * already carries it removes it instead of stacking a second copy — which is
+ * the half people notice immediately when it is missing.
+ */
+export declare const applyMarkdownAction: (state: EditorState, action: MarkdownAction) => EditorState;
+//# sourceMappingURL=markdownActions.d.ts.map

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

@@ -10,7 +10,7 @@
  *   - A View with the base color and `overflow: hidden` + radius gives the
  *     placeholder its shape.
  *   - For `animation: 'shimmer'`, an Animated.View carrying a 3-stop
- *     `LinearGradient` (transparent → highlight → transparent) translates
+ *     linear gradient (transparent → highlight → transparent) translates
  *     across the box. The radius clips it to the right outline automatically.
  *   - For `animation: 'pulse'`, a full-fill Animated.View fades its opacity
  *     between 0 and 0.6. Cheap and useful for tiny shapes where a sweep

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

@@ -6,6 +6,8 @@ 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 } from './Avatar';
@@ -48,6 +50,8 @@ 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 { FloatingActionButtonGroupAction, FloatingActionButtonGroupProps, FloatingActionButtonPosition, FloatingActionButtonProps, FloatingActionButtonSize, FloatingActionButtonTone } from './FloatingActionButton';
@@ -70,6 +74,10 @@ 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';
@@ -88,6 +96,8 @@ 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, SegmentedControlSize, SegmentedControlTone } from './SegmentedControl';

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

@@ -1,15 +1,25 @@
 import React from 'react';
 import type { FormApi, FormValues } from './types';
-export interface FormProps {
+export interface FormProps<Values extends FormValues = FormValues> {
     /** The object returned by {@link useForm}. */
-    form: FormApi<FormValues>;
+    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: React.FC<FormProps>;
+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. */

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

@@ -1,11 +1,26 @@
-import React from 'react';
-import type { StyleProp, ViewStyle } from 'react-native';
+import type React from 'react';
+import type { LinearGradientValue, StyleProp, ViewStyle } from 'react-native';
 import type { GradientDefinition } from './types';
+/**
+ * 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 declare const isGradientAvailable: () => boolean;
+export {};
 //# sourceMappingURL=Gradient.d.ts.map

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

@@ -1,4 +1,19 @@
 import type { ColorMode, Theme, ThemeOverrides } from './types';
+/**
+ * Set the override object for a mode (defaults to the active one).
+ *
+ * REPLACES that mode's overrides; it does not accumulate them. Calling
+ * `setTheme({ colors })` and then `setTheme({ spacing })` leaves ONLY the
+ * spacing override live — the colours silently revert to the base theme. Pass
+ * one complete override object per mode, or merge them yourself before calling:
+ *
+ *   setTheme({ ...myColors, ...mySpacing });
+ *
+ * This is deliberate (one override object per mode, last call wins) and is
+ * pinned by a test. Do not "fix" it to merge without treating that as the
+ * behaviour change it is: an app relying on replace to CLEAR a previous
+ * override would silently keep it.
+ */
 export declare const setTheme: (overrides: ThemeOverrides, mode?: ColorMode) => void;
 export declare const setColorMode: (mode: ColorMode) => void;
 export declare const getColorMode: () => ColorMode;
@@ -7,7 +22,7 @@ export declare const resetTheme: () => void;
 export declare const subscribeTheme: (callback: () => void) => (() => void);
 export { createAnimatedValue, setNativeValue } from './animatedValue';
 export type { GradientProps } from './Gradient';
-export { Gradient, isGradientAvailable } from './Gradient';
+export { Gradient, gradientAngle, toBackgroundImage } from './Gradient';
 export { mergeTheme } from './merge';
 export type { ColorSchemePreference, ThemeProviderProps } from './ThemeContext';
 export { ThemeProvider, useTheme, useThemeMode } from './ThemeContext';