@onairos/react-native 3.0.2 → 3.0.5

package/src/types/ambient.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Ambient type declarations to fix Node.js module conflicts
+ */
+
+// These modules are not used directly in React Native, but are referenced by types
+// Providing empty declarations prevents TypeScript from trying to use Node.js types
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): any;
+    once(event: string, listener: (...args: any[]) => void): any;
+    prependOnceListener(event: string, listener: (...args: any[]) => void): any;
+  }
+}
+
+declare module 'node:https' {}
+declare module 'node:http' {}
+declare module 'node:crypto' {}
+declare module 'process' {
+  global {
+    namespace NodeJS {
+      interface Process {
+        env: {
+          NODE_ENV?: string;
+          [key: string]: string | undefined;
+        };
+      }
+    }
+  }
+} 

package/src/types/index.d.ts

@@ -9,27 +9,47 @@ declare module '@onairos/react-native' {
   }
 
   export interface OnairosButtonProps {
+    /** Return link after authentication (used for web-based flows) */
     returnLink?: string;
+    /** Prefill URL for the authentication process */
     prefillUrl?: string;
-    AppName: string;
+    /** Application name to display in dialogs */
+    AppName?: string;
+    /** Button type - 'normal' or 'pill' */
     buttonType?: 'normal' | 'pill';
+    /** Data requests for user consent */
     requestData?: {
-      Small: DataTier;
-      Medium: DataTier;
-      Large: DataTier;
+      [key: string]: {
+        type: string;
+        descriptions: string;
+        reward: string;
+      };
     };
-    buttonWidth?: number;
+    /** Button width in pixels or percentage */
+    buttonWidth?: number | string;
+    /** Button height in pixels */
     buttonHeight?: number;
+    /** Whether to show stroke/border around button */
     hasStroke?: boolean;
+    /** Whether the button is enabled */
     enabled?: boolean;
-    buttonForm?: 'default' | 'login' | 'signup';
-    onRejection?: () => void;
-    onResolved?: (apiUrl: string, token: string, userData: any) => void;
+    /** Button form/shape style */
+    buttonForm?: 'default' | 'rounded' | 'square';
+    /** Callback when user rejects or cancels */
+    onRejection?: (reason: string) => void;
+    /** Callback when authentication is resolved */
+    onResolved?: (apiUrl: string, accessToken: string, data: any) => void;
+    /** Function to check before starting authentication */
     preCheck?: () => Promise<boolean>;
+    /** Button background color */
     color?: string;
+    /** Whether to apply a slight rotation effect */
     swerv?: boolean;
+    /** Enable debug mode */
     debug?: boolean;
+    /** Preferred platform for authentication */
     preferredPlatform?: string;
+    /** Enable test mode */
     testMode?: boolean;
   }
 
@@ -110,4 +130,24 @@ declare module '@onairos/react-native' {
   export class PinInput extends Component<PinInputProps> {}
   export class TrainingModal extends Component<TrainingModalProps> {}
   export class OAuthWebView extends Component<OAuthWebViewProps> {}
+}
+
+// Fix for Node.js type conflicts
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): this;
+  }
+}
+
+// Override any problematic Node.js types
+declare module 'node:https' {
+  export * from 'https';
+}
+
+declare module 'node:http' {
+  export * from 'http';
+}
+
+declare module 'node:crypto' {
+  export * from 'crypto';
 } 

package/src/types/index.ts

