@explorins/pers-sdk-react-native 1.3.2

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/polyfills/index.d.ts

@@ -0,0 +1,3 @@
+export declare const initializeReactNativePolyfills: () => boolean;
+export declare const isReactNative: () => boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/polyfills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/polyfills/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,8BAA8B,QAAO,OAGjD,CAAC;AAGF,eAAO,MAAM,aAAa,QAAO,OAEhC,CAAC"}

package/dist/polyfills/index.js

@@ -0,0 +1,13 @@
+// Minimal React Native environment setup
+// No polyfills needed - modules are disabled at Metro level
+// Simple initialization function for compatibility
+export const initializeReactNativePolyfills = () => {
+    console.log('✅ [PERS SDK] React Native environment ready (no polyfills needed)');
+    return true;
+};
+// Platform detection
+export const isReactNative = () => {
+    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+};
+// Auto-initialize
+initializeReactNativePolyfills();

package/dist/polyfills/index.simple.d.ts

@@ -0,0 +1,2 @@
+export declare const initializeReactNativePolyfills: () => boolean;
+//# sourceMappingURL=index.simple.d.ts.map

package/dist/polyfills/index.simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.simple.d.ts","sourceRoot":"","sources":["../../src/polyfills/index.simple.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,8BAA8B,QAAO,OAGjD,CAAC"}

package/dist/polyfills/index.simple.js

@@ -0,0 +1,17 @@
+import { Buffer } from 'buffer';
+// Simple polyfills based on proven web project pattern
+// Minimal setup that actually works
+// Set up global environment
+global.global = global;
+global.Buffer = Buffer;
+// Only add what's actually needed for React Native
+if (typeof global !== 'undefined' && !global.process) {
+    global.process = { env: {} };
+}
+// Export initialization function for compatibility
+export const initializeReactNativePolyfills = () => {
+    console.log('✅ [PERS SDK] Simple polyfills initialized');
+    return true;
+};
+// Auto-initialize
+initializeReactNativePolyfills();

package/dist/providers/PersSDKProvider.d.ts

@@ -0,0 +1,29 @@
+import React, { ReactNode } from 'react';
+import { PersApiClient } from '@explorins/pers-sdk/core';
+export interface PersSDKConfig {
+    apiProjectKey: string;
+    environment?: 'development' | 'staging' | 'production';
+    timeout?: number;
+}
+export interface PersSDKContext {
+    tokens: any | null;
+    transactions: any | null;
+    business: any | null;
+    campaigns: any | null;
+    redemptions: any | null;
+    web3: any | null;
+    apiClient: PersApiClient | null;
+    isInitialized: boolean;
+    isAuthenticated: boolean;
+    user: any | null;
+    accountAddress: string | null;
+    initialize: (config: PersSDKConfig) => Promise<void>;
+    login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
+    loginWithRawData: (rawUserData: any) => Promise<any>;
+    logout: () => Promise<void>;
+}
+export declare const PersSDKProvider: React.FC<{
+    children: ReactNode;
+}>;
+export declare const usePersSDK: () => PersSDKContext;
+//# sourceMappingURL=PersSDKProvider.d.ts.map

package/dist/providers/PersSDKProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersSDKProvider.d.ts","sourceRoot":"","sources":["../../src/providers/PersSDKProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAkD,SAAS,EAAuB,MAAM,OAAO,CAAC;AAC9G,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAWzD,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAE7B,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC;IACnB,YAAY,EAAE,GAAG,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,GAAG,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,GAAG,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IACjB,SAAS,EAAE,aAAa,GAAG,IAAI,CAAC;IAGhC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,UAAU,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACvE,gBAAgB,EAAE,CAAC,WAAW,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAiCD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IACrC,QAAQ,EAAE,SAAS,CAAC;CACrB,CA4LA,CAAC;AAGF,eAAO,MAAM,UAAU,QAAO,cAQ7B,CAAC"}

package/dist/providers/PersSDKProvider.js

