@grupalia/rn-ui-kit 0.15.0 → 0.17.0

package/src/hooks/useInternetConnectionStatus.ts

@@ -0,0 +1,221 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useNetInfo } from '@react-native-community/netinfo';
+import {
+  useState, useEffect, useCallback, useRef, useMemo,
+} from 'react';
+
+import { MS_IN_A_SECOND } from '../utils/timeConstants';
+
+export interface InternetConnectionStatus {
+  isConnected: boolean | null;
+  isLoading: boolean;
+  lastChecked: Date | null;
+  isWeakConnection: boolean;
+}
+
+export interface InternetConnectionStatusProps {
+  checkInterval?: number;
+  timeout?: number;
+  checkHealth: () => Promise<{ ok: boolean }>;
+}
+
+interface CachedInternetConnectionStatus {
+  hasInternetAccess: boolean;
+  timestamp: number;
+}
+
+const DEFAULT_SETTINGS: Required<Omit<InternetConnectionStatusProps, 'checkHealth'>> = {
+  checkInterval: 15 * MS_IN_A_SECOND,
+  timeout: 5 * MS_IN_A_SECOND,
+};
+
+const CACHE_KEY = 'internet_connectivity_status';
+const CACHE_EXPIRY_TIME = 10 * MS_IN_A_SECOND;
+const STRONG_CONNECTION_THRESHOLD = 20;
+
+let ongoingNetworkTest: Promise<boolean> | null = null;
+
+// Global event broadcaster for syncing all instances
+const globalListeners = new Set<(hasInternetAccess: boolean | null) => void>();
+
+function broadcastConnectionChange(hasInternetAccess: boolean | null) {
+  globalListeners.forEach((listener) => {
+    try {
+      listener(hasInternetAccess);
+    } catch {
+      // Ignore listener errors
+    }
+  });
+}
+
+async function getCachedStatus() {
+  try {
+    const cached = await AsyncStorage.getItem(CACHE_KEY);
+    if (!cached) return null;
+
+    const parsedCache: CachedInternetConnectionStatus = JSON.parse(cached);
+    const isExpired = Date.now() - parsedCache.timestamp > CACHE_EXPIRY_TIME;
+
+    if (isExpired) {
+      await AsyncStorage.removeItem(CACHE_KEY);
+      return null;
+    }
+
+    return parsedCache;
+  } catch {
+    return null;
+  }
+}
+
+async function setCachedStatus(internetAccess: boolean) {
+  try {
+    const cacheData: CachedInternetConnectionStatus = {
+      hasInternetAccess: internetAccess,
+      timestamp: Date.now(),
+    };
+    await AsyncStorage.setItem(CACHE_KEY, JSON.stringify(cacheData));
+  } catch {
+    // Silently fail if we can't write to cache
+  }
+}
+
+export default function useInternetConnectionStatus(props: InternetConnectionStatusProps) {
+  const { checkInterval, timeout, checkHealth } = { ...DEFAULT_SETTINGS, ...props };
+
+  const netInfo = useNetInfo();
+
+  const [successfulHealthCheck, setSuccessfulHealthCheck] = useState<boolean | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [lastChecked, setLastChecked] = useState<Date | null>(null);
+
+  const intervalRef = useRef<NodeJS.Timeout | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const cleanupIntervals = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+
+  const performNetworkTest = useCallback(async (): Promise<boolean> => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+
+    const timeoutId = setTimeout(() => {
+      abortController.abort();
+    }, timeout);
+
+    try {
+      const response = await checkHealth();
+
+      clearTimeout(timeoutId);
+      const isConnected = response.ok;
+
+      await setCachedStatus(isConnected);
+
+      setSuccessfulHealthCheck(isConnected);
+      setLastChecked(new Date());
+
+      broadcastConnectionChange(isConnected);
+
+      return isConnected;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === 'AbortError') return false;
+
+      await setCachedStatus(false);
+
+      setSuccessfulHealthCheck(false);
+      setLastChecked(new Date());
+
+      broadcastConnectionChange(false);
+
+      return false;
+    } finally {
+      abortControllerRef.current = null;
+    }
+  }, [timeout]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const requestCachedStatusOrPerformNetworkTest = useCallback(async () => {
+    const cachedStatus = await getCachedStatus();
+    if (cachedStatus) {
+      setSuccessfulHealthCheck(cachedStatus.hasInternetAccess);
+      setLastChecked(new Date(cachedStatus.timestamp));
+
+      return cachedStatus.hasInternetAccess;
+    }
+
+    setIsLoading(true);
+
+    if (ongoingNetworkTest) {
+      try {
+        const result = await ongoingNetworkTest;
+        return result;
+      } catch {
+        return false;
+      } finally {
+        setIsLoading(false);
+      }
+    }
+
+    ongoingNetworkTest = performNetworkTest();
+
+    try {
+      const result = await ongoingNetworkTest;
+      return result;
+    } catch {
+      return false;
+    } finally {
+      setIsLoading(false);
+      ongoingNetworkTest = null;
+    }
+  }, [performNetworkTest]);
+
+  // Setup
+  useEffect(() => {
+    cleanupIntervals();
+
+    if (checkInterval > 0) {
+      requestCachedStatusOrPerformNetworkTest();
+
+      intervalRef.current = setInterval(() => {
+        requestCachedStatusOrPerformNetworkTest();
+      }, checkInterval);
+    }
+
+    return cleanupIntervals;
+  }, [requestCachedStatusOrPerformNetworkTest, cleanupIntervals, checkInterval]);
+
+  const { isConnected, type, details } = netInfo;
+
+  const result = useMemo(() => ({
+    isConnected: successfulHealthCheck,
+    isLoading,
+    lastChecked,
+    isWeakConnection: isConnected === true && type === 'wifi' && details.strength && details.strength < STRONG_CONNECTION_THRESHOLD,
+  }), [successfulHealthCheck, isLoading, lastChecked, isConnected, type, details]);
+
+  // Listen for changes from other instances
+  useEffect(() => {
+    const listener = (globalHasInternetAccess: boolean | null) => {
+      if (successfulHealthCheck !== globalHasInternetAccess) {
+        setSuccessfulHealthCheck(globalHasInternetAccess);
+        AsyncStorage.removeItem(CACHE_KEY).catch(() => {});
+      }
+    };
+
+    globalListeners.add(listener);
+    return () => { globalListeners.delete(listener); };
+  }, [successfulHealthCheck]);
+
+  return result;
+}

