Function bodies 299 total

TopBar function · typescript · L13-L70 (58 LOC)

src/components/TopBar.tsx

export default function TopBar(): React.JSX.Element {
  const { colors } = useTheme();
  const navigation = useNavigation<any>();
  const [pictureUrl, setPictureUrl] = useState<string | null>(null);

  const activeTabName = useNavigationState(state => {
    const tabRoute = state?.routes?.[0];
    const tabState = tabRoute?.state;
    if (tabState) {
      const activeRoute = tabState.routes[tabState.index ?? 0];
      return activeRoute?.name ?? 'Home';
    }
    return 'Home';
  });

  useFocusEffect(
    useCallback(() => {
      loadUserProfile().then(profile => {
        setPictureUrl(profile?.profilePictureUrl ?? null);
      });
    }, []),
  );

  return (
    <View style={[s.bar, { backgroundColor: colors.background, borderBottomColor: colors.borderLight }]}>
      <TouchableOpacity
        onPress={() => navigation.navigate('ProfileScreen')}
        activeOpacity={0.7}
        hitSlop={{ top: 8, bottom: 8, left: 8, right: 8 }}
      >
        {pictureUrl ? (
          <Image

UpdatePlanModal function · typescript · L37-L210 (174 LOC)

src/components/UpdatePlanModal.tsx

export default function UpdatePlanModal({ visible, onClose, onPlanUpdated }: Props) {
  const { colors, isDark } = useTheme();
  const [request, setRequest] = useState('');
  const [loading, setLoading] = useState(false);
  const [preview, setPreview] = useState<string | null>(null);
  const [error, setError] = useState<string | null>(null);

  const handleGenerate = useCallback(async () => {
    if (!request.trim()) return;
    setLoading(true);
    setError(null);
    setPreview(null);

    try {
      const [apiKey, profile] = await Promise.all([getApiKey(), loadUserProfile()]);
      if (!apiKey) throw new Error('No API key found');
      if (!profile) throw new Error('No profile found');

      const systemPrompt = await buildChatSystemPrompt(profile);
      const messages = [
        {
          role: 'user' as const,
          content: `I'd like to update my nutrition/fitness plan. Here's what I want to change:\n\n${request.trim()}\n\nPlease generate a complete updated plan base

generateNonce function · typescript · L15-L22 (8 LOC)

src/contexts/AuthContext.tsx

function generateNonce(length = 32): string {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return result;
}

useAuth function · typescript · L59-L61 (3 LOC)

src/contexts/AuthContext.tsx

export function useAuth() {
  return useContext(AuthContext);
}

AuthProvider function · typescript · L63-L202 (140 LOC)

src/contexts/AuthContext.tsx

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [session, setSession] = useState<Session | null>(null);
  const [user, setUser] = useState<User | null>(null);
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    supabase.auth.getSession().then(({ data: { session: s } }) => {
      setSession(s);
      setUser(s?.user ?? null);
      setIsLoading(false);
    });

    const { data: { subscription } } = supabase.auth.onAuthStateChange(
      (_event, s) => {
        setSession(s);
        setUser(s?.user ?? null);
      },
    );

    return () => subscription.unsubscribe();
  }, []);

  const signUp = useCallback(async (email: string, password: string) => {
    const { error } = await supabase.auth.signUp({ email, password });
    return { error: error?.message ?? null };
  }, []);

  const signIn = useCallback(async (email: string, password: string) => {
    const { error } = await supabase.auth.signInWithPassword({ email, pass

ChatProvider function · typescript · L36-L105 (70 LOC)

src/contexts/ChatContext.tsx

export function ChatProvider({ children }: { children: React.ReactNode }) {
  const [isReady, setIsReady] = useState(false);
  const [messages, setMessages] = useState<Message[]>([]);
  const [apiKey, setApiKey] = useState<string | null>(null);
  const [profile, setProfile] = useState<UserProfile | null>(null);
  const [conversationSummary, setConversationSummary] = useState<string | null>(null);

  // Load initial state once on mount
  useEffect(() => {
    let cancelled = false;
    Promise.all([
      loadMessages(),
      getApiKey(),
      loadUserProfile(),
      loadConversationSummary(),
    ]).then(([savedMessages, storedKey, storedProfile, storedSummary]) => {
      if (cancelled) return;
      setMessages(savedMessages);
      setApiKey(storedKey);
      setProfile(storedProfile);
      setConversationSummary(storedSummary);
      setIsReady(true);
    });
    return () => { cancelled = true; };
  }, []);

  // Persist messages whenever they change (debounced by React batchi

useChatContext function · typescript · L109-L115 (7 LOC)

src/contexts/ChatContext.tsx

export function useChatContext(): ChatContextValue {
  const ctx = useContext(ChatContext);
  if (!ctx) {
    throw new Error('useChatContext must be used within a ChatProvider');
  }
  return ctx;
}

Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)

useImpersonation function · typescript · L26-L28 (3 LOC)

src/contexts/ImpersonationContext.tsx

export function useImpersonation() {
  return useContext(ImpersonationContext);
}

ImpersonationProvider function · typescript · L30-L112 (83 LOC)

src/contexts/ImpersonationContext.tsx

export function ImpersonationProvider({ children }: { children: React.ReactNode }) {
  const [isImpersonating, setIsImpersonating] = useState(false);
  const [isSwitching, setIsSwitching] = useState(false);
  const [impersonatedLabel, setImpersonatedLabel] = useState<string | null>(null);
  const stashedSession = useRef<StashedSession | null>(null);

  const switchToUser = useCallback(async (email: string, password: string, label: string) => {
    try {
      setIsSwitching(true);

      const { data: { session: currentSession } } = await supabase.auth.getSession();
      if (currentSession) {
        stashedSession.current = {
          access_token: currentSession.access_token,
          refresh_token: currentSession.refresh_token,
        };
      }

      await supabase.auth.signOut();

      const { error } = await supabase.auth.signInWithPassword({ email, password });
      if (error) {
        if (stashedSession.current) {
          await supabase.auth.setSession(stashedSession.

ThemeProvider function · typescript · L101-L135 (35 LOC)

src/contexts/ThemeContext.tsx

export function ThemeProvider({ children }: { children: React.ReactNode }) {
  const systemScheme = useColorScheme();
  const [mode, setModeState] = useState<ThemeMode>('system');
  const [loaded, setLoaded] = useState(false);

  useEffect(() => {
    AsyncStorage.getItem(STORAGE_KEY).then(stored => {
      if (stored === 'light' || stored === 'dark' || stored === 'system') {
        setModeState(stored);
      }
      setLoaded(true);
    });
  }, []);

  const setMode = useCallback((newMode: ThemeMode) => {
    setModeState(newMode);
    AsyncStorage.setItem(STORAGE_KEY, newMode);
  }, []);

  const isDark = mode === 'dark' || (mode === 'system' && systemScheme === 'dark');
  const colors = isDark ? DARK : LIGHT;

  const value = useMemo(
    () => ({ mode, isDark, colors, setMode }),
    [mode, isDark, colors, setMode],
  );

  if (!loaded) return null;

  return (
    <ThemeContext.Provider value={value}>
      {children}
    </ThemeContext.Provider>
  );
}

useTheme function · typescript · L137-L139 (3 LOC)

src/contexts/ThemeContext.tsx

export function useTheme(): ThemeContextValue {
  return useContext(ThemeContext);
}

useAsyncData function · typescript · L22-L74 (53 LOC)

src/hooks/useAsyncData.ts

export function useAsyncData<T>(
  fetcher: () => Promise<T>,
  options?: UseAsyncDataOptions<T>,
): UseAsyncDataResult<T> {
  const deps = options?.deps ?? [];
  const [data, setData] = useState<T | undefined>(options?.initialData);
  const [loading, setLoading] = useState(!options?.manual);
  const [refreshing, setRefreshing] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const mountedRef = useRef(true);

  useEffect(() => {
    mountedRef.current = true;
    return () => { mountedRef.current = false; };
  }, []);

  const fetchData = useCallback(async (isRefresh: boolean) => {
    if (isRefresh) {
      setRefreshing(true);
    } else {
      setLoading(true);
    }
    setError(null);

    try {
      const result = await fetcher();
      if (mountedRef.current) {
        setData(result);
      }
    } catch (err) {
      if (mountedRef.current) {
        setError(getUserFriendlyError(err));
      }
    } finally {
      if (mountedRef.current) {

todayKey function · typescript · L8-L11 (4 LOC)

src/hooks/useDayChange.ts

function todayKey(): string {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}

useDayChange function · typescript · L22-L46 (25 LOC)

src/hooks/useDayChange.ts

export function useDayChange(onDayChange: () => void): void {
  const lastDate = useRef(todayKey());

  useEffect(() => {
    const check = () => {
      const now = todayKey();
      if (now !== lastDate.current) {
        lastDate.current = now;
        onDayChange();
      }
    };

    const interval = setInterval(check, 30_000);

    const handleAppState = (state: AppStateStatus) => {
      if (state === 'active') check();
    };
    const subscription = AppState.addEventListener('change', handleAppState);

    return () => {
      clearInterval(interval);
      subscription.remove();
    };
  }, [onDayChange]);
}

useDeepLink function · typescript · L6-L25 (20 LOC)

src/hooks/useDeepLink.ts

export function useDeepLink(onAction: (action: DeepLinkAction) => void) {
  const onActionRef = useRef(onAction);
  onActionRef.current = onAction;

  const handleURL = useCallback((url: string | null) => {
    if (!url) return;
    if (url === 'noomibodi://add-photo') {
      onActionRef.current('add-photo');
    } else if (url === 'noomibodi://quick-log') {
      onActionRef.current('quick-log');
    }
  }, []);

  useEffect(() => {
    Linking.getInitialURL().then(handleURL);

    const sub = Linking.addEventListener('url', ({ url }) => handleURL(url));
    return () => sub.remove();
  }, [handleURL]);
}

If a scraper extracted this row, it came from Repobility (https://repobility.com)

handleNotificationNavigation function · typescript · L16-L32 (17 LOC)

src/hooks/useNotifications.ts

function handleNotificationNavigation(
  remoteMessage: FirebaseMessagingTypes.RemoteMessage | null,
  navRef: React.RefObject<NavigationContainerRef<any> | null>,
) {
  if (!remoteMessage?.data?.type || !navRef.current) return;

  switch (remoteMessage.data.type) {
    case 'friend_request':
    case 'friend_accepted':
    case 'streak_milestone':
      navRef.current.navigate('MainTabs' as never, { screen: 'Social' } as never);
      break;
    case 'shared_meal':
      navRef.current.navigate('MainTabs' as never, { screen: 'Meals' } as never);
      break;
  }
}

useNotifications function · typescript · L34-L71 (38 LOC)

src/hooks/useNotifications.ts

export function useNotifications(
  enabled: boolean,
  navigationRef: React.RefObject<NavigationContainerRef<any> | null>,
) {
  const initialized = useRef(false);

  useEffect(() => {
    if (!enabled || initialized.current) return;
    initialized.current = true;

    const messaging = getMessaging();

    registerForPushNotifications().catch(() => {});

    const unsubRefresh = onTokenRefresh(token => {
      upsertToken(token).catch(() => {});
    });

    const unsubForeground = onMessage(messaging, async _remoteMessage => {
      // No in-app banner; user already sees data on-screen
    });

    const unsubBackground = onNotificationOpenedApp(messaging, remoteMessage => {
      handleNotificationNavigation(remoteMessage, navigationRef);
    });

    getInitialNotification(messaging).then(remoteMessage => {
      handleNotificationNavigation(remoteMessage, navigationRef);
    });

    return () => {
      initialized.current = false;
      unsubRefresh();
      unsubForeground();

useOfflineSync function · typescript · L18-L52 (35 LOC)

src/hooks/useOfflineSync.ts

export function useOfflineSync(onSynced?: () => void): OfflineSyncResult {
  const { isOnline } = useNetworkStatus();
  const wasOffline = useRef(false);
  const [pendingCount, setPendingCount] = useState(0);

  const refreshPendingCount = useCallback(async () => {
    const q = await getQueue();
    setPendingCount(q.length);
  }, []);

  const syncNow = useCallback(async () => {
    const { synced } = await flushQueue();
    await refreshPendingCount();
    if (synced > 0) onSynced?.();
  }, [onSynced, refreshPendingCount]);

  // Flush when transitioning from offline → online
  useEffect(() => {
    if (!isOnline) {
      wasOffline.current = true;
      return;
    }
    if (wasOffline.current) {
      wasOffline.current = false;
      syncNow();
    }
  }, [isOnline, syncNow]);

  // Check queue size on mount and whenever online state changes
  useEffect(() => {
    refreshPendingCount();
  }, [isOnline, refreshPendingCount]);

  return { isOnline, pendingCount, syncNow };
}

useStaleFetch function · typescript · L12-L39 (28 LOC)

src/hooks/useStaleFetch.ts

export function useStaleFetch(
  fetchFn: (isRefresh: boolean) => Promise<void>,
  staleTimeMs: number = 30_000,
) {
  const lastFetchedAt = useRef<number>(0);

  const fetchIfStale = useCallback(async () => {
    const now = Date.now();
    const elapsed = now - lastFetchedAt.current;
    const isFirstLoad = lastFetchedAt.current === 0;

    if (!isFirstLoad && elapsed < staleTimeMs) return;

    lastFetchedAt.current = now;
    await fetchFn(isFirstLoad ? false : true);
  }, [fetchFn, staleTimeMs]);

  const forceFetch = useCallback(async () => {
    lastFetchedAt.current = Date.now();
    await fetchFn(true);
  }, [fetchFn]);

  const markStale = useCallback(() => {
    lastFetchedAt.current = 0;
  }, []);

  return { fetchIfStale, forceFetch, markStale };
}

AddFriendModal function · typescript · L37-L226 (190 LOC)

src/screens/AddFriendModal.tsx

export default function AddFriendModal({
  visible,
  onClose,
  onFriendAdded,
}: AddFriendModalProps) {
  const { colors } = useTheme();
  const [query, setQuery] = useState('');
  const [results, setResults] = useState<SearchResult[]>([]);
  const [loading, setLoading] = useState(false);
  const [actionLoading, setActionLoading] = useState<string | null>(null);
  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);

  useEffect(() => {
    if (!visible) {
      setQuery('');
      setResults([]);
    }
  }, [visible]);

  const handleSearch = useCallback(async (text: string) => {
    if (text.length < 2) {
      setResults([]);
      return;
    }
    setLoading(true);
    try {
      const users = await searchUsers(text);
      const enriched = await Promise.all(
        users.map(async u => {
          const { status, friendshipId } = await getFriendshipStatus(u.id);
          return { ...u, relationship: status, friendshipId };
        }),
      );
      setRes

fmtNum function · typescript · L55-L57 (3 LOC)