@@ -7,14 +7,16 @@ export interface DataTier {
 export interface OnairosButtonProps {
   returnLink?: string;
   prefillUrl?: string;
-  AppName: string;
+  AppName?: string;
   buttonType?: 'normal' | 'pill';
   requestData?: {
-    Small: DataTier;
-    Medium: DataTier;
-    Large: DataTier;
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
   };
-  buttonWidth?: number;
+  buttonWidth?: number | string;
   buttonHeight?: number;
   hasStroke?: boolean;
   enabled?: boolean;
@@ -34,9 +36,11 @@ export interface UniversalOnboardingProps {
   onClose: () => void;
   AppName: string;
   requestData?: {
-    Small: DataTier;
-    Medium: DataTier;
-    Large: DataTier;
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
   };
   returnLink?: string;
   onComplete: (apiUrl: string, token: string, userData: any) => void;
@@ -81,6 +85,13 @@ export interface OAuthWebViewProps {
   onClose: () => void;
 }
 
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
 export interface OnairosCredentials {
   username: string;
   accessToken?: string;
@@ -106,13 +117,8 @@ export interface OverlayProps {
   username: string;
   modelKey: string;
   onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
-}
-
-export interface PlatformConfig {
-  name: string;
-  icon: string;
-  color: string;
-  description?: string;
+  appName?: string;
+  darkMode?: boolean;
 }
 
 export interface BiometricOptions {

package/src/types/node-fix.d.ts

@@ -0,0 +1,19 @@
+// Fix for Node.js type conflicts
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): this;
+  }
+}
+
+// Override any problematic Node.js types
+declare module 'node:https' {
+  export * from 'https';
+}
+
+declare module 'node:http' {
+  export * from 'http';
+}
+
+declare module 'node:crypto' {
+  export * from 'crypto';
+} 

package/src/types/node-override.d.ts

@@ -0,0 +1,24 @@
+// Override for Node.js HTTPS module to fix type errors
+declare module 'node:https' {
+  import * as http from 'http';
+  import * as tls from 'tls';
+  
+  interface ServerOptions {
+    // Define simplified options
+  }
+  
+  class Server extends tls.Server {
+    // Override problematic methods with any type
+    prependListener(event: string, listener: any): this;
+    prependOnceListener(event: string, listener: any): this;
+    once(event: string, listener: any): this;
+  }
+  
+  function createServer(options?: ServerOptions, requestListener?: any): Server;
+  function createServer(requestListener?: any): Server;
+}
+
+// Also override node:http
+declare module 'node:http' {
+  export * from 'http';
+} 

package/src/types/types.d.ts

@@ -0,0 +1,18 @@
+declare module '@onairos/react-native' {
+  import { Component } from 'react';
+  import { ViewStyle } from 'react-native';
+
+  // Re-export all the types from our index.ts
+  export * from '../types';
+  
+  // Components
+  export class Onairos extends Component<any> {}
+  export class OnairosButton extends Component<import('../types').OnairosButtonProps> {}
+  export class OnairosOverlay extends Component<import('../types').OverlayProps> {}
+  export class UniversalOnboarding extends Component<import('../types').UniversalOnboardingProps> {}
+}
+
+// Fix for Node.js type conflicts by providing empty declarations
+declare module 'node:https' {}
+declare module 'node:http' {}
+declare module 'node:crypto' {} 

package/src/types.ts

@@ -20,10 +20,130 @@ export interface UniversalOnboardingProps {
   test?: boolean;
   buttonType?: 'default' | 'pill';
   buttonForm?: 'signup' | 'login';
+  preferredPlatform?: string;
 }
 
 export interface ConnectionStatus {
-  [key: string]: boolean;
+  [key: string]: {
+    userName: string;
+    connected: boolean;
+  };
+}
+
+export interface OnairosButtonProps {
+  returnLink?: string;
+  prefillUrl?: string;
+  AppName: string;
+  buttonType?: 'normal' | 'pill';
+  requestData?: {
+    Small: DataTier;
+    Medium: DataTier;
+    Large: DataTier;
+  };
+  buttonWidth?: number;
+  buttonHeight?: number;
+  hasStroke?: boolean;
+  enabled?: boolean;
+  buttonForm?: 'default' | 'login' | 'signup';
+  onRejection?: (error?: string) => void;
+  onResolved?: (apiUrl: string, token: string, userData: any) => void;
+  preCheck?: () => Promise<boolean>;
+  color?: string;
+  swerv?: boolean;
+  debug?: boolean;
+  preferredPlatform?: string;
+  testMode?: boolean;
+}
+
+export interface PlatformListProps {
+  platforms?: string[];
+  onSelect?: (platform: string) => void;
+  selectedPlatform?: string;
+  connections?: ConnectionStatus;
+  onToggle?: (platform: string, connect: boolean) => void;
+  isLoading?: boolean;
+  canProceed?: boolean;
+  onProceed?: () => void;
+}
+
+export interface PinInputProps {
+  onComplete?: (pin: string) => void;
+  length?: number;
+  secure?: boolean;
+  title?: string;
+  subtitle?: string;
+  verification?: boolean;
+  initialPin?: string;
+  onSubmit: (pin: string) => void;
+  minLength?: number;
+  requireSpecialChar?: boolean;
+  requireNumber?: boolean;
+}
+
+export interface TrainingModalProps {
+  visible: boolean;
+  onClose: () => void;
+  onComplete: () => void;
+  modelKey: string;
+  username: string;
+  progress?: number;
+  eta?: string;
+  onCancel?: () => void;
+}
+
+export interface OAuthWebViewProps {
+  url: string;
+  onClose: () => void;
+  onSuccess: (code: string) => void;
+  platform?: string;
+  onComplete?: () => void;
+}
+
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  publicKey?: string;
+}
+
+export interface CredentialsResult {
+  success: boolean;
+  credentials?: any;
+  error?: string;
+  isValid?: boolean;
+}
+
+export interface OverlayProps {
+  data: {
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
+  };
+  username: string;
+  modelKey: string;
+  onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
+}
+
+export interface BiometricOptions {
+  enableBiometrics?: boolean;
+  biometricPrompt?: string;
+}
+
+export interface PinRequirements {
+  minLength: number;
+  requireUppercase: boolean;
+  requireLowercase: boolean;
+  requireNumber: boolean;
+  requireSpecialChar: boolean;
 }
 
 // ... rest of the existing types ... 

package/src/utils/encryption.ts

@@ -1,5 +1,6 @@
 import { onairosApi } from '../api';
 import RSA from 'react-native-rsa-native';
+import { ApiResponse } from '../types';
 
 /**
  * Encrypt a model key using RSA with a public key
@@ -33,10 +34,14 @@ export const encryptModelKey = (publicKey: string, modelKey: string): string =>
  */
 export const getServerPublicKey = async (): Promise<string> => {
   try {
+    // Use the API without generics to prevent TypeScript errors
     const response = await onairosApi.get('public/getPublicKey');
     
-    if (response && response.publicKey) {
-      return response.publicKey;
+    // Check for the public key in the response data
+    if (response?.data?.data?.publicKey) {
+      return response.data.data.publicKey;
+    } else if (response?.data?.publicKey) {
+      return response.data.publicKey;
     } else {
       throw new Error('No public key found in response');
     }

package/src/utils/secureStorage.ts

@@ -1,4 +1,3 @@
-import * as Keychain from 'react-native-keychain';
 import { Platform } from 'react-native';
 import { sha256 } from './crypto';
 import { STORAGE_KEYS } from '../constants';
@@ -20,24 +19,41 @@ export interface OnairosCredentials {
 
 export interface StorageOptions {
   service?: string;
-  accessControl?: Keychain.ACCESS_CONTROL;
-  accessible?: Keychain.ACCESSIBLE;
+  accessControl?: any;
+  accessible?: any;
 }
 
 // Create a mock storage for environments without Keychain access (like Expo Go)
 const mockStorage: Record<string, { username: string; password: string }> = {};
 
-// Check if running in Expo Go or environments without native module access
+// 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, using mock storage');
+  // Create minimal mock implementation
+  Keychain = {
+    ACCESS_CONTROL: { BIOMETRY_ANY_OR_DEVICE_PASSCODE: 'mock' },
+    ACCESSIBLE: { WHEN_UNLOCKED: 'mock' },
+    getGenericPassword: async () => null,
+    setGenericPassword: async () => true,
+    resetGenericPassword: async () => true,
+  };
+}
+
+// Check if Keychain is properly initialized and available
 const isKeychainAvailable = () => {
   try {
-    return typeof Keychain.getGenericPassword === 'function';
+    return Keychain && typeof Keychain.getGenericPassword === 'function';
   } catch (e) {
     return false;
   }
 };
 
 // Wrapper for getGenericPassword that falls back to mock storage
-const safeGetGenericPassword = async (options: Keychain.Options) => {
+const safeGetGenericPassword = async (options: any) => {
   try {
     if (isKeychainAvailable()) {
       return await Keychain.getGenericPassword(options);
@@ -58,7 +74,7 @@ const safeGetGenericPassword = async (options: Keychain.Options) => {
 const safeSetGenericPassword = async (
   username: string,
   password: string,
-  options?: Keychain.Options
+  options?: any
 ) => {
   try {
     if (isKeychainAvailable()) {
@@ -79,7 +95,7 @@ const safeSetGenericPassword = async (
 };
 
 // Wrapper for resetGenericPassword that falls back to mock storage
-const safeResetGenericPassword = async (options?: Keychain.Options) => {
+const safeResetGenericPassword = async (options?: any) => {
   try {
     if (isKeychainAvailable()) {
       return await Keychain.resetGenericPassword(options);
@@ -117,7 +133,7 @@ export const storeCredentials = async (
       throw new Error('Username is required for storing credentials');
     }
 
-    const options: Keychain.Options = {
+    const options: any = {
       service: STORAGE_KEYS.credentials,
     };
 

package/types/index.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Onairos React Native SDK Type Definitions
+ * 
+ * @packageDocumentation
+ */
+
+import * as React from 'react';
+import { ViewStyle, TextStyle } from 'react-native';
+
+/**
+ * Data tier configuration for permission requests
+ */
+export interface DataTier {
+  /** Type label for the data tier */
+  type: string;
+  /** Description of what this tier includes */
+  descriptions: string;
+  /** What the user receives for granting this level of access */
+  reward: string;
+}
+
+/**
+ * Onairos API response wrapper
+ */
+export interface ApiResponse<T> {
+  /** Whether the API call was successful */
+  success: boolean;
+  /** The data returned from the API (if successful) */
+  data?: T;
+  /** Error message (if not successful) */
+  error?: string;
+}
+
+/**
+ * Credentials for Onairos authentication
+ */
+export interface OnairosCredentials {
+  /** User's unique username */
+  username: string;
+  /** Access token for API requests */
+  accessToken?: string;
+  /** Refresh token for obtaining new access tokens */
+  refreshToken?: string;
+  /** User's PIN for local authentication */
+  userPin?: string;
+  /** Connected platform tokens */
+  platforms?: {
+    instagram?: { token: string; username: string };
+    youtube?: { token: string; username: string };
+    pinterest?: { token: string; username: string };
+    reddit?: { token: string; username: string };
+  };
+  /** When the credentials were created */
+  createdAt: number;
+}
+
+/**
+ * Props for the OnairosButton component
+ */
+export interface OnairosButtonProps {
+  /** The link to return to after OAuth flow completes */
+  returnLink?: string;
+  /** URL to prefill for authentication */
+  prefillUrl?: string;
+  /** Your application name */
+  AppName: string;
+  /** Button style: 'normal' or 'pill' */
+  buttonType?: 'normal' | 'pill';
+  /** Data request tiers */
+  requestData?: {
+    Small: DataTier;
+    Medium: DataTier;
+    Large: DataTier;
+  };
+  /** Button width in pixels */
+  buttonWidth?: number;
+  /** Button height in pixels */
+  buttonHeight?: number;
+  /** Whether to show a stroke around the button */
+  hasStroke?: boolean;
+  /** Whether the button is enabled */
+  enabled?: boolean;
+  /** Button form style */
+  buttonForm?: 'default' | 'login' | 'signup';
+  /** Called when authentication is rejected */
+  onRejection?: (error?: string) => void;
+  /** Called when authentication is completed successfully */
+  onResolved?: (apiUrl: string, token: string, userData: any) => void;
+  /** Function to run before starting the authentication flow */
+  preCheck?: () => Promise<boolean>;
+  /** Button color */
+  color?: string;
+  /** Whether to slightly rotate the button */
+  swerv?: boolean;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Preferred platform to highlight */
+  preferredPlatform?: string;
+  /** Whether to use test mode */
+  testMode?: boolean;
+}
+
+/**
+ * Universal onboarding props
+ */
+export interface UniversalOnboardingProps {
+  visible: boolean;
+  onClose: () => void;
+  AppName: string;
+  requestData?: {
+    Small: DataTier;
+    Medium: DataTier;
+    Large: DataTier;
+  };
+  returnLink?: string;
+  onComplete: (apiUrl: string, token: string, userData: any) => void;
+  preferredPlatform?: string;
+  debug?: boolean;
+  test?: boolean;
+  embedd?: boolean;
+}
+
+/**
+ * Overlay props
+ */
+export interface OverlayProps {
+  data: {
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
+  };
+  username: string;
+  modelKey: string;
+  onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
+}
+
+/**
+ * OAuth Configuration
+ */
+export interface OAuthConfig {
+  clientId: string;
+  redirectUri: string;
+  scope: string;
+  authorizationEndpoint: string;
+  tokenEndpoint: string;
+  responseType: string;
+}
+
+/** Platform configuration type */
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
+// Main components
+export const Onairos: React.ComponentType<OnairosButtonProps>;
+export const OnairosButton: React.ComponentType<OnairosButtonProps>;
+export const OnairosOverlay: React.ComponentType<OverlayProps>;
+export const UniversalOnboarding: React.ComponentType<UniversalOnboardingProps>;
+
+// Utility functions
+export function initializeOAuthService(): void;
+export function cleanupOAuthService(): void;
+export function storeCredentials(credentials: Partial<OnairosCredentials>, options?: any): Promise<boolean>;
+export function getCredentials(options?: any): Promise<OnairosCredentials | null>;
+export function hasCredentials(): Promise<boolean>;
+export function deleteCredentials(): Promise<boolean>;
+export function updateCredentials(updates: Partial<OnairosCredentials>): Promise<boolean>;
+export function generateDeviceUsername(): string;
+export function verifyCredentials(credentials: OnairosCredentials): Promise<boolean>;
+
+// Service functions
+export function connectPlatform(platform: string): Promise<any>;
+export function disconnectPlatform(platform: string, credentials: OnairosCredentials): Promise<boolean>;
+export function storePlatformConnection(platform: string, connectionData: any, credentials: OnairosCredentials): Promise<boolean>;
+
+// Export constants
+export const COLORS: Record<string, string>;
+export const PLATFORMS: Record<string, PlatformConfig>;
+export const API_ENDPOINTS: {
+  base: string;
+  oauth: Record<string, string>;
+  callback: Record<string, string>;
+};
+export const STORAGE_KEYS: Record<string, string>;
+export const PIN_REQUIREMENTS: {
+  minLength: number;
+  requireUppercase: boolean;
+  requireLowercase: boolean;
+  requireNumber: boolean;
+  requireSpecialChar: boolean;
+};
+export const DEEP_LINK_CONFIG: {
+  scheme: string;
+  host: string;
+};
+
+// Default export
+declare const _default: {
+  Onairos: typeof Onairos;
+  OnairosButton: typeof OnairosButton;
+  OnairosOverlay: typeof OnairosOverlay;
+  UniversalOnboarding: typeof UniversalOnboarding;
+};
+
+export default _default;