package/src/hooks/useIsAboveBreakpoint.ts

@@ -0,0 +1,8 @@
+import { useWindowDimensions } from 'react-native';
+
+import { BREAKPOINTS, Breakpoint } from './useBreakpoints';
+
+export function useIsAboveBreakpoint(minBreakpoint: Breakpoint): boolean {
+  const { width } = useWindowDimensions();
+  return width >= BREAKPOINTS[minBreakpoint];
+}

package/src/utils/date.ts

@@ -0,0 +1 @@
+export const WEEKDAY_NAMES = ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'];

package/src/utils/fileDirectoryUtils.ts

@@ -0,0 +1,12 @@
+import * as FileSystem from 'expo-file-system';
+
+const ensureDirExists = async (dirPath: string) => {
+  const dirInfo = await FileSystem.getInfoAsync(dirPath);
+  if (!dirInfo.exists) {
+    await FileSystem.makeDirectoryAsync(dirPath, { intermediates: true });
+  }
+
+  return dirPath;
+};
+
+export { ensureDirExists };

package/src/utils/index.ts

@@ -1 +1,3 @@
 export * from './clabe';
+export * from './fileDirectoryUtils';
+export * from './timeConstants';

package/src/utils/timeConstants.ts

@@ -0,0 +1,19 @@
+const MS_IN_A_SECOND = 1_000;
+const HOURS_IN_A_DAY = 24;
+const MINUTES_IN_A_HOUR = 60;
+const SECONDS_IN_A_MINUTE = 60;
+const DAYS_IN_A_WEEK = 7;
+const MS_IN_A_DAY = MS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_A_HOUR * HOURS_IN_A_DAY;
+const MS_IN_A_MINUTE = MS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+const MS_IN_A_WEEK = MS_IN_A_DAY * DAYS_IN_A_WEEK;
+
+export {
+  MS_IN_A_SECOND,
+  HOURS_IN_A_DAY,
+  MINUTES_IN_A_HOUR,
+  SECONDS_IN_A_MINUTE,
+  DAYS_IN_A_WEEK,
+  MS_IN_A_DAY,
+  MS_IN_A_MINUTE,
+  MS_IN_A_WEEK,
+};