create-gufran-expo-app 2.0.0 → 2.0.2

package/template/src/utils/scaling.ts

@@ -0,0 +1,14 @@
+import { Dimensions } from "react-native";
+
+export const { width, height } = Dimensions.get("screen");
+
+// Guideline sizes are based on standard ~5" screen mobile device
+const guidelineBaseWidth = 350;
+const guidelineBaseHeight = 680;
+
+const scale = (size: number) => (width / guidelineBaseWidth) * size;
+const verticalScale = (size: number) => (height / guidelineBaseHeight) * size;
+const moderateScale = (size: number, factor = 0.5) =>
+  size + (scale(size) - size) * factor;
+
+export { moderateScale, scale, verticalScale };

package/template/src/utils/storage.ts

@@ -0,0 +1,247 @@
+import { MMKV } from 'react-native-mmkv';
+
+// Create MMKV instances for different data types
+const storage = new MMKV({
+  id: 'club-yakka-storage',
+  encryptionKey: 'club-yakka-encryption-key', // In production, use a secure key
+});
+
+const authStorage = new MMKV({
+  id: 'club-yakka-auth',
+  encryptionKey: 'club-yakka-auth-key', // In production, use a secure key
+});
+
+// Generic storage interface
+interface StorageInterface {
+  setItem: (key: string, value: string) => void;
+  getItem: (key: string) => string | undefined;
+  removeItem: (key: string) => void;
+  getAllKeys: () => string[];
+  clear: () => void;
+  setObject: <T>(key: string, value: T) => void;
+  getObject: <T>(key: string) => T | undefined;
+  setBoolean: (key: string, value: boolean) => void;
+  getBoolean: (key: string) => boolean | undefined;
+  setNumber: (key: string, value: number) => void;
+  getNumber: (key: string) => number | undefined;
+}
+
+// Create storage utilities
+const createStorageUtil = (mmkvInstance: MMKV): StorageInterface => ({
+  setItem: (key: string, value: string) => {
+    mmkvInstance.set(key, value);
+  },
+
+  getItem: (key: string) => {
+    return mmkvInstance.getString(key);
+  },
+
+  removeItem: (key: string) => {
+    mmkvInstance.delete(key);
+  },
+
+  getAllKeys: () => {
+    return mmkvInstance.getAllKeys();
+  },
+
+  clear: () => {
+    mmkvInstance.clearAll();
+  },
+
+  setObject: <T>(key: string, value: T) => {
+    try {
+      mmkvInstance.set(key, JSON.stringify(value));
+    } catch (error) {
+      console.error(`Error storing object for key ${key}:`, error);
+    }
+  },
+
+  getObject: <T>(key: string): T | undefined => {
+    try {
+      const value = mmkvInstance.getString(key);
+      return value ? JSON.parse(value) : undefined;
+    } catch (error) {
+      console.error(`Error parsing object for key ${key}:`, error);
+      return undefined;
+    }
+  },
+
+  setBoolean: (key: string, value: boolean) => {
+    mmkvInstance.set(key, value);
+  },
+
+  getBoolean: (key: string) => {
+    return mmkvInstance.getBoolean(key);
+  },
+
+  setNumber: (key: string, value: number) => {
+    mmkvInstance.set(key, value);
+  },
+
+  getNumber: (key: string) => {
+    return mmkvInstance.getNumber(key);
+  },
+});
+
+// Export storage instances
+export const generalStorage = createStorageUtil(storage);
+export const secureStorage = createStorageUtil(authStorage);
+
+// Specific storage functions for common use cases
+export const StorageService = {
+  // Authentication related storage
+  auth: {
+    setToken: (token: string) => secureStorage.setItem('user_token', token),
+    getToken: () => secureStorage.getItem('user_token'),
+    removeToken: () => secureStorage.removeItem('user_token'),
+    
+    setAccessToken: (token: string) => {secureStorage.setItem('access_token', token);},
+    getAccessToken: () => {
+      const token = secureStorage.getItem('access_token')
+      return token;
+    },
+    removeAccessToken: () => secureStorage.removeItem('access_token'),
+    setAuthorizationToken: (token: string) => {
+      secureStorage.setItem('authorization_token', token);
+    },
+    getAuthorizationToken: () => {
+      const token = secureStorage.getItem('authorization_token');
+      return token;
+    },
+    removeAuthorizationToken: () => secureStorage.removeItem('authorization_token'),
+    
+    setUser: (user: any) => secureStorage.setObject('user_data', user),
+    getUser: () => secureStorage.getObject('user_data'),
+    removeUser: () => secureStorage.removeItem('user_data'),
+    
+    setTokens: (accessToken: string, authorizationToken: string) => {
+      secureStorage.setItem('access_token', accessToken);
+      secureStorage.setItem('authorization_token', authorizationToken);
+    },
+    
+    getTokens: () => {
+      const accessToken = secureStorage.getItem('access_token');
+      const authorizationToken = secureStorage.getItem('authorization_token');
+      
+      return {
+        accessToken,
+        authorizationToken,
+      };
+    },
+    
+    clearAuthData: () => {
+      console.log("🧹 STORAGE - clearAuthData() called");
+      secureStorage.removeItem('user_token');
+      secureStorage.removeItem('access_token');
+      secureStorage.removeItem('authorization_token');
+      secureStorage.removeItem('user_data');
+    },
+  },
+
+  // App preferences
+  preferences: {
+    setTheme: (theme: 'light' | 'dark') => generalStorage.setItem('theme_preference', theme),
+    getTheme: () => generalStorage.getItem('theme_preference') as 'light' | 'dark' | undefined,
+    
+    setLanguage: (language: string) => generalStorage.setItem('language_preference', language),
+    getLanguage: () => generalStorage.getItem('language_preference'),
+    
+    setNotificationsEnabled: (enabled: boolean) => generalStorage.setBoolean('notifications_enabled', enabled),
+    getNotificationsEnabled: () => generalStorage.getBoolean('notifications_enabled') ?? true,
+    
+    setBiometricEnabled: (enabled: boolean) => generalStorage.setBoolean('biometric_enabled', enabled),
+    getBiometricEnabled: () => generalStorage.getBoolean('biometric_enabled') ?? false,
+    
+    // Welcome screen tracking
+    setWelcomeScreenShown: (shown: boolean) => generalStorage.setBoolean('welcome_screen_shown', shown),
+    getWelcomeScreenShown: () => generalStorage.getBoolean('welcome_screen_shown') ?? false,
+  },
+
+  // App data cache
+  cache: {
+    set: <T>(key: string, data: T, ttl?: number) => {
+      const cacheData = {
+        data,
+        timestamp: Date.now(),
+        ttl: ttl || 0,
+      };
+      generalStorage.setObject(`cache_${key}`, cacheData);
+    },
+
+    get: <T>(key: string): T | undefined => {
+      const cacheData = generalStorage.getObject<{
+        data: T;
+        timestamp: number;
+        ttl: number;
+      }>(`cache_${key}`);
+
+      if (!cacheData) return undefined;
+
+      // Check if cache has expired
+      if (cacheData.ttl > 0 && Date.now() - cacheData.timestamp > cacheData.ttl) {
+        generalStorage.removeItem(`cache_${key}`);
+        return undefined;
+      }
+
+      return cacheData.data;
+    },
+
+    remove: (key: string) => generalStorage.removeItem(`cache_${key}`),
+
+    clear: () => {
+      const keys = generalStorage.getAllKeys();
+      keys.forEach(key => {
+        if (key.startsWith('cache_')) {
+          generalStorage.removeItem(key);
+        }
+      });
+    },
+  },
+
+  // Development utilities
+  dev: {
+    logAllKeys: () => {
+      console.log('General Storage Keys:', generalStorage.getAllKeys());
+      console.log('Secure Storage Keys:', secureStorage.getAllKeys());
+    },
+    
+    clearAll: () => {
+      generalStorage.clear();
+      secureStorage.clear();
+      console.log('All storage cleared');
+    },
+  },
+};
+
+// Hook for reactive storage updates (optional)
+export class StorageListener {
+  private listeners: Map<string, ((value: any) => void)[]> = new Map();
+
+  subscribe<T>(key: string, callback: (value: T) => void): () => void {
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, []);
+    }
+    
+    this.listeners.get(key)!.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const callbacks = this.listeners.get(key);
+      if (callbacks) {
+        const index = callbacks.indexOf(callback);
+        if (index > -1) {
+          callbacks.splice(index, 1);
+        }
+      }
+    };
+  }
+
+  notify(key: string, value: any) {
+    const callbacks = this.listeners.get(key);
+    if (callbacks) {
+      callbacks.forEach(callback => callback(value));
+    }
+  }
+}
+
+export const storageListener = new StorageListener();

