@onairos/react-native 3.4.1 → 3.5.4

package/src/hooks/useConnections.ts

@@ -1,163 +0,0 @@
-import { useState, useCallback } from 'react';
-import { Platform } from 'react-native';
-import { STORAGE_KEYS } from '../constants';
-import type { ConnectionStatus } from '../types';
-
-// Create a mock storage for environments without Keychain access (like Expo Go)
-const mockConnectionStorage: Record<string, ConnectionStatus> = {};
-
-// Try to import Keychain, but provide fallbacks if not available
-let Keychain: any = null;
-try {
-  // This import might fail in Expo Go or environments without native modules
-  Keychain = require('react-native-keychain');
-} catch (error) {
-  console.warn('react-native-keychain module not available in useConnections, using mock storage');
-}
-
-// Check if Keychain is properly initialized and available
-const isKeychainAvailable = () => {
-  try {
-    return Keychain && typeof Keychain.getGenericPassword === 'function';
-  } catch (e) {
-    return false;
-  }
-};
-
-export const useConnections = () => {
-  const [isConnecting, setIsConnecting] = useState(false);
-
-  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
-    try {
-      if (isKeychainAvailable()) {
-        try {
-          const stored = await Keychain.getGenericPassword({
-            service: STORAGE_KEYS.connections
-          });
-          if (stored && stored.password) {
-            const parsed = JSON.parse(stored.password);
-            // Validate the parsed data structure
-            if (parsed && typeof parsed === 'object') {
-              return parsed;
-            }
-          }
-        } catch (keychainError) {
-          console.warn('Keychain access failed, using fallback:', keychainError);
-          // Clear corrupted data
-          try {
-            await Keychain.resetGenericPassword({ service: STORAGE_KEYS.connections });
-          } catch (resetError) {
-            console.warn('Failed to reset keychain:', resetError);
-          }
-        }
-      }
-      
-      // Use in-memory mock storage if Keychain is not available or failed
-      const mockData = mockConnectionStorage[STORAGE_KEYS.connections] || {};
-      console.log('Using mock connection storage:', mockData);
-      return mockData;
-    } catch (error) {
-      console.error('Error getting connection status:', error);
-      
-      // Always return empty object as safe fallback
-      console.log('Returning empty connections due to error');
-      return {};
-    }
-  }, []);
-
-  const saveConnectionStatus = useCallback(async (status: ConnectionStatus) => {
-    try {
-      if (isKeychainAvailable()) {
-        await Keychain.setGenericPassword(
-          'connections',
-          JSON.stringify(status),
-          { service: STORAGE_KEYS.connections }
-        );
-      } else {
-        // Use in-memory mock storage if Keychain is not available
-        mockConnectionStorage[STORAGE_KEYS.connections] = status;
-      }
-    } catch (error) {
-      console.error('Error saving connection status:', error);
-      // Save to mock storage as fallback
-      mockConnectionStorage[STORAGE_KEYS.connections] = status;
-    }
-  }, []);
-
-  const connectPlatform = useCallback(async (platform: string) => {
-    setIsConnecting(true);
-    try {
-      console.log(`[Mock] Connecting to ${platform}`);
-      
-      // Simulate connection delay
-      await new Promise<void>((resolve) => {
-        setTimeout(() => resolve(), 1000);
-      });
-      
-      const status = await getConnectionStatus();
-      status[platform] = {
-        userName: `Mock User (${platform})`,
-        connected: true
-      };
-      await saveConnectionStatus(status);
-      
-      console.log(`[Mock] Successfully connected to ${platform}`);
-    } catch (error) {
-      console.error(`Error connecting to ${platform}:`, error);
-      // In development, provide mock data even on error
-      if (__DEV__) {
-        const status = {
-          [platform]: {
-            userName: `Fallback User (${platform})`,
-            connected: true
-          }
-        };
-        await saveConnectionStatus(status);
-      } else {
-        throw error;
-      }
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [getConnectionStatus, saveConnectionStatus]);
-
-  const disconnectPlatform = useCallback(async (platform: string) => {
-    try {
-      const status = await getConnectionStatus();
-      if (status && platform in status) {
-        delete status[platform];
-        await saveConnectionStatus(status);
-      }
-    } catch (error) {
-      console.error(`Error disconnecting ${platform}:`, error);
-      // Don't throw in development mode
-      if (!__DEV__) {
-        throw error;
-      }
-    }
-  }, [getConnectionStatus, saveConnectionStatus]);
-
-  const handleOAuthCallback = useCallback(async (platform: string, data: any) => {
-    try {
-      console.log(`[Mock] Handling callback for ${platform}`);
-      const status = await getConnectionStatus();
-      status[platform] = {
-        userName: data.userName || `Mock User (${platform})`,
-        connected: true
-      };
-      await saveConnectionStatus(status);
-      return true;
-    } catch (error) {
-      console.error('Error handling callback:', error);
-      return false;
-    }
-  }, [getConnectionStatus, saveConnectionStatus]);
-
-  return {
-    isConnecting,
-    connectPlatform,
-    disconnectPlatform,
-    getConnectionStatus,
-    handleOAuthCallback,
-  };
-}; 

package/src/hooks/useCredentials.ts

@@ -1,175 +0,0 @@
-import { useCallback } from 'react';
-import { STORAGE_KEYS } from '../constants';
-import type { CredentialsResult } from '../types';
-
-// Create a mock storage for environments without Keychain access
-const mockCredentialStorage: Record<string, any> = {};
-
-// Try to import Keychain, but provide fallbacks if not available
-let Keychain: any = null;
-try {
-  Keychain = require('react-native-keychain');
-} catch (error) {
-  console.warn('react-native-keychain module not available in useCredentials, using mock storage');
-}
-
-// Check if Keychain is properly initialized and available
-const isKeychainAvailable = () => {
-  try {
-    return Keychain && typeof Keychain.getGenericPassword === 'function';
-  } catch (e) {
-    return false;
-  }
-};
-
-// Safe wrapper for getGenericPassword
-const safeGetGenericPassword = async (options: any) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.getGenericPassword(options);
-    } else {
-      const key = options?.service || 'default';
-      return mockCredentialStorage[key] || null;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    const key = options?.service || 'default';
-    return mockCredentialStorage[key] || null;
-  }
-};
-
-// Safe wrapper for setGenericPassword
-const safeSetGenericPassword = async (username: string, password: string, options?: any) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.setGenericPassword(username, password, options);
-    } else {
-      const key = options?.service || 'default';
-      mockCredentialStorage[key] = { username, password };
-      return true;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    const key = options?.service || 'default';
-    mockCredentialStorage[key] = { username, password };
-    return true;
-  }
-};
-
-// Safe wrapper for resetGenericPassword
-const safeResetGenericPassword = async (options?: any) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.resetGenericPassword(options);
-    } else {
-      const key = options?.service || 'default';
-      delete mockCredentialStorage[key];
-      return true;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    const key = options?.service || 'default';
-    delete mockCredentialStorage[key];
-    return true;
-  }
-};
-
-export const useCredentials = () => {
-  const hasCredentials = useCallback(async (): Promise<boolean> => {
-    try {
-      const credentials = await safeGetGenericPassword({
-        service: STORAGE_KEYS.credentials
-      });
-      return !!credentials;
-    } catch (error) {
-      console.error('Error checking credentials:', error);
-      return false;
-    }
-  }, []);
-
-  const getCredentials = useCallback(async () => {
-    try {
-      const credentials = await safeGetGenericPassword({
-        service: STORAGE_KEYS.credentials
-      });
-      if (credentials) {
-        return JSON.parse(credentials.password);
-      }
-      return null;
-    } catch (error) {
-      console.error('Error getting credentials:', error);
-      return null;
-    }
-  }, []);
-
-  const storeCredentials = useCallback(async (
-    username: string,
-    userPin: string,
-    accessToken: string
-  ): Promise<boolean> => {
-    try {
-      const options: any = {
-        service: STORAGE_KEYS.credentials
-      };
-
-      // Only use secure storage options on real devices
-      if (isKeychainAvailable()) {
-        options.accessControl = Keychain.ACCESS_CONTROL?.BIOMETRY_ANY;
-        options.accessible = Keychain.ACCESSIBLE?.WHEN_UNLOCKED;
-      }
-
-      await safeSetGenericPassword(
-        username,
-        JSON.stringify({ userPin, accessToken }),
-        options
-      );
-      return true;
-    } catch (error) {
-      console.error('Error storing credentials:', error);
-      return false;
-    }
-  }, []);
-
-  const clearCredentials = useCallback(async (): Promise<void> => {
-    try {
-      await safeResetGenericPassword({
-        service: STORAGE_KEYS.credentials
-      });
-    } catch (error) {
-      console.error('Error clearing credentials:', error);
-    }
-  }, []);
-
-  const validateCredentials = useCallback(async (username: string): Promise<CredentialsResult> => {
-    try {
-      const response = await fetch(`https://api2.onairos.uk/validate`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ username }),
-      });
-
-      const data = await response.json();
-      return {
-        success: true,
-        isValid: data.valid,
-        credentials: data.credentials,
-      };
-    } catch (error) {
-      console.error('Error validating credentials:', error);
-      return { 
-        success: false,
-        isValid: false
-      };
-    }
-  }, []);
-
-  return {
-    hasCredentials,
-    getCredentials,
-    storeCredentials,
-    clearCredentials,
-    validateCredentials,
-  };
-}; 

