@mrmeg/expo-ui 0.23.0 → 0.25.0

package/dist/components/Avatar.js

@@ -81,12 +81,17 @@ export function getAvatarInitials(name) {
  * `{ bundle, name }`, a resolved asset object). Keying those as "no image"
  * silently degraded a perfectly good source to initials.
  */
+// `Array.isArray` narrows to `any[]`, which cannot subtract the readonly array
+// arm of the source union, so the predicate spells the arm out.
+function isSourceList(source) {
+    return Array.isArray(source);
+}
 function getSourceKey(source) {
     if (source == null)
         return null;
     if (typeof source === "number")
         return `asset:${source}`;
-    if (Array.isArray(source)) {
+    if (isSourceList(source)) {
         // An empty array carries no image; anything else does.
         const keys = source.map((entry) => getSourceKey(entry) ?? "").filter(Boolean);
         return keys.length > 0 ? keys.join("|") : null;

package/dist/components/BottomSheet.js

@@ -181,7 +181,7 @@ function SheetCloseButton({ style }) {
  *     dispatched across the `RNHostView` boundary on Android — only `Pressable`
  *     hit-testing (native `measure()`) works inside the host. So this is a
  *     transparent `Pressable` mounted ONLY while a field is focused, mirroring
- *     the app's `DismissKeyboardOverlay`. The tap blurs the focused field via
+ *     a tap-to-dismiss overlay in the app. The tap blurs the focused field via
  *     its own native ref (`dismissKeyboardFocusedInput`), which resigns the
  *     responder regardless of window; `KeyboardController.dismiss()` is a
  *     best-effort fallback for the (rare) case with no registered blur handle.

package/dist/components/Button.d.ts

@@ -40,7 +40,7 @@ export interface ButtonProps extends PressableProps {
      */
     txOptions?: TextProps["txOptions"];
     /**
-     * An optional style override useful for padding & margin.
+     * An optional style override useful for margin and layout.
      */
     style?: StyleProp<ViewStyle>;
     /**

package/dist/components/Carousel.js

@@ -94,6 +94,8 @@ export function Carousel({ children, itemWidth = 0.85, gap = spacing.md, content
     // state: web's throttled ticks report the same page many times over, and
     // onIndexChange must fire once per page.
     const activeIndexRef = useRef(activeIndex);
+    // `ComponentRef<typeof ScrollView>` rather than RN 0.88's `ScrollViewInstance`,
+    // which RN 0.85/0.86 typings do not export.
     const scrollRef = useRef(null);
     const hasScrolledToInitial = useRef(false);
     const commitIndex = useCallback((next) => {

package/dist/components/Dialog.d.ts

@@ -1,25 +1,9 @@
 import * as React from "react";
-import { View, ViewProps } from "react-native";
+import { ViewProps } from "react-native";
 import * as DialogPrimitive from "@rn-primitives/dialog";
 import * as AlertDialogPrimitive from "@rn-primitives/alert-dialog";
-declare const DialogTrigger: {
-    ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-        asChild?: boolean;
-    } & {
-        onKeyDown?: (ev: React.KeyboardEvent) => void;
-        onKeyUp?: (ev: React.KeyboardEvent) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
-declare const DialogClose: {
-    ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-        asChild?: boolean;
-    } & {
-        onKeyDown?: (ev: React.KeyboardEvent) => void;
-        onKeyUp?: (ev: React.KeyboardEvent) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
+declare const DialogTrigger: typeof DialogPrimitive.Trigger;
+declare const DialogClose: typeof DialogPrimitive.Close;
 interface DialogProps extends DialogPrimitive.RootProps {
     children: React.ReactNode;
 }
@@ -36,58 +20,19 @@ declare function DialogTitle({ children, style, ...props }: DialogPrimitive.Titl
 declare function DialogDescription({ children, style, ...props }: DialogPrimitive.DescriptionProps & {
     children: React.ReactNode;
 }): React.JSX.Element;
-declare const Dialog: typeof DialogRoot & {
-    Trigger: {
-        ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-            asChild?: boolean;
-        } & {
-            onKeyDown?: (ev: React.KeyboardEvent) => void;
-            onKeyUp?: (ev: React.KeyboardEvent) => void;
-        } & React.RefAttributes<View>): React.JSX.Element;
-        displayName: string;
-    };
+type DialogComponent = typeof DialogRoot & {
+    Trigger: typeof DialogTrigger;
     Content: typeof DialogContent;
     Header: typeof DialogHeader;
     Footer: typeof DialogFooter;
     Title: typeof DialogTitle;
     Description: typeof DialogDescription;
-    Close: {
-        ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-            asChild?: boolean;
-        } & {
-            onKeyDown?: (ev: React.KeyboardEvent) => void;
-            onKeyUp?: (ev: React.KeyboardEvent) => void;
-        } & React.RefAttributes<View>): React.JSX.Element;
-        displayName: string;
-    };
-};
-declare const AlertDialogTrigger: {
-    ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-        asChild?: boolean;
-    } & {
-        onKeyDown?: (ev: React.KeyboardEvent) => void;
-        onKeyUp?: (ev: React.KeyboardEvent) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
-declare const AlertDialogAction: {
-    ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-        asChild?: boolean;
-    } & {
-        onKeyDown?: (ev: React.KeyboardEvent) => void;
-        onKeyUp?: (ev: React.KeyboardEvent) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
-declare const AlertDialogCancel: {
-    ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-        asChild?: boolean;
-    } & {
-        onKeyDown?: (ev: React.KeyboardEvent) => void;
-        onKeyUp?: (ev: React.KeyboardEvent) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
+    Close: typeof DialogClose;
 };
+declare const Dialog: DialogComponent;
+declare const AlertDialogTrigger: typeof AlertDialogPrimitive.Trigger;
+declare const AlertDialogAction: typeof AlertDialogPrimitive.Action;
+declare const AlertDialogCancel: typeof AlertDialogPrimitive.Cancel;
 interface AlertDialogProps extends AlertDialogPrimitive.RootProps {
     children: React.ReactNode;
 }
@@ -102,39 +47,16 @@ declare function AlertDialogTitle({ children, style, ...props }: AlertDialogPrim
 declare function AlertDialogDescription({ children, style, ...props }: AlertDialogPrimitive.DescriptionProps & {
     children: React.ReactNode;
 }): React.JSX.Element;
-declare const AlertDialog: typeof AlertDialogRoot & {
-    Trigger: {
-        ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-            asChild?: boolean;
-        } & {
-            onKeyDown?: (ev: React.KeyboardEvent) => void;
-            onKeyUp?: (ev: React.KeyboardEvent) => void;
-        } & React.RefAttributes<View>): React.JSX.Element;
-        displayName: string;
-    };
+type AlertDialogComponent = typeof AlertDialogRoot & {
+    Trigger: typeof AlertDialogTrigger;
     Content: typeof AlertDialogContent;
     Header: typeof DialogHeader;
     Footer: typeof DialogFooter;
     Title: typeof AlertDialogTitle;
     Description: typeof AlertDialogDescription;
-    Action: {
-        ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-            asChild?: boolean;
-        } & {
-            onKeyDown?: (ev: React.KeyboardEvent) => void;
-            onKeyUp?: (ev: React.KeyboardEvent) => void;
-        } & React.RefAttributes<View>): React.JSX.Element;
-        displayName: string;
-    };
-    Cancel: {
-        ({ asChild, onPress: onPressProp, disabled, ref, ...props }: Omit<import("react-native").PressableProps & React.RefAttributes<View>, "ref"> & {
-            asChild?: boolean;
-        } & {
-            onKeyDown?: (ev: React.KeyboardEvent) => void;
-            onKeyUp?: (ev: React.KeyboardEvent) => void;
-        } & React.RefAttributes<View>): React.JSX.Element;
-        displayName: string;
-    };
+    Action: typeof AlertDialogAction;
+    Cancel: typeof AlertDialogCancel;
 };
+declare const AlertDialog: AlertDialogComponent;
 export { Dialog, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, DialogClose, AlertDialog, AlertDialogTrigger, AlertDialogContent, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };
 export type { DialogProps, DialogContentProps, AlertDialogProps, AlertDialogContentProps, };

package/dist/components/Dialog.js

@@ -14,6 +14,11 @@ const FullWindowOverlay = Platform.OS === "ios" ? RNFullWindowOverlay : React.Fr
 // ============================================================================
 // Dialog
 // ============================================================================
+// These re-exports and the compound components below carry explicit type
+// annotations because React Native 0.88 resolves primitive ref types through
+// its private `ReactNativeElement`, which declaration emit cannot name
+// portably (TS2883). Annotating with `typeof <primitive>` keeps the emitted
+// .d.ts pointing at the primitive's own public types instead.
 const DialogTrigger = DialogPrimitive.Trigger;
 const DialogClose = DialogPrimitive.Close;
 function DialogRoot({ children, ...props }) {

package/dist/components/DismissKeyboard.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { StyleProp, ViewStyle } from "react-native";
+import { type StyleProp, type ViewStyle } from "react-native";
 type Props = {
     children: React.ReactNode;
     style?: StyleProp<ViewStyle>;
@@ -9,7 +9,18 @@ type Props = {
     scrollable?: boolean;
 };
 /**
- * @returns Wrapper for a view that dismisses the keyboard when tapped outside of a text input
+ * Wrapper for a screen (or form) that dismisses the keyboard when the user taps
+ * outside of a text input.
+ *
+ * Mirrors RN's `keyboardShouldPersistTaps="handled"` for the native `@expo/ui`
+ * field, which RN itself cannot see: the wrapper never claims the touch, so
+ * buttons, other fields and the focused field's own gestures win, and it
+ * dismisses on release only when nothing else took the tap and the finger did
+ * not scroll. See `useKeyboardDismissResponder`.
+ *
+ * A drag on the inner ScrollView also hides the keyboard: `interactive` on iOS
+ * (UIKit resigns any first responder, SwiftUI fields included) and an explicit
+ * dismiss on drag start on Android, where RN's `on-drag` only knows RN inputs.
  */
-export declare const DismissKeyboard: (props: Props) => React.JSX.Element;
+export declare function DismissKeyboard({ children, style, avoidKeyboard, scrollable, }: Props): React.JSX.Element;
 export {};

package/dist/components/DismissKeyboard.js

@@ -1,58 +1,27 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import React from "react";
-import { Platform, ScrollView, View, } from "react-native";
-import { KeyboardController, useKeyboardContext, useKeyboardState, } from "./keyboardController";
+import { Platform, ScrollView, View } from "react-native";
 import { KeyboardAvoidingView, useKeyboardAvoidance } from "./KeyboardAvoidingView.js";
-import { isTouchInsideKeyboardFocusedInput } from "./keyboardFocusRegistry.js";
+import { dismissKeyboard, useKeyboardDismissResponder } from "./keyboardDismiss.js";
 /**
- * Native tap-away keyboard dismissal.
+ * Wrapper for a screen (or form) that dismisses the keyboard when the user taps
+ * outside of a text input.
  *
- * Why window-level dismissal: the native `@expo/ui` TextInput is a SwiftUI /
- * Compose field that never registers with React Native's `TextInputState`, so
- * `Keyboard.dismiss()` (which only blurs RN-tracked inputs) does nothing for it.
- * `KeyboardController.dismiss()` resigns the focused responder at the IME level,
- * which works for both native and RN fields.
+ * Mirrors RN's `keyboardShouldPersistTaps="handled"` for the native `@expo/ui`
+ * field, which RN itself cannot see: the wrapper never claims the touch, so
+ * buttons, other fields and the focused field's own gestures win, and it
+ * dismisses on release only when nothing else took the tap and the finger did
+ * not scroll. See `useKeyboardDismissResponder`.
  *
- * Why responder capture: a full-screen overlay also catches taps on the focused
- * input, which breaks double-tap text selection. Capture lets the tap continue
- * to children while still dismissing when the touch starts outside the focused
- * input bounds.
+ * A drag on the inner ScrollView also hides the keyboard: `interactive` on iOS
+ * (UIKit resigns any first responder, SwiftUI fields included) and an explicit
+ * dismiss on drag start on Android, where RN's `on-drag` only knows RN inputs.
  */
-function useDismissKeyboardOnOutsideTouch() {
-    const isVisible = useKeyboardState((state) => state.isVisible);
-    const { layout: focusedInput } = useKeyboardContext();
-    return React.useCallback((event) => {
-        if (Platform.OS === "web" || !isVisible) {
-            return false;
-        }
-        if (isTouchInsideKeyboardFocusedInput(event, focusedInput.value?.layout)) {
-            return false;
-        }
-        KeyboardController.dismiss();
-        return false;
-    }, [focusedInput, isVisible]);
-}
-/**
- * @returns Wrapper for a view that dismisses the keyboard when tapped outside of a text input
- */
-function DismissKeyboardLayout({ children, style, avoidKeyboard = true, scrollable = true, dismissOnTouchStart, }) {
+export function DismissKeyboard({ children, style, avoidKeyboard = true, scrollable = true, }) {
+    const responderProps = useKeyboardDismissResponder();
     const hasKeyboardAvoidance = useKeyboardAvoidance();
-    const content = scrollable ? (_jsx(ScrollView, { style: { flex: 1 }, contentContainerStyle: { flexGrow: 1, justifyContent: "center" }, keyboardShouldPersistTaps: "handled", showsVerticalScrollIndicator: false, children: children })) : (children);
+    const content = scrollable ? (_jsx(ScrollView, { style: { flex: 1 }, contentContainerStyle: { flexGrow: 1, justifyContent: "center" }, keyboardShouldPersistTaps: "handled", keyboardDismissMode: Platform.OS === "ios" ? "interactive" : "none", onScrollBeginDrag: Platform.OS === "android" ? dismissKeyboard : undefined, showsVerticalScrollIndicator: false, children: children })) : (children);
     if (!avoidKeyboard || hasKeyboardAvoidance) {
-        return (_jsx(View, { style: { flex: 1 }, onStartShouldSetResponderCapture: dismissOnTouchStart, children: content }));
+        return (_jsx(View, { style: { flex: 1 }, ...responderProps, children: content }));
     }
-    return (_jsx(KeyboardAvoidingView, { style: [{ flex: 1, width: "100%" }, style], keyboardVerticalOffset: Platform.OS === "ios" ? 0 : 0, onStartShouldSetResponderCapture: dismissOnTouchStart, children: content }));
-}
-function NativeDismissKeyboard(props) {
-    const dismissOnTouchStart = useDismissKeyboardOnOutsideTouch();
-    return (_jsx(DismissKeyboardLayout, { ...props, dismissOnTouchStart: dismissOnTouchStart }));
+    return (_jsx(KeyboardAvoidingView, { style: [{ flex: 1, width: "100%" }, style], keyboardVerticalOffset: 0, ...responderProps, children: content }));
 }
-/**
- * @returns Wrapper for a view that dismisses the keyboard when tapped outside of a text input
- */
-export const DismissKeyboard = (props) => {
-    if (Platform.OS === "web") {
-        return _jsx(DismissKeyboardLayout, { ...props });
-    }
-    return _jsx(NativeDismissKeyboard, { ...props });
-};

package/dist/components/DropdownMenu.d.ts

@@ -1,40 +1,11 @@
 import * as React from "react";
-import { type TextStyle, View } from "react-native";
+import { type TextStyle } from "react-native";
 import * as DropdownMenuPrimitive from "@rn-primitives/dropdown-menu";
-declare const DropdownMenu: {
-    ({ asChild, onOpenChange: onOpenChangeProp, ref, ...viewProps }: import("react-native").ViewProps & {
-        asChild?: boolean;
-    } & {
-        onOpenChange?: (open: boolean) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
-declare const DropdownMenuGroup: {
-    ({ asChild, ref, ...props }: import("react-native").ViewProps & {
-        asChild?: boolean;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
+declare const DropdownMenu: typeof DropdownMenuPrimitive.Root;
+declare const DropdownMenuGroup: typeof DropdownMenuPrimitive.Group;
 declare const DropdownMenuPortal: typeof DropdownMenuPrimitive.Portal;
-declare const DropdownMenuSub: {
-    ({ asChild, defaultOpen, open: openProp, onOpenChange: onOpenChangeProp, ref, ...props }: import("react-native").ViewProps & {
-        asChild?: boolean;
-    } & {
-        defaultOpen?: boolean;
-        open?: boolean;
-        onOpenChange?: (value: boolean) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
-declare const DropdownMenuRadioGroup: {
-    ({ asChild, value, onValueChange, ref, ...props }: import("react-native").ViewProps & {
-        asChild?: boolean;
-    } & {
-        value: string | undefined;
-        onValueChange: (value: string) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-};
+declare const DropdownMenuSub: typeof DropdownMenuPrimitive.Sub;
+declare const DropdownMenuRadioGroup: typeof DropdownMenuPrimitive.RadioGroup;
 /**
  * DropdownMenuTrigger Component
  * Wraps the primitive Trigger to default `accessibilityRole="button"`.

package/dist/components/DropdownMenu.js

@@ -10,7 +10,8 @@ import { useScalePress } from "../hooks/useScalePress.js";
 import * as DropdownMenuPrimitive from "@rn-primitives/dropdown-menu";
 import { FullWindowOverlay as RNFullWindowOverlay } from "react-native-screens";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
-// Re-export primitives that don't need styling
+// Re-export primitives that don't need styling. Annotated with `typeof` for
+// portable declaration emit — see the note in Dialog.tsx (TS2883).
 const DropdownMenu = DropdownMenuPrimitive.Root;
 const DropdownMenuGroup = DropdownMenuPrimitive.Group;
 const DropdownMenuPortal = DropdownMenuPrimitive.Portal;

package/dist/components/InputOTP.js

@@ -27,6 +27,8 @@ const BULLET = "\u2022";
  */
 function InputOTP({ length = 6, value = "", onChangeText, onComplete, error = false, errorText, disabled = false, autoFocus = false, secureTextEntry = false, inputMode = "numeric", style: styleOverride, }) {
     const { theme } = useTheme();
+    // `ComponentRef<typeof RNTextInput>` rather than RN 0.88's `TextInputInstance`,
+    // which RN 0.85/0.86 typings do not export.
     const inputRef = useRef(null);
     const [focused, setFocused] = useState(false);
     const styles = themedStyles(theme);
@@ -63,7 +65,10 @@ function InputOTP({ length = 6, value = "", onChangeText, onComplete, error = fa
     const markOtpBlurred = useCallback(() => {
         setFocused(false);
     }, []);
-    return (_jsxs(View, { style: StyleSheet.flatten([styles.container, styleOverride]), children: [_jsx(RNTextInput, { ref: inputRef, value: value, onChangeText: handleChangeText, onKeyPress: handleKeyPress, onFocus: markOtpFocused, onBlur: markOtpBlurred, maxLength: length, autoFocus: autoFocus, editable: !disabled, inputMode: inputMode, autoComplete: "one-time-code", textContentType: "oneTimeCode", caretHidden: true, style: styles.hiddenInput, accessibilityLabel: "Verification code input", importantForAccessibility: "yes" }), _jsx(View, { style: styles.cellRow, children: Array.from({ length }, (_, index) => {
+    return (_jsxs(View, { style: StyleSheet.flatten([styles.container, styleOverride]), children: [_jsx(RNTextInput, { ref: inputRef, value: value, onChangeText: handleChangeText, onKeyPress: handleKeyPress, onFocus: markOtpFocused, onBlur: markOtpBlurred, maxLength: length, autoFocus: autoFocus, editable: !disabled, inputMode: inputMode, 
+                // Android only recognises the `sms-otp` autofill hint; iOS and web use
+                // `one-time-code` + `oneTimeCode` to offer codes from Messages / Mail.
+                autoComplete: Platform.OS === "android" ? "sms-otp" : "one-time-code", textContentType: "oneTimeCode", caretHidden: true, style: styles.hiddenInput, accessibilityLabel: "Verification code input", importantForAccessibility: "yes" }), _jsx(View, { style: styles.cellRow, children: Array.from({ length }, (_, index) => {
                     const char = value[index] ?? "";
                     const isActive = focused && index === activeIndex;
                     const displayChar = char

package/dist/components/Popover.d.ts

@@ -1,6 +1,6 @@
 import * as PopoverPrimitive from "@rn-primitives/popover";
 import * as React from "react";
-import { View, ViewProps } from "react-native";
+import { ViewProps } from "react-native";
 /**
  * Popover Trigger Component
  * The element that triggers the popover to open/close
@@ -44,21 +44,21 @@ interface PopoverFooterProps extends ViewProps {
 }
 declare function PopoverFooter({ children, style, ...props }: PopoverFooterProps): React.JSX.Element;
 /**
- * Popover Component with Sub-components
- * Properly typed interface for dot notation access (e.g., Popover.Trigger)
+ * Popover Root Component
+ * Manages popover state and provides context for trigger and content
  */
-declare const Popover: {
-    ({ asChild, onOpenChange: onOpenChangeProp, ref, ...viewProps }: ViewProps & {
-        asChild?: boolean;
-    } & {
-        onOpenChange?: (open: boolean) => void;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-} & {
+declare const PopoverRoot: typeof PopoverPrimitive.Root;
+type PopoverComponent = typeof PopoverRoot & {
     Trigger: typeof PopoverTrigger;
     Content: typeof PopoverContent;
     Header: typeof PopoverHeader;
     Body: typeof PopoverBody;
     Footer: typeof PopoverFooter;
 };
+/**
+ * Popover Component with Sub-components
+ * Properly typed interface for dot notation access (e.g., Popover.Trigger).
+ * The annotation is what keeps declaration emit portable — see Dialog.tsx (TS2883).
+ */
+declare const Popover: PopoverComponent;
 export { Popover, PopoverTrigger, PopoverContent, PopoverHeader, PopoverBody, PopoverFooter, };

package/dist/components/Popover.js

@@ -40,7 +40,7 @@ function PopoverContent({ side, align = "center", sideOffset = 4, portalHost, ..
             padding: spacing.xs,
             ...getShadowStyle("soft"),
         },
-    ]);
+    ]) ?? undefined;
     return (_jsx(PopoverPrimitive.Portal, { hostName: portalHost, children: _jsx(FullWindowOverlay, { children: _jsx(PopoverPrimitive.Overlay, { style: Platform.select({ native: StyleSheet.absoluteFill }), children: _jsx(AnimatedView, { type: "fade", enterDuration: 200, children: _jsx(TextColorContext.Provider, { value: textColor, children: _jsx(TextClassContext.Provider, { value: "", children: _jsx(PopoverPrimitive.Content, { side: side, align: align, sideOffset: sideOffset, style: contentStyle, ...props }) }) }) }) }) }) }));
 }
 function PopoverHeader({ children, style, ...props }) {
@@ -83,7 +83,8 @@ function PopoverFooter({ children, style, ...props }) {
 const PopoverRoot = PopoverPrimitive.Root;
 /**
  * Popover Component with Sub-components
- * Properly typed interface for dot notation access (e.g., Popover.Trigger)
+ * Properly typed interface for dot notation access (e.g., Popover.Trigger).
+ * The annotation is what keeps declaration emit portable — see Dialog.tsx (TS2883).
  */
 const Popover = Object.assign(PopoverRoot, {
     Trigger: PopoverTrigger,

package/dist/components/Select.d.ts

@@ -1,6 +1,10 @@
 import * as React from "react";
-import { View } from "react-native";
 import * as SelectPrimitive from "@rn-primitives/select";
+/**
+ * SelectRoot Component
+ * Manages select state and provides context for trigger and content
+ */
+declare const SelectRoot: typeof SelectPrimitive.Root;
 /**
  * Size variants for SelectTrigger
  */
@@ -57,25 +61,7 @@ declare function SelectLabel({ style: styleOverride, ...props }: SelectLabelProp
  */
 type SelectSeparatorProps = SelectPrimitive.SeparatorProps;
 declare function SelectSeparator({ style: styleOverride, ...props }: SelectSeparatorProps): React.JSX.Element;
-/**
- * Select Component with Sub-components
- * Properly typed interface for dot notation access (e.g., Select.Trigger)
- */
-declare const Select: {
-    ({ asChild, value: valueProp, defaultValue, onValueChange: onValueChangeProp, onOpenChange: onOpenChangeProp, disabled, ref, ...viewProps }: import("react-native").ViewProps & {
-        asChild?: boolean;
-    } & {
-        value?: import("@rn-primitives/select").Option;
-        defaultValue?: import("@rn-primitives/select").Option;
-        onValueChange?: (option: import("@rn-primitives/select").Option) => void;
-        onOpenChange?: (open: boolean) => void;
-        disabled?: boolean;
-        dir?: "ltr" | "rtl";
-        name?: string;
-        required?: boolean;
-    } & React.RefAttributes<View>): React.JSX.Element;
-    displayName: string;
-} & {
+type SelectComponent = typeof SelectRoot & {
     Trigger: typeof SelectTrigger;
     Value: typeof SelectValue;
     Content: typeof SelectContent;
@@ -84,5 +70,11 @@ declare const Select: {
     Label: typeof SelectLabel;
     Separator: typeof SelectSeparator;
 };
+/**
+ * Select Component with Sub-components
+ * Properly typed interface for dot notation access (e.g., Select.Trigger).
+ * The annotation is what keeps declaration emit portable — see Dialog.tsx (TS2883).
+ */
+declare const Select: SelectComponent;
 export { Select, SelectTrigger, SelectValue, SelectContent, SelectItem, SelectGroup, SelectLabel, SelectSeparator, };
 export type { SelectSize, SelectTriggerProps, SelectValueProps, SelectContentProps, SelectItemProps, SelectGroupProps, SelectLabelProps, SelectSeparatorProps, };

package/dist/components/Select.js

@@ -210,7 +210,8 @@ const styles = StyleSheet.create({
 });
 /**
  * Select Component with Sub-components
- * Properly typed interface for dot notation access (e.g., Select.Trigger)
+ * Properly typed interface for dot notation access (e.g., Select.Trigger).
+ * The annotation is what keeps declaration emit portable — see Dialog.tsx (TS2883).
  */
 const Select = Object.assign(SelectRoot, {
     Trigger: SelectTrigger,

package/dist/components/StatusBar.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect } from "react";
 import { useTheme } from "../hooks/useTheme.js";
-import { StatusBar as RNStatusBar, Platform } from "react-native";
+import { StatusBar as RNStatusBar } from "react-native";
 export const StatusBar = () => {
     const { scheme, theme } = useTheme();
     const barStyle = scheme === "dark" ? "light-content" : "dark-content";
@@ -10,10 +10,6 @@ export const StatusBar = () => {
      */
     useEffect(() => {
         RNStatusBar.setBarStyle(barStyle, true);
-        if (Platform.OS === "android") {
-            RNStatusBar.setBackgroundColor("transparent", true);
-            RNStatusBar.setTranslucent(true);
-        }
     }, [barStyle]);
-    return (_jsx(RNStatusBar, { barStyle: barStyle, backgroundColor: Platform.OS === "android" ? "transparent" : undefined, translucent: true }));
+    return _jsx(RNStatusBar, { barStyle: barStyle });
 };

package/dist/components/StyledText.context.d.ts

@@ -2,5 +2,5 @@ import React from "react";
 import type { StyleProp, TextStyle } from "react-native";
 export declare const TextClassContext: React.Context<string | undefined>;
 export declare const TextColorContext: React.Context<string | undefined>;
-export declare const TextStyleContext: React.Context<StyleProp<TextStyle>>;
+export declare const TextStyleContext: React.Context<StyleProp<TextStyle> | undefined>;
 export declare const TextSelectabilityContext: React.Context<boolean | undefined>;

package/dist/components/StyledText.d.ts

@@ -1,4 +1,4 @@
-import { type Ref } from "react";
+import { type ComponentRef, type Ref } from "react";
 import { Text as RNText, TextProps as RNTextProps } from "react-native";
 import { type FontVariant } from "../constants/fonts";
 /**
@@ -55,8 +55,12 @@ export type TextProps = RNTextProps & {
     txOptions?: object;
     /**
      * Forwarded ref to the underlying RNText element.
+     *
+     * Written as `ComponentRef<typeof RNText>` rather than RN 0.88's `TextInstance`
+     * alias so the emitted declarations stay valid on RN 0.85/0.86, whose typings
+     * do not export that name.
      */
-    ref?: Ref<RNText>;
+    ref?: Ref<ComponentRef<typeof RNText>>;
 };
 /**
  * Base Text component with theme and variant support

package/dist/components/TextInput.d.ts

@@ -1,4 +1,4 @@
-import { type ReactNode, type Ref } from "react";
+import { type ComponentRef, type ReactNode, type Ref } from "react";
 import { TextInput as RNTextInput, ViewStyle, TextStyle, TextInputProps, StyleProp } from "react-native";
 /**
  * Size variants for TextInput
@@ -11,8 +11,12 @@ export type TextInputVariant = "outline" | "filled" | "underlined";
 interface TextInputCustomProps extends TextInputProps {
     /**
      * Forwarded ref to the underlying RNTextInput element.
+     *
+     * Written as `ComponentRef<typeof RNTextInput>` rather than RN 0.88's
+     * `TextInputInstance` alias so the emitted declarations stay valid on
+     * RN 0.85/0.86, whose typings do not export that name.
      */
-    ref?: Ref<RNTextInput>;
+    ref?: Ref<ComponentRef<typeof RNTextInput>>;
     /**
      * Visual variant
      * @default "outline"