@@ -0,0 +1,194 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useRef } from 'react';
+import { PersApiClient } from '@explorins/pers-sdk/core';
+import { TokenSDK } from '@explorins/pers-sdk/token';
+import { createTransactionSDK } from '@explorins/pers-sdk/transaction';
+import { createBusinessSDK } from '@explorins/pers-sdk/business';
+import { createCampaignSDK } from '@explorins/pers-sdk/campaign';
+import { createRedemptionSDK } from '@explorins/pers-sdk/redemption';
+import { createWeb3SDK } from '@explorins/pers-sdk/web3';
+import { ReactNativeHttpClient } from './react-native-http-client';
+import { BaseReactNativeAuthProvider } from './react-native-auth-provider';
+// Create the context
+const SDKContext = createContext(null);
+// Custom auth provider for React Native
+class ReactNativeSDKAuthProvider extends BaseReactNativeAuthProvider {
+    constructor(projectKey) {
+        super(projectKey);
+        this.projectKey = projectKey;
+        this.authType = 'user';
+        this._token = null;
+    }
+    async getToken() {
+        return this._token;
+    }
+    async setToken(token) {
+        this._token = token;
+    }
+    async getProjectKey() {
+        return this.projectKey;
+    }
+    async onTokenExpired() {
+        console.log('Token expired - clearing token');
+        this._token = null;
+    }
+}
+// Provider component
+export const PersSDKProvider = ({ children }) => {
+    const initializingRef = useRef(false);
+    const [apiClient, setApiClient] = useState(null);
+    const [authProvider, setAuthProvider] = useState(null);
+    const [sdks, setSdks] = useState({
+        tokens: null,
+        transactions: null,
+        business: null,
+        campaigns: null,
+        redemptions: null,
+        web3: null,
+    });
+    const [isInitialized, setIsInitialized] = useState(false);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [user, setUser] = useState(null);
+    const [accountAddress, setAccountAddress] = useState(null);
+    const initialize = useCallback(async (config) => {
+        // Prevent multiple initializations
+        if (isInitialized || initializingRef.current) {
+            console.log('⚠️ SDK already initialized or initializing, skipping...');
+            return;
+        }
+        initializingRef.current = true;
+        try {
+            console.log('🚀 Initializing PERS SDK with config:', config);
+            // Create auth provider
+            const auth = new ReactNativeSDKAuthProvider(config.apiProjectKey);
+            setAuthProvider(auth);
+            // Create HTTP client
+            const httpClient = new ReactNativeHttpClient();
+            // Create API client
+            const client = new PersApiClient(httpClient, {
+                apiProjectKey: config.apiProjectKey,
+                authProvider: auth,
+                environment: config.environment || 'development',
+            });
+            setApiClient(client);
+            // Initialize domain SDKs
+            const domainSDKs = {
+                tokens: new TokenSDK(client),
+                transactions: createTransactionSDK(client),
+                business: createBusinessSDK(client),
+                campaigns: createCampaignSDK(client),
+                redemptions: createRedemptionSDK(client),
+                web3: createWeb3SDK(client),
+            };
+            setSdks(domainSDKs);
+            setIsInitialized(true);
+            console.log('✅ PERS SDK initialized successfully');
+        }
+        catch (error) {
+            console.error('❌ Failed to initialize PERS SDK:', error);
+            initializingRef.current = false;
+            throw error;
+        }
+        finally {
+            initializingRef.current = false;
+        }
+    }, []);
+    const login = useCallback(async (jwtToken, userType = 'user') => {
+        if (!apiClient || !authProvider) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            console.log(`🔐 Logging in as ${userType}...`);
+            // Set token in auth provider
+            await authProvider.setToken(jwtToken);
+            // Perform login with API client
+            const result = userType === 'admin'
+                ? await apiClient.loginAdmin(jwtToken)
+                : await apiClient.loginUser(jwtToken);
+            const userData = result.user || result.admin;
+            const userAccountAddress = userData?.accountAddress ||
+                userData?.wallets?.[0]?.address ||
+                null;
+            setUser(userData);
+            setAccountAddress(userAccountAddress);
+            setIsAuthenticated(true);
+            console.log('✅ Login successful');
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Login failed:', error);
+            throw error;
+        }
+    }, [apiClient, authProvider]);
+    const loginWithRawData = useCallback(async (rawUserData) => {
+        if (!apiClient || !authProvider) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            console.log('🔐 Logging in with raw user data...');
+            const result = await apiClient.loginUserWithRawData(rawUserData);
+            // Set token from result
+            if (result.accessToken) {
+                await authProvider.setToken(result.accessToken);
+            }
+            const userData = result.user;
+            const userAccountAddress = userData?.accountAddress ||
+                userData?.wallets?.[0]?.address ||
+                null;
+            setUser(userData);
+            setAccountAddress(userAccountAddress);
+            setIsAuthenticated(true);
+            console.log('✅ Raw data login successful');
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Raw data login failed:', error);
+            throw error;
+        }
+    }, [apiClient, authProvider]);
+    const logout = useCallback(async () => {
+        try {
+            console.log('🔓 Logging out...');
+            if (authProvider) {
+                await authProvider.setToken(null);
+            }
+            setUser(null);
+            setAccountAddress(null);
+            setIsAuthenticated(false);
+            console.log('✅ Logout successful');
+        }
+        catch (error) {
+            console.error('❌ Logout failed:', error);
+            throw error;
+        }
+    }, [authProvider]);
+    const contextValue = {
+        // SDK instances
+        tokens: sdks.tokens,
+        transactions: sdks.transactions,
+        business: sdks.business,
+        campaigns: sdks.campaigns,
+        redemptions: sdks.redemptions,
+        web3: sdks.web3,
+        apiClient,
+        // State
+        isInitialized,
+        isAuthenticated,
+        user,
+        accountAddress,
+        // Methods
+        initialize,
+        login,
+        loginWithRawData,
+        logout,
+    };
+    return (_jsx(SDKContext.Provider, { value: contextValue, children: children }));
+};
+// Custom hook to use the SDK context
+export const usePersSDK = () => {
+    const context = useContext(SDKContext);
+    if (!context) {
+        throw new Error('usePersSDK must be used within a PersSDKProvider');
+    }
+    return context;
+};