package/src/index.js

@@ -1,14 +0,0 @@
-import OnairosButton from './components/OnairosButton';
-import * as AuthUtils from './utils/auth';
-import * as CryptoUtils from './utils/crypto';
-import * as ApiUtils from './utils/api';
-
-// Export the main component
-export default OnairosButton;
-
-// Export utilities for advanced usage
-export {
-  AuthUtils,
-  CryptoUtils,
-  ApiUtils
-};

package/src/index.ts

@@ -1,50 +0,0 @@
-/**
- * Onairos React Native SDK
- * A React Native implementation for Onairos personalized data integration
- * 
- * PUBLIC API - Only expose what developers need
- */
-
-// Essential Types Only
-export type {
-  OnairosButtonProps,
-  OnairosProps,
-  DataTier,
-  OnairosConfig,
-  TestModeOptions,
-} from './types';
-
-// Core Components
-export { OnairosButton } from './components/OnairosButton';
-export { Onairos } from './components/Onairos';
-
-// SDK Initialization
-export { 
-  initializeApiKey,
-  ADMIN_API_KEY,
-  extractUsernameFromJWT,
-  extractUserDataFromJWT,
-  decodeJWTPayload,
-} from './services/apiKeyService';
-
-// Authentication & PIN Management
-export {
-  // storePinAfterBiometric, // TODO: Commented out temporarily - biometric functionality disabled
-  getStoredJwtToken,
-  clearStoredTokens,
-  requestEmailVerification,
-  verifyEmailCode,
-  checkEmailVerificationStatus,
-} from './services/platformAuthService';
-
-// Programmatic Function (for custom buttons)
-export { executeOnairosFlow } from './utils/programmaticFlow';
-
-// Default export for convenience
-import { OnairosButton } from './components/OnairosButton';
-import { Onairos } from './components/Onairos';
-
-export default {
-  OnairosButton,
-  Onairos,
-};