@oxyhq/services 6.9.14 → 6.9.15

package/src/ui/components/CrossFadeIcon.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const Icon_1 = __importStar(require("./Icon"));
+const theming_1 = require("./theming");
+const CrossFadeIcon = ({ color, size, source, theme: themeOverrides, testID = 'cross-fade-icon', }) => {
+    const theme = (0, theming_1.useInternalTheme)(themeOverrides);
+    const [currentIcon, setCurrentIcon] = React.useState(() => source);
+    const [previousIcon, setPreviousIcon] = React.useState(null);
+    const { current: fade } = React.useRef(new react_native_1.Animated.Value(1));
+    const { scale } = theme.animation;
+    if (currentIcon !== source) {
+        setPreviousIcon(() => currentIcon);
+        setCurrentIcon(() => source);
+    }
+    React.useEffect(() => {
+        if ((0, Icon_1.isValidIcon)(previousIcon) && !(0, Icon_1.isEqualIcon)(previousIcon, currentIcon)) {
+            fade.setValue(1);
+            react_native_1.Animated.timing(fade, {
+                duration: scale * 200,
+                toValue: 0,
+                useNativeDriver: true,
+            }).start();
+        }
+    }, [currentIcon, previousIcon, scale]);
+    const opacityPrev = fade;
+    const opacityNext = previousIcon
+        ? fade.interpolate({
+            inputRange: [0, 1],
+            outputRange: [1, 0],
+        })
+        : 1;
+    const rotatePrev = fade.interpolate({
+        inputRange: [0, 1],
+        outputRange: ['-90deg', '0deg'],
+    });
+    const rotateNext = previousIcon
+        ? fade.interpolate({
+            inputRange: [0, 1],
+            outputRange: ['0deg', '-180deg'],
+        })
+        : '0deg';
+    return ((0, jsx_runtime_1.jsxs)(react_native_1.View, { style: [
+            styles.content,
+            {
+                height: size,
+                width: size,
+            },
+        ], children: [previousIcon ? ((0, jsx_runtime_1.jsx)(react_native_1.Animated.View, { style: [
+                    styles.icon,
+                    {
+                        opacity: opacityPrev,
+                        transform: [{ rotate: rotatePrev }],
+                    },
+                ], testID: `${testID}-previous`, children: (0, jsx_runtime_1.jsx)(Icon_1.default, { source: previousIcon, size: size, color: color, theme: theme }) })) : null, (0, jsx_runtime_1.jsx)(react_native_1.Animated.View, { style: [
+                    styles.icon,
+                    {
+                        opacity: opacityNext,
+                        transform: [{ rotate: rotateNext }],
+                    },
+                ], testID: `${testID}-current`, children: (0, jsx_runtime_1.jsx)(Icon_1.default, { source: currentIcon, size: size, color: color, theme: theme }) })] }));
+};
+exports.default = CrossFadeIcon;
+const styles = react_native_1.StyleSheet.create({
+    content: {
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    icon: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+    },
+});

package/src/ui/components/EmptyState.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface EmptyStateProps {
+    message: string;
+    textColor?: string;
+}
+declare const _default: React.NamedExoticComponent<EmptyStateProps>;
+export default _default;

package/src/ui/components/EmptyState.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+/**
+ * Reusable empty state component
+ * Provides consistent empty state displays across screens
+ */
+const EmptyState = ({ message, textColor, }) => {
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: styles.container, children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: [styles.message, textColor ? { color: textColor } : undefined], children: message }) }));
+};
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        padding: 40,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    message: {
+        fontSize: 16,
+        textAlign: 'center',
+    },
+});
+exports.default = react_1.default.memo(EmptyState);

package/src/ui/components/FollowButton.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { type ViewStyle, type TextStyle, type StyleProp } from 'react-native';
+export interface FollowButtonProps {
+    userId: string;
+    initiallyFollowing?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    onFollowChange?: (isFollowing: boolean) => void;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    disabled?: boolean;
+    showLoadingState?: boolean;
+    preventParentActions?: boolean;
+    theme?: 'light' | 'dark';
+}
+/**
+ * Outer wrapper that handles the "should we render?" check.
+ *
+ * This is the ONLY place useOxy() is called — to check authentication and
+ * get the current user ID for the self-follow guard. The oxyServices instance
+ * is passed down as a prop to the inner component, which avoids subscribing
+ * to the full OxyContext.
+ *
+ * The early return happens BEFORE the inner component mounts, so the inner
+ * component's hooks are never called conditionally (no Rules of Hooks violation).
+ */
+declare const FollowButton: React.FC<FollowButtonProps>;
+export { FollowButton };
+export default FollowButton;