package/template/src/utils/usePermissions.ts

@@ -0,0 +1,275 @@
+import { useState, useEffect, useCallback } from 'react';
+import { 
+  PermissionType, 
+  PermissionResult, 
+  PermissionRequestResult,
+  requestPermission,
+  getPermissionStatus,
+  requestMultiplePermissions,
+  getMultiplePermissionStatuses,
+  PermissionGroups,
+  requestPermissionGroup,
+  isPermissionGroupGranted,
+} from './permissions';
+
+/**
+ * Hook for managing a single permission
+ */
+export const usePermission = (permission: PermissionType) => {
+  const [status, setStatus] = useState<PermissionResult | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const checkStatus = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const result = await getPermissionStatus(permission);
+      setStatus(result);
+    } catch (error) {
+      console.error(`Error checking permission ${permission}:`, error);
+      setStatus({
+        status: 'denied',
+        canAskAgain: false,
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  }, [permission]);
+
+  const request = useCallback(async (): Promise<PermissionRequestResult> => {
+    try {
+      setIsLoading(true);
+      const result = await requestPermission(permission);
+      setStatus({
+        status: result.status,
+        canAskAgain: result.canAskAgain,
+        expires: result.expires,
+      });
+      return result;
+    } catch (error) {
+      console.error(`Error requesting permission ${permission}:`, error);
+      const errorResult: PermissionRequestResult = {
+        granted: false,
+        status: 'denied',
+        canAskAgain: false,
+      };
+      setStatus({
+        status: 'denied',
+        canAskAgain: false,
+      });
+      return errorResult;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [permission]);
+
+  useEffect(() => {
+    checkStatus();
+  }, [checkStatus]);
+
+  return {
+    status,
+    isLoading,
+    isGranted: status?.status === 'granted',
+    canAskAgain: status?.canAskAgain ?? false,
+    request,
+    refresh: checkStatus,
+  };
+};
+
+/**
+ * Hook for managing multiple permissions
+ */
+export const usePermissions = (permissions: PermissionType[]) => {
+  const [statuses, setStatuses] = useState<Record<PermissionType, PermissionResult> | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const checkStatuses = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const results = await getMultiplePermissionStatuses(permissions);
+      setStatuses(results);
+    } catch (error) {
+      console.error('Error checking permissions:', error);
+      const errorResults: Record<PermissionType, PermissionResult> = {} as any;
+      permissions.forEach(permission => {
+        errorResults[permission] = {
+          status: 'denied',
+          canAskAgain: false,
+        };
+      });
+      setStatuses(errorResults);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [permissions]);
+
+  const request = useCallback(async (): Promise<Record<PermissionType, PermissionRequestResult>> => {
+    try {
+      setIsLoading(true);
+      const results = await requestMultiplePermissions(permissions);
+      const statusResults: Record<PermissionType, PermissionResult> = {} as any;
+      
+      permissions.forEach(permission => {
+        const result = results[permission];
+        statusResults[permission] = {
+          status: result.status,
+          canAskAgain: result.canAskAgain,
+          expires: result.expires,
+        };
+      });
+      
+      setStatuses(statusResults);
+      return results;
+    } catch (error) {
+      console.error('Error requesting permissions:', error);
+      const errorResults: Record<PermissionType, PermissionRequestResult> = {} as any;
+      const errorStatuses: Record<PermissionType, PermissionResult> = {} as any;
+      
+      permissions.forEach(permission => {
+        errorResults[permission] = {
+          granted: false,
+          status: 'denied',
+          canAskAgain: false,
+        };
+        errorStatuses[permission] = {
+          status: 'denied',
+          canAskAgain: false,
+        };
+      });
+      
+      setStatuses(errorStatuses);
+      return errorResults;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [permissions]);
+
+  useEffect(() => {
+    checkStatuses();
+  }, [checkStatuses]);
+
+  const isGranted = useCallback((permission: PermissionType): boolean => {
+    return statuses?.[permission]?.status === 'granted' ?? false;
+  }, [statuses]);
+
+  const canAskAgain = useCallback((permission: PermissionType): boolean => {
+    return statuses?.[permission]?.canAskAgain ?? false;
+  }, [statuses]);
+
+  const allGranted = useCallback((): boolean => {
+    if (!statuses) return false;
+    return permissions.every(permission => statuses[permission]?.status === 'granted');
+  }, [statuses, permissions]);
+
+  const anyGranted = useCallback((): boolean => {
+    if (!statuses) return false;
+    return permissions.some(permission => statuses[permission]?.status === 'granted');
+  }, [statuses, permissions]);
+
+  return {
+    statuses,
+    isLoading,
+    isGranted,
+    canAskAgain,
+    allGranted,
+    anyGranted,
+    request,
+    refresh: checkStatuses,
+  };
+};
+
+/**
+ * Hook for managing permission groups
+ */
+export const usePermissionGroup = (group: keyof typeof PermissionGroups) => {
+  const permissions = PermissionGroups[group];
+  const permissionHook = usePermissions(permissions);
+
+  const requestGroup = useCallback(async (): Promise<Record<PermissionType, PermissionRequestResult>> => {
+    try {
+      permissionHook.isLoading = true;
+      const results = await requestPermissionGroup(group);
+      const statusResults: Record<PermissionType, PermissionResult> = {} as any;
+      
+      permissions.forEach(permission => {
+        const result = results[permission];
+        statusResults[permission] = {
+          status: result.status,
+          canAskAgain: result.canAskAgain,
+          expires: result.expires,
+        };
+      });
+      
+      permissionHook.setStatuses?.(statusResults);
+      return results;
+    } catch (error) {
+      console.error(`Error requesting permission group ${group}:`, error);
+      const errorResults: Record<PermissionType, PermissionRequestResult> = {} as any;
+      const errorStatuses: Record<PermissionType, PermissionResult> = {} as any;
+      
+      permissions.forEach(permission => {
+        errorResults[permission] = {
+          granted: false,
+          status: 'denied',
+          canAskAgain: false,
+        };
+        errorStatuses[permission] = {
+          status: 'denied',
+          canAskAgain: false,
+        };
+      });
+      
+      permissionHook.setStatuses?.(errorStatuses);
+      return errorResults;
+    } finally {
+      permissionHook.isLoading = false;
+    }
+  }, [group, permissions, permissionHook]);
+
+  const isGroupGranted = useCallback(async (): Promise<boolean> => {
+    return isPermissionGroupGranted(group);
+  }, [group]);
+
+  return {
+    ...permissionHook,
+    requestGroup,
+    isGroupGranted,
+    groupName: group,
+    permissions,
+  };
+};
+
+/**
+ * Hook for camera permissions specifically
+ */
+export const useCameraPermissions = () => {
+  return usePermissionGroup('camera');
+};
+
+/**
+ * Hook for location permissions specifically
+ */
+export const useLocationPermissions = () => {
+  return usePermissionGroup('location');
+};
+
+/**
+ * Hook for media permissions (camera, camera roll, audio recording)
+ */
+export const useMediaPermissions = () => {
+  return usePermissionGroup('media');
+};
+
+/**
+ * Hook for contacts permissions specifically
+ */
+export const useContactsPermissions = () => {
+  return usePermissionGroup('contacts');
+};
+
+/**
+ * Hook for calendar permissions specifically
+ */
+export const useCalendarPermissions = () => {
+  return usePermissionGroup('calendar');
+};