package/dist/providers/react-native-auth-provider.d.ts

@@ -0,0 +1,92 @@
+import type { PersAuthProvider } from '@explorins/pers-sdk/core';
+/**
+ * Storage strategy for different types of data
+ */
+export declare enum StorageStrategy {
+    /** Use AsyncStorage for general app data */
+    ASYNC_STORAGE = "async_storage",
+    /** Use Keychain for sensitive tokens (when available) */
+    KEYCHAIN = "keychain",
+    /** Use in-memory storage (fallback) */
+    MEMORY = "memory"
+}
+/**
+ * Configuration options for React Native Auth Provider
+ */
+export interface ReactNativeAuthConfig {
+    /** Storage strategy for access tokens */
+    accessTokenStrategy?: StorageStrategy;
+    /** Storage strategy for refresh tokens */
+    refreshTokenStrategy?: StorageStrategy;
+    /** Custom key prefix for storage */
+    keyPrefix?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Base React Native Authentication Provider
+ *
+ * This serves as a blueprint for native implementations and can be extended
+ * by consuming applications to integrate with their specific auth systems.
+ *
+ * Features:
+ * - Multiple storage strategies (AsyncStorage, Keychain, Memory)
+ * - Configurable security levels per token type
+ * - Cross-platform compatibility (iOS/Android/Web)
+ * - Blueprint for native iOS/Android implementations
+ */
+export declare abstract class BaseReactNativeAuthProvider implements PersAuthProvider {
+    abstract readonly authType: 'admin' | 'user';
+    abstract getProjectKey(): Promise<string | null>;
+    abstract onTokenExpired(): Promise<void>;
+    protected readonly config: Required<ReactNativeAuthConfig>;
+    protected readonly ACCESS_TOKEN_KEY: string;
+    protected readonly REFRESH_TOKEN_KEY: string;
+    protected readonly PROJECT_KEY_KEY: string;
+    private memoryStorage;
+    constructor(projectKey: string, config?: ReactNativeAuthConfig);
+    getToken(): Promise<string | null>;
+    setAccessToken(token: string): Promise<void>;
+    setRefreshToken(token: string): Promise<void>;
+    getRefreshToken(): Promise<string | null>;
+    clearTokens(): Promise<void>;
+    hasValidToken(): boolean;
+    hasRefreshToken(): boolean;
+    hasValidTokenAsync(): Promise<boolean>;
+    hasRefreshTokenAsync(): Promise<boolean>;
+    setToken(token: string): void;
+    clearToken(): void;
+    protected storeValue(key: string, value: string, strategy: StorageStrategy): Promise<void>;
+    protected getStoredValue(key: string, strategy: StorageStrategy): Promise<string | null>;
+    protected removeStoredValue(key: string, strategy: StorageStrategy): Promise<void>;
+    private isKeychainAvailable;
+    private storeInKeychain;
+    private getFromKeychain;
+    private removeFromKeychain;
+}
+/**
+ * React Native Authentication Provider
+ *
+ * A ready-to-use implementation for basic use cases.
+ * Uses AsyncStorage for access tokens and Keychain for refresh tokens (when available).
+ */
+export declare class ReactNativeAuthProvider extends BaseReactNativeAuthProvider {
+    private projectKey;
+    readonly authType: 'user';
+    constructor(projectKey: string, config?: ReactNativeAuthConfig);
+    getProjectKey(): Promise<string | null>;
+    onTokenExpired(): Promise<void>;
+}
+/**
+ * Secure React Native Authentication Provider
+ *
+ * Maximum security implementation using Keychain for all sensitive data.
+ */
+export declare class SecureReactNativeAuthProvider extends BaseReactNativeAuthProvider {
+    private projectKey;
+    readonly authType: 'user';
+    constructor(projectKey: string, config?: Omit<ReactNativeAuthConfig, 'accessTokenStrategy' | 'refreshTokenStrategy'>);
+    getProjectKey(): Promise<string | null>;
+    onTokenExpired(): Promise<void>;
+}
+//# sourceMappingURL=react-native-auth-provider.d.ts.map

package/dist/providers/react-native-auth-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-native-auth-provider.d.ts","sourceRoot":"","sources":["../../src/providers/react-native-auth-provider.ts"],"names":[],"mappings":"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"}

package/dist/providers/react-native-auth-provider.js

@@ -0,0 +1,268 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+/**
+ * Storage strategy for different types of data
+ */
+export var StorageStrategy;
+(function (StorageStrategy) {
+    /** Use AsyncStorage for general app data */
+    StorageStrategy["ASYNC_STORAGE"] = "async_storage";
+    /** Use Keychain for sensitive tokens (when available) */
+    StorageStrategy["KEYCHAIN"] = "keychain";
+    /** Use in-memory storage (fallback) */
+    StorageStrategy["MEMORY"] = "memory";
+})(StorageStrategy || (StorageStrategy = {}));
+/**
+ * Base React Native Authentication Provider
+ *
+ * This serves as a blueprint for native implementations and can be extended
+ * by consuming applications to integrate with their specific auth systems.
+ *
+ * Features:
+ * - Multiple storage strategies (AsyncStorage, Keychain, Memory)
+ * - Configurable security levels per token type
+ * - Cross-platform compatibility (iOS/Android/Web)
+ * - Blueprint for native iOS/Android implementations
+ */
+export class BaseReactNativeAuthProvider {
+    constructor(projectKey, config = {}) {
+        // In-memory fallback storage
+        this.memoryStorage = new Map();
+        // Validate projectKey
+        if (!projectKey || typeof projectKey !== 'string') {
+            throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
+        }
+        // Set default configuration
+        this.config = {
+            accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
+            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+            keyPrefix: `pers_${projectKey.slice(0, 8)}`,
+            debug: false,
+            ...config
+        };
+        // Create storage keys
+        this.ACCESS_TOKEN_KEY = `${this.config.keyPrefix}_access_token`;
+        this.REFRESH_TOKEN_KEY = `${this.config.keyPrefix}_refresh_token`;
+        this.PROJECT_KEY_KEY = `${this.config.keyPrefix}_project_key`;
+        if (this.config.debug) {
+            console.log('🔧 ReactNativeAuthProvider initialized with config:', this.config);
+        }
+    }
+    // Core token management methods
+    async getToken() {
+        return this.getStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy);
+    }
+    async setAccessToken(token) {
+        await this.storeValue(this.ACCESS_TOKEN_KEY, token, this.config.accessTokenStrategy);
+        if (this.config.debug) {
+            console.log('✅ Access token stored securely');
+        }
+    }
+    async setRefreshToken(token) {
+        await this.storeValue(this.REFRESH_TOKEN_KEY, token, this.config.refreshTokenStrategy);
+        if (this.config.debug) {
+            console.log('✅ Refresh token stored securely');
+        }
+    }
+    async getRefreshToken() {
+        return this.getStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy);
+    }
+    async clearTokens() {
+        await Promise.all([
+            this.removeStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy),
+            this.removeStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy)
+        ]);
+        if (this.config.debug) {
+            console.log('✅ All tokens cleared from storage');
+        }
+    }
+    // Token validation methods
+    hasValidToken() {
+        // Synchronous check - for async check use hasValidTokenAsync()
+        return true; // Actual validation happens in getToken()
+    }
+    hasRefreshToken() {
+        // Synchronous check - for async check use hasRefreshTokenAsync()
+        return true; // Actual validation happens in getRefreshToken()
+    }
+    // Async token validation methods
+    async hasValidTokenAsync() {
+        const token = await this.getToken();
+        return !!token;
+    }
+    async hasRefreshTokenAsync() {
+        const refreshToken = await this.getRefreshToken();
+        return !!refreshToken;
+    }
+    // Legacy methods for backward compatibility
+    setToken(token) {
+        this.setAccessToken(token).catch(error => {
+            console.error('Legacy setToken failed:', error);
+        });
+    }
+    clearToken() {
+        this.clearTokens().catch(error => {
+            console.error('Legacy clearToken failed:', error);
+        });
+    }
+    // Protected storage implementation methods
+    async storeValue(key, value, strategy) {
+        try {
+            switch (strategy) {
+                case StorageStrategy.KEYCHAIN:
+                    // Try Keychain first, fallback to AsyncStorage
+                    if (await this.isKeychainAvailable()) {
+                        await this.storeInKeychain(key, value);
+                    }
+                    else {
+                        await AsyncStorage.setItem(key, value);
+                    }
+                    break;
+                case StorageStrategy.ASYNC_STORAGE:
+                    await AsyncStorage.setItem(key, value);
+                    break;
+                case StorageStrategy.MEMORY:
+                default:
+                    this.memoryStorage.set(key, value);
+                    break;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to store value with strategy ${strategy}:`, error);
+            // Fallback to memory storage
+            this.memoryStorage.set(key, value);
+        }
+    }
+    async getStoredValue(key, strategy) {
+        try {
+            switch (strategy) {
+                case StorageStrategy.KEYCHAIN:
+                    // Try Keychain first, fallback to AsyncStorage
+                    if (await this.isKeychainAvailable()) {
+                        return await this.getFromKeychain(key);
+                    }
+                    else {
+                        return await AsyncStorage.getItem(key);
+                    }
+                case StorageStrategy.ASYNC_STORAGE:
+                    return await AsyncStorage.getItem(key);
+                case StorageStrategy.MEMORY:
+                default:
+                    return this.memoryStorage.get(key) || null;
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to get value with strategy ${strategy}:`, error);
+            // Fallback to memory storage
+            return this.memoryStorage.get(key) || null;
+        }
+    }
+    async removeStoredValue(key, strategy) {
+        try {
+            switch (strategy) {
+                case StorageStrategy.KEYCHAIN:
+                    // Try Keychain first, fallback to AsyncStorage
+                    if (await this.isKeychainAvailable()) {
+                        await this.removeFromKeychain(key);
+                    }
+                    else {
+                        await AsyncStorage.removeItem(key);
+                    }
+                    break;
+                case StorageStrategy.ASYNC_STORAGE:
+                    await AsyncStorage.removeItem(key);
+                    break;
+                case StorageStrategy.MEMORY:
+                default:
+                    this.memoryStorage.delete(key);
+                    break;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to remove value with strategy ${strategy}:`, error);
+            // Ensure memory fallback is also cleared
+            this.memoryStorage.delete(key);
+        }
+    }
+    // Keychain helper methods
+    async isKeychainAvailable() {
+        try {
+            // Check if react-native-keychain is available
+            const Keychain = require('react-native-keychain');
+            return !!Keychain && typeof Keychain.setInternetCredentials === 'function';
+        }
+        catch {
+            return false;
+        }
+    }
+    async storeInKeychain(key, value) {
+        const Keychain = require('react-native-keychain');
+        await Keychain.setInternetCredentials(key, 'pers-token', value);
+    }
+    async getFromKeychain(key) {
+        const Keychain = require('react-native-keychain');
+        const credentials = await Keychain.getInternetCredentials(key);
+        return credentials ? credentials.password : null;
+    }
+    async removeFromKeychain(key) {
+        const Keychain = require('react-native-keychain');
+        await Keychain.resetInternetCredentials(key);
+    }
+}
+/**
+ * React Native Authentication Provider
+ *
+ * A ready-to-use implementation for basic use cases.
+ * Uses AsyncStorage for access tokens and Keychain for refresh tokens (when available).
+ */
+export class ReactNativeAuthProvider extends BaseReactNativeAuthProvider {
+    constructor(projectKey, config = {}) {
+        // Validate projectKey
+        if (!projectKey || typeof projectKey !== 'string') {
+            throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
+        }
+        super(projectKey, {
+            accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
+            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+            debug: false,
+            ...config
+        });
+        this.projectKey = projectKey;
+        this.authType = 'user';
+    }
+    async getProjectKey() {
+        return this.projectKey;
+    }
+    async onTokenExpired() {
+        if (this.config.debug) {
+            console.warn('ReactNativeAuthProvider: Token expired - no refresh logic implemented');
+        }
+    }
+}
+/**
+ * Secure React Native Authentication Provider
+ *
+ * Maximum security implementation using Keychain for all sensitive data.
+ */
+export class SecureReactNativeAuthProvider extends BaseReactNativeAuthProvider {
+    constructor(projectKey, config = {}) {
+        // Validate projectKey
+        if (!projectKey || typeof projectKey !== 'string') {
+            throw new Error('SecureReactNativeAuthProvider: projectKey is required and must be a string');
+        }
+        super(projectKey, {
+            ...config,
+            accessTokenStrategy: StorageStrategy.KEYCHAIN,
+            refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+        });
+        this.projectKey = projectKey;
+        this.authType = 'user';
+    }
+    async getProjectKey() {
+        return this.projectKey;
+    }
+    async onTokenExpired() {
+        if (this.config.debug) {
+            console.warn('SecureReactNativeAuthProvider: Token expired - implement refresh logic');
+        }
+    }
+}

package/dist/providers/react-native-http-client.d.ts

@@ -0,0 +1,29 @@
+/**
+ * HTTP Client implementation for React Native
+ *
+ * This implementation properly implements the core SDK's HttpClient interface
+ * and uses fetch API which is available in React Native.
+ */
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+    timeout?: number;
+    responseType?: 'json' | 'blob' | 'text' | 'arraybuffer';
+}
+export interface HttpClient {
+    get<T>(url: string, options?: RequestOptions): Promise<T>;
+    post<T>(url: string, body: any, options?: RequestOptions): Promise<T>;
+    put<T>(url: string, body: any, options?: RequestOptions): Promise<T>;
+    delete<T>(url: string, options?: RequestOptions): Promise<T>;
+}
+export declare class ReactNativeHttpClient implements HttpClient {
+    private baseURL?;
+    constructor(baseURL?: string);
+    get<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    post<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T>;
+    put<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T>;
+    delete<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    private request;
+    private buildUrl;
+}
+//# sourceMappingURL=react-native-http-client.d.ts.map