package/src/ui/components/FollowButton.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowButton = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const react_native_reanimated_1 = __importStar(require("react-native-reanimated"));
+const OxyContext_1 = require("../context/OxyContext");
+const fonts_1 = require("../styles/fonts");
+const sonner_1 = require("../../lib/sonner");
+const useFollow_1 = require("../hooks/useFollow");
+const theme_1 = require("../styles/theme");
+// Create animated TouchableOpacity
+const AnimatedTouchableOpacity = react_native_reanimated_1.default.createAnimatedComponent(react_native_1.TouchableOpacity);
+const AnimatedText = react_native_reanimated_1.default.createAnimatedComponent(react_native_1.Text);
+/**
+ * Inner component that handles all hooks and rendering.
+ *
+ * Separated from the outer wrapper to avoid a Rules of Hooks violation.
+ * The outer wrapper handles the auth/self-follow guard and returns null
+ * before any hooks are called. This inner component always renders
+ * (all hooks are called unconditionally).
+ *
+ * Receives oxyServices as a prop instead of calling useOxy(), so it does
+ * not subscribe to the OxyContext. This is critical in list contexts where
+ * N buttons would all re-render on any context change (session socket events,
+ * token refreshes, etc.).
+ */
+const FollowButtonInner = (0, react_1.memo)(function FollowButtonInner({ userId, oxyServices, initiallyFollowing = false, size = 'medium', onFollowChange, style, textStyle, disabled = false, showLoadingState = true, preventParentActions = true, theme = 'light', }) {
+    const colors = (0, theme_1.useThemeColors)(theme);
+    // Uses granular Zustand selectors — only re-renders when THIS user's data changes
+    const { isFollowing, isLoading, toggleFollow, setFollowStatus, fetchStatus, } = (0, useFollow_1.useFollowForButton)(userId, oxyServices);
+    // Animation values
+    const animationProgress = (0, react_native_reanimated_1.useSharedValue)(isFollowing ? 1 : 0);
+    const scale = (0, react_native_reanimated_1.useSharedValue)(1);
+    // Stable press handler — depends on primitives only
+    const handlePress = (0, react_1.useCallback)(async (event) => {
+        if (preventParentActions && event && event.preventDefault) {
+            event.preventDefault();
+            event.stopPropagation?.();
+        }
+        if (disabled || isLoading)
+            return;
+        // Press animation
+        scale.value = (0, react_native_reanimated_1.withTiming)(0.95, { duration: 100 }, (finished) => {
+            if (finished) {
+                scale.value = (0, react_native_reanimated_1.withSpring)(1, { damping: 15, stiffness: 200 });
+            }
+        });
+        try {
+            await toggleFollow();
+            if (onFollowChange)
+                onFollowChange(!isFollowing);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            sonner_1.toast.error(error.message || 'Failed to update follow status');
+        }
+    }, [disabled, isLoading, toggleFollow, onFollowChange, isFollowing, preventParentActions, scale]);
+    // Set initial follow status on mount if provided and not already set
+    (0, react_1.useEffect)(() => {
+        if (userId && !isFollowing && initiallyFollowing) {
+            setFollowStatus(initiallyFollowing);
+        }
+        // Intentional: only run on mount with initial values
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [userId, initiallyFollowing]);
+    // Fetch latest follow status from backend on mount
+    (0, react_1.useEffect)(() => {
+        if (userId) {
+            fetchStatus();
+        }
+    }, [userId, fetchStatus]);
+    // Animate button on follow/unfollow
+    (0, react_1.useEffect)(() => {
+        animationProgress.value = (0, react_native_reanimated_1.withTiming)(isFollowing ? 1 : 0, { duration: 300, easing: react_native_reanimated_1.Easing.inOut(react_native_reanimated_1.Easing.ease) });
+    }, [isFollowing, animationProgress]);
+    // Animated styles
+    const animatedButtonStyle = (0, react_native_reanimated_1.useAnimatedStyle)(() => {
+        return {
+            transform: [{ scale: scale.value }],
+            backgroundColor: (0, react_native_reanimated_1.interpolateColor)(animationProgress.value, [0, 1], [colors.background, colors.primary]),
+            borderColor: (0, react_native_reanimated_1.interpolateColor)(animationProgress.value, [0, 1], [colors.border, colors.primary]),
+        };
+    }, [colors]);
+    const animatedTextStyle = (0, react_native_reanimated_1.useAnimatedStyle)(() => {
+        return {
+            color: (0, react_native_reanimated_1.interpolateColor)(animationProgress.value, [0, 1], [colors.text, '#FFFFFF']),
+        };
+    }, [colors]);
+    const baseButtonStyle = getBaseButtonStyle(size, style);
+    const baseTextStyle = getBaseTextStyle(size, textStyle);
+    return ((0, jsx_runtime_1.jsx)(AnimatedTouchableOpacity, { style: [baseButtonStyle, animatedButtonStyle], onPress: handlePress, disabled: disabled || isLoading, activeOpacity: 0.8, children: showLoadingState && isLoading ? ((0, jsx_runtime_1.jsx)(react_native_1.ActivityIndicator, { size: "small", color: isFollowing ? '#FFFFFF' : colors.primary })) : ((0, jsx_runtime_1.jsx)(AnimatedText, { style: [baseTextStyle, animatedTextStyle], children: isFollowing ? 'Following' : 'Follow' })) }));
+});
+/**
+ * Outer wrapper that handles the "should we render?" check.
+ *
+ * This is the ONLY place useOxy() is called — to check authentication and
+ * get the current user ID for the self-follow guard. The oxyServices instance
+ * is passed down as a prop to the inner component, which avoids subscribing
+ * to the full OxyContext.
+ *
+ * The early return happens BEFORE the inner component mounts, so the inner
+ * component's hooks are never called conditionally (no Rules of Hooks violation).
+ */
+const FollowButton = (props) => {
+    const { oxyServices, isAuthenticated, user: currentUser } = (0, OxyContext_1.useOxy)();
+    const currentUserId = currentUser?.id ? String(currentUser.id).trim() : '';
+    const targetUserId = props.userId ? String(props.userId).trim() : '';
+    // Don't render if not authenticated or viewing own profile
+    if (!isAuthenticated || !targetUserId || (currentUserId && currentUserId === targetUserId)) {
+        return null;
+    }
+    return ((0, jsx_runtime_1.jsx)(FollowButtonInner, { ...props, userId: targetUserId, oxyServices: oxyServices }));
+};
+exports.FollowButton = FollowButton;
+// Pure helper functions (no hooks, no state) extracted outside the component
+function getBaseButtonStyle(size, style) {
+    const baseStyle = {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'center',
+        borderWidth: 1,
+        ...react_native_1.Platform.select({
+            web: {},
+            default: {
+                shadowColor: '#000',
+                shadowOffset: { width: 0, height: 2 },
+                shadowOpacity: 0.1,
+                shadowRadius: 4,
+                elevation: 2,
+            }
+        }),
+    };
+    let sizeStyle;
+    if (size === 'small') {
+        sizeStyle = { paddingVertical: 6, paddingHorizontal: 12, minWidth: 70, borderRadius: 35 };
+    }
+    else if (size === 'large') {
+        sizeStyle = { paddingVertical: 12, paddingHorizontal: 24, minWidth: 120, borderRadius: 35 };
+    }
+    else {
+        sizeStyle = { paddingVertical: 8, paddingHorizontal: 16, minWidth: 90, borderRadius: 35 };
+    }
+    return [baseStyle, sizeStyle, style];
+}
+function getBaseTextStyle(size, textStyle) {
+    const baseTextStyle = {
+        fontFamily: fonts_1.fontFamilies.interSemiBold,
+        fontWeight: '600',
+    };
+    let sizeTextStyle;
+    if (size === 'small') {
+        sizeTextStyle = { fontSize: 13 };
+    }
+    else if (size === 'large') {
+        sizeTextStyle = { fontSize: 16 };
+    }
+    else {
+        sizeTextStyle = { fontSize: 15 };
+    }
+    return [baseTextStyle, sizeTextStyle, textStyle];
+}
+exports.default = FollowButton;

package/src/ui/components/FontLoader.d.ts

@@ -0,0 +1,14 @@
+import type React from 'react';
+/**
+ * FontLoader component that loads custom fonts in the background while rendering children immediately
+ * This works in both the package development and when consumed as an npm package
+ * Children render immediately with system fonts as fallback until custom fonts are loaded
+ */
+export declare const FontLoader: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Setup fonts for applications consuming this package
+ * This should be called by applications using your package
+ */
+export declare const setupFonts: () => Promise<boolean>;

package/src/ui/components/FontLoader.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupFonts = exports.FontLoader = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const Font = __importStar(require("expo-font"));
+/**
+ * Get the Inter font sources for both native and web environments
+ * This is specifically designed to work when distributed as an npm package
+ */
+const getInterFonts = () => {
+    try {
+        // For both development and when used as a package
+        // Load all static font weights
+        return {
+            'Inter-Light': require('../../assets/fonts/Inter/Inter_18pt-Light.ttf'),
+            'Inter-Regular': require('../../assets/fonts/Inter/Inter_18pt-Regular.ttf'),
+            'Inter-Medium': require('../../assets/fonts/Inter/Inter_18pt-Medium.ttf'),
+            'Inter-SemiBold': require('../../assets/fonts/Inter/Inter_18pt-SemiBold.ttf'),
+            'Inter-Bold': require('../../assets/fonts/Inter/Inter_18pt-Bold.ttf'),
+            'Inter-ExtraBold': require('../../assets/fonts/Inter/Inter_18pt-ExtraBold.ttf'),
+            'Inter-Black': require('../../assets/fonts/Inter/Inter_18pt-Black.ttf'),
+        };
+    }
+    catch (error) {
+        if (__DEV__) {
+            console.warn('Failed to load Inter fonts:', error);
+        }
+        return null;
+    }
+};
+/**
+ * FontLoader component that loads custom fonts in the background while rendering children immediately
+ * This works in both the package development and when consumed as an npm package
+ * Children render immediately with system fonts as fallback until custom fonts are loaded
+ */
+const FontLoader = ({ children, }) => {
+    const [fontState, setFontState] = (0, react_1.useState)('loading');
+    (0, react_1.useEffect)(() => {
+        const loadFonts = async () => {
+            try {
+                // Get all the font weights
+                const interFonts = getInterFonts();
+                if (!interFonts) {
+                    throw new Error('Inter font files not found');
+                }
+                // Load all the static Inter fonts with their respective weights
+                await Font.loadAsync(interFonts);
+                setFontState('loaded');
+            }
+            catch (error) {
+                if (__DEV__) {
+                    console.error('Error loading fonts:', error);
+                }
+                setFontState('error');
+            }
+        };
+        loadFonts();
+    }, []);
+    // Always render children immediately - fonts will load in background
+    // If fonts aren't loaded yet, the app will use system fonts as fallback
+    if (fontState === 'error' && __DEV__) {
+        console.warn('Fonts failed to load. Using system fonts instead.');
+    }
+    // Render children immediately, even while fonts are loading
+    // Fonts will apply when they're ready, otherwise system fonts are used
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
+};
+exports.FontLoader = FontLoader;
+/**
+ * Setup fonts for applications consuming this package
+ * This should be called by applications using your package
+ */
+const setupFonts = async () => {
+    try {
+        const interFonts = getInterFonts();
+        if (!interFonts) {
+            throw new Error('Inter font files not found');
+        }
+        if (react_native_1.Platform.OS === 'web') {
+            // For web platform, dynamically inject CSS to load the fonts
+            if (typeof document !== 'undefined') {
+                // Create a style element
+                const style = document.createElement('style');
+                // Define @font-face rules for each font weight
+                const fontFaceRules = `
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-Light']}) format('truetype');
+                        font-weight: 300;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-Regular']}) format('truetype');
+                        font-weight: 400;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-Medium']}) format('truetype');
+                        font-weight: 500;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-SemiBold']}) format('truetype');
+                        font-weight: 600;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-Bold']}) format('truetype');
+                        font-weight: 700;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-ExtraBold']}) format('truetype');
+                        font-weight: 800;
+                        font-style: normal;
+                    }
+                    @font-face {
+                        font-family: 'Inter';
+                        src: url(${interFonts['Inter-Black']}) format('truetype');
+                        font-weight: 900;
+                        font-style: normal;
+                    }
+                `;
+                style.textContent = fontFaceRules;
+                document.head.appendChild(style);
+                if (__DEV__) {
+                    console.info('All Inter web fonts have been dynamically loaded');
+                }
+            }
+        }
+        else {
+            // Attempt to load the fonts anyway (this works if the consumer has linked the assets)
+            await Font.loadAsync(interFonts);
+        }
+        return true;
+    }
+    catch (error) {
+        if (__DEV__) {
+            const errorMessage = error instanceof Error ? (error instanceof Error ? error.message : null) : String(error);
+            console.warn('Error setting up fonts:', errorMessage);
+        }
+        return false;
+    }
+};
+exports.setupFonts = setupFonts;

package/src/ui/components/GroupedItem.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+interface GroupedItemProps {
+    icon?: string;
+    iconColor?: string;
+    title: string;
+    subtitle?: string;
+    onPress?: () => void;
+    isFirst?: boolean;
+    isLast?: boolean;
+    showChevron?: boolean;
+    disabled?: boolean;
+    customContent?: React.ReactNode;
+    customIcon?: React.ReactNode;
+    /** Accessibility label (defaults to title) */
+    accessibilityLabel?: string;
+    /** Accessibility hint for what happens on press */
+    accessibilityHint?: string;
+}
+export declare const GroupedItem: React.MemoExoticComponent<{
+    ({ icon, iconColor, title, subtitle, onPress, isFirst, isLast, showChevron, disabled, customContent, customIcon, accessibilityLabel, accessibilityHint, }: GroupedItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export default GroupedItem;