@quiltt/react-native 5.0.0 → 5.0.1

package/dist/index.js

@@ -1,801 +1,11 @@
 import { decode } from 'base-64';
-import { getUserAgent as getUserAgent$1, QuilttClient, InMemoryCache, createVersionLink } from '@quiltt/core';
 export * from '@quiltt/core';
-import { useQuilttSession, ConnectorSDKEventType, QuilttAuthProvider as QuilttAuthProvider$1, QuilttSettingsProvider } from '@quiltt/react';
 export { QuilttSettingsProvider, useLazyQuery, useMutation, useQuery, useQuilttClient, useQuilttConnector, useQuilttSession, useQuilttSettings, useSession, useStorage, useSubscription } from '@quiltt/react';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import React, { forwardRef, useRef, useState, useEffect, useCallback, useMemo, useImperativeHandle } from 'react';
-import { Platform, StyleSheet, StatusBar, SafeAreaView, View, Text, Pressable, ActivityIndicator, Linking } from 'react-native';
-import { URL } from 'react-native-url-polyfill';
-import { WebView } from 'react-native-webview';
-import { generateStackTrace, makeBacktrace, getCauses } from '@honeybadger-io/core/build/src/util';
-import __node_cjsModule from 'node:module';
-
-var version = "5.0.0";
-
-// Custom Error Reporter to avoid hooking into or colliding with a client's Honeybadger singleton
-const notifier = {
-    name: 'Quiltt React Native SDK Reporter',
-    url: 'https://www.quiltt.dev/connector/sdk/react-native',
-    version: version
-};
-class ErrorReporter {
-    constructor(userAgent){
-        this.noticeUrl = 'https://api.honeybadger.io/v1/notices';
-        this.apiKey = process.env.HONEYBADGER_API_KEY_REACT_NATIVE || '';
-        this.logger = console;
-        this.userAgent = userAgent;
-    }
-    async notify(error, context) {
-        const headers = {
-            'X-API-Key': this.apiKey,
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-            'User-Agent': this.userAgent
-        };
-        const payload = await this.buildPayload(error, context);
-        const method = 'POST';
-        const body = JSON.stringify(payload);
-        const mode = 'cors';
-        fetch(this.noticeUrl, {
-            headers,
-            method,
-            body,
-            mode
-        }).then((response)=>{
-            if (response.status !== 201) {
-                this.logger.warn(`Error report failed: unknown response from server. code=${response.status}`);
-                return;
-            }
-            return response.json();
-        }).then((data)=>{
-            if (data) {
-                this.logger.info(`Error report sent ⚡ https://app.honeybadger.io/notice/${data?.id}`);
-            }
-        });
-    }
-    async buildPayload(error, localContext = {}) {
-        const notice = error;
-        notice.stack = generateStackTrace();
-        notice.backtrace = makeBacktrace(notice.stack);
-        return {
-            notifier,
-            error: {
-                class: notice.name,
-                message: notice.message,
-                backtrace: notice.backtrace,
-                // fingerprint: this.calculateFingerprint(notice),
-                tags: notice.tags || [],
-                causes: getCauses(notice, this.logger)
-            },
-            request: {
-                url: notice.url,
-                component: notice.component,
-                action: notice.action,
-                context: localContext || {},
-                cgi_data: {},
-                params: {},
-                session: {}
-            },
-            server: {
-                project_root: notice.projectRoot,
-                environment_name: this.userAgent,
-                revision: version,
-                hostname: this.userAgent,
-                time: new Date().toUTCString()
-            },
-            details: notice.details || {}
-        };
-    }
-}
-
-const getErrorMessage = (responseStatus, error)=>{
-    if (error) return `An error occurred while checking the Connector URL: ${error?.name} \n${error?.message}`;
-    return responseStatus ? `An error occurred loading the Connector. Response status: ${responseStatus}` : 'An error occurred while checking the Connector URL';
-};
-
-const require$1 = __node_cjsModule.createRequire(import.meta.url);
-
-// Optionally import react-native-device-info if available
-let DeviceInfo = null;
-try {
-    DeviceInfo = require$1('react-native-device-info').default;
-} catch  {
-// react-native-device-info is not installed - will use fallback
-}
-/**
- * Gets the React version from the runtime
- */ const getReactVersion = ()=>{
-    return React.version || 'unknown';
-};
-/**
- * Gets the React Native version from Platform constants
- */ const getReactNativeVersion = ()=>{
-    try {
-        const rnVersion = Platform.constants?.reactNativeVersion;
-        if (rnVersion) {
-            return `${rnVersion.major}.${rnVersion.minor}.${rnVersion.patch}`;
-        }
-    } catch (error) {
-        console.warn('Failed to get React Native version:', error);
-    }
-    return 'unknown';
-};
-/**
- * Gets OS information (platform and version)
- */ const getOSInfo = ()=>{
-    try {
-        const os = Platform.OS // 'ios' or 'android'
-        ;
-        const osVersion = Platform.Version // string (iOS) or number (Android)
-        ;
-        // Map platform names to correct capitalization
-        const platformNames = {
-            ios: 'iOS',
-            android: 'Android'
-        };
-        const osName = platformNames[os] || 'Unknown';
-        return `${osName}/${osVersion}`;
-    } catch (error) {
-        console.warn('Failed to get OS info:', error);
-        return 'Unknown/Unknown';
-    }
-};
-/**
- * Gets device model information
- * Falls back to 'Unknown' if react-native-device-info is not installed
- */ const getDeviceModel = async ()=>{
-    if (!DeviceInfo) {
-        return 'Unknown';
-    }
-    try {
-        const model = await DeviceInfo.getModel();
-        return model || 'Unknown';
-    } catch (error) {
-        console.warn('Failed to get device model:', error);
-        return 'Unknown';
-    }
-};
-/**
- * Generates platform information string for React Native
- * Format: React/<version>; ReactNative/<version>; <OS>/<version>; <device-model>
- */ const getPlatformInfo = async ()=>{
-    const reactVersion = getReactVersion();
-    const rnVersion = getReactNativeVersion();
-    const osInfo = getOSInfo();
-    const deviceModel = await getDeviceModel();
-    return `React/${reactVersion}; ReactNative/${rnVersion}; ${osInfo}; ${deviceModel}`;
-};
-/**
- * Synchronously generates platform information string for React Native
- * Format: React/<version>; ReactNative/<version>; <OS>/<version>; Unknown
- * Note: Device model is set to 'Unknown' since it requires async DeviceInfo call
- */ const getPlatformInfoSync = ()=>{
-    const reactVersion = getReactVersion();
-    const rnVersion = getReactNativeVersion();
-    const osInfo = getOSInfo();
-    return `React/${reactVersion}; ReactNative/${rnVersion}; ${osInfo}; Unknown`;
-};
-/**
- * Generates User-Agent string for React Native SDK
- * Format: Quiltt/<sdk-version> (React/<version>; ReactNative/<version>; <OS>/<version>; <device-model>)
- */ const getUserAgent = async (sdkVersion)=>{
-    const platformInfo = await getPlatformInfo();
-    return getUserAgent$1(sdkVersion, platformInfo);
-};
-
-/**
- * Checks if a string appears to be already URL encoded
- * @param str The string to check
- * @returns boolean indicating if the string appears to be URL encoded
- */ const isEncoded = (str)=>{
-    // Check for typical URL encoding patterns like %20, %3A, etc.
-    const hasEncodedChars = /%[0-9A-F]{2}/i.test(str);
-    // Check if double encoding has occurred (e.g., %253A instead of %3A)
-    const hasDoubleEncoding = /%25[0-9A-F]{2}/i.test(str);
-    // If we have encoded chars but no double encoding, it's likely properly encoded
-    return hasEncodedChars && !hasDoubleEncoding;
-};
-/**
- * Smart URL encoder that ensures a string is encoded exactly once
- * @param str The string to encode
- * @returns A properly URL encoded string
- */ const smartEncodeURIComponent = (str)=>{
-    if (!str) return str;
-    // If it's already encoded, return as is
-    if (isEncoded(str)) {
-        console.log('URL already encoded, skipping encoding');
-        return str;
-    }
-    // Otherwise, encode it
-    const encoded = encodeURIComponent(str);
-    console.log('URL encoded');
-    return encoded;
-};
-/**
- * Checks if a string appears to be double-encoded
- */ const isDoubleEncoded = (str)=>{
-    if (!str) return false;
-    return /%25[0-9A-F]{2}/i.test(str);
-};
-/**
- * Normalizes a URL string by decoding it once if it appears to be double-encoded
- */ const normalizeUrlEncoding = (urlStr)=>{
-    if (isDoubleEncoded(urlStr)) {
-        console.log('Detected double-encoded URL:', urlStr);
-        const normalized = decodeURIComponent(urlStr);
-        console.log('Normalized to:', normalized);
-        return normalized;
-    }
-    return urlStr;
-};
-
-const AndroidSafeAreaView = ({ testId, children })=>/*#__PURE__*/ jsx(SafeAreaView, {
-        testID: testId,
-        style: styles$2.AndroidSafeArea,
-        children: children
-    });
-const styles$2 = StyleSheet.create({
-    AndroidSafeArea: {
-        flex: 1,
-        backgroundColor: 'white',
-        paddingTop: Platform.OS === 'android' ? StatusBar.currentHeight : 0
-    }
-});
-
-const ErrorScreen = ({ testId, error, cta })=>/*#__PURE__*/ jsx(AndroidSafeAreaView, {
-        testId: testId,
-        children: /*#__PURE__*/ jsxs(View, {
-            style: [
-                styles$1.container,
-                styles$1.padding
-            ],
-            children: [
-                /*#__PURE__*/ jsxs(View, {
-                    style: {
-                        flex: 1,
-                        justifyContent: 'center'
-                    },
-                    children: [
-                        /*#__PURE__*/ jsx(View, {
-                            style: {
-                                flexDirection: 'row',
-                                justifyContent: 'space-between',
-                                alignItems: 'center',
-                                marginVertical: 10
-                            },
-                            children: /*#__PURE__*/ jsx(Text, {
-                                style: [
-                                    styles$1.title
-                                ],
-                                children: "Cannot connect to the internet."
-                            })
-                        }),
-                        /*#__PURE__*/ jsx(Text, {
-                            style: [
-                                styles$1.subtitle
-                            ],
-                            children: error
-                        })
-                    ]
-                }),
-                /*#__PURE__*/ jsx(Pressable, {
-                    style: [
-                        styles$1.pressable
-                    ],
-                    onPress: cta,
-                    children: /*#__PURE__*/ jsx(Text, {
-                        style: [
-                            styles$1.pressableText
-                        ],
-                        children: "Exit"
-                    })
-                })
-            ]
-        })
-    });
-const styles$1 = StyleSheet.create({
-    container: {
-        flex: 1,
-        flexDirection: 'column',
-        justifyContent: 'flex-start',
-        alignItems: 'stretch',
-        backgroundColor: '#F3F4F6'
-    },
-    title: {
-        color: '#1F2937',
-        fontSize: 30,
-        fontWeight: 'bold'
-    },
-    subtitle: {
-        color: 'rgba(107, 114, 128, 1)'
-    },
-    padding: {
-        paddingHorizontal: 16,
-        paddingVertical: 24
-    },
-    pressable: {
-        marginTop: 20,
-        backgroundColor: '#1F2937',
-        padding: 10,
-        paddingHorizontal: 25,
-        borderRadius: 5
-    },
-    pressableText: {
-        color: '#fff',
-        textAlign: 'center'
-    }
-});
-
-const LoadingScreen = ({ testId })=>/*#__PURE__*/ jsx(AndroidSafeAreaView, {
-        testId: testId,
-        children: /*#__PURE__*/ jsx(View, {
-            style: {
-                flex: 1,
-                justifyContent: 'center',
-                alignItems: 'center'
-            },
-            children: /*#__PURE__*/ jsx(ActivityIndicator, {
-                testID: "activity-indicator",
-                size: "large",
-                color: "#5928A3"
-            })
-        })
-    });
-
-const PREFLIGHT_RETRY_COUNT = 3;
-const parseMetadata = (url, connectorId)=>{
-    const metadata = {
-        connectorId: url.searchParams.get('connectorId') ?? connectorId
-    };
-    const profileId = url.searchParams.get('profileId');
-    if (profileId) metadata.profileId = profileId;
-    const connectionId = url.searchParams.get('connectionId');
-    if (connectionId) metadata.connectionId = connectionId;
-    const connectorSessionId = url.searchParams.get('connectorSession');
-    if (connectorSessionId) metadata.connectorSession = {
-        id: connectorSessionId
-    };
-    return metadata;
-};
-const checkConnectorUrl = async (connectorUrl, errorReporter, retryCount = 0)=>{
-    let responseStatus;
-    try {
-        const response = await fetch(connectorUrl);
-        switch(response.status){
-            case 200:
-                return {
-                    checked: true
-                };
-            case 400:
-                console.log('Invalid configuration');
-                return {
-                    checked: true
-                };
-            case 404:
-                console.error('Connector not found');
-                return {
-                    checked: true
-                };
-            default:
-                throw new Error('Connector URL is not routable.');
-        }
-    } catch (error) {
-        // Log error for debugging
-        console.error(error);
-        // Try again
-        if (retryCount < PREFLIGHT_RETRY_COUNT) {
-            const delay = 50 * 2 ** retryCount;
-            await new Promise((resolve)=>setTimeout(resolve, delay));
-            console.log(`Retrying connection... Attempt ${retryCount + 1}`);
-            return checkConnectorUrl(connectorUrl, errorReporter, retryCount + 1);
-        }
-        // Report error after retries exhausted
-        const errorMessage = getErrorMessage(responseStatus, error);
-        const errorToSend = error || new Error(errorMessage);
-        const context = {
-            connectorUrl,
-            responseStatus
-        };
-        await errorReporter.notify(errorToSend, context);
-        // Return errored preflight check
-        return {
-            checked: true,
-            error: errorMessage
-        };
-    }
-};
-/**
- * Handle opening OAuth URLs with proper encoding detection and normalization
- */ const handleOAuthUrl = (oauthUrl)=>{
-    try {
-        // Throw error if oauthUrl is null or undefined
-        if (oauthUrl == null) {
-            throw new Error('OAuth URL missing');
-        }
-        // Convert to string if it's a URL object
-        const urlString = oauthUrl.toString();
-        // Throw error if the resulting string is empty
-        if (!urlString || urlString.trim() === '') {
-            throw new Error('Empty OAuth URL');
-        }
-        // Normalize the URL encoding
-        const normalizedUrl = normalizeUrlEncoding(urlString);
-        // Open the normalized URL
-        Linking.openURL(normalizedUrl);
-    } catch (_error) {
-        console.error('OAuth URL handling error');
-        // Only try the fallback if oauthUrl is not null
-        if (oauthUrl != null) {
-            try {
-                const fallbackUrl = typeof oauthUrl === 'string' ? oauthUrl : oauthUrl.toString();
-                console.log('Attempting fallback OAuth opening');
-                Linking.openURL(fallbackUrl);
-            } catch (_fallbackError) {
-                console.error('Fallback OAuth opening failed');
-            }
-        }
-    }
-};
-const QuilttConnector = /*#__PURE__*/ forwardRef(({ connectorId, connectionId, institution, oauthRedirectUrl, onEvent, onLoad, onExit, onExitSuccess, onExitAbort, onExitError, testId }, ref)=>{
-    const webViewRef = useRef(null);
-    const { session } = useQuilttSession();
-    const [preFlightCheck, setPreFlightCheck] = useState({
-        checked: false
-    });
-    const [errorReporter, setErrorReporter] = useState(null);
-    const [userAgent, setUserAgent] = useState('');
-    // Initialize error reporter and user agent
-    useEffect(()=>{
-        let mounted = true;
-        const init = async ()=>{
-            const agent = await getUserAgent(version);
-            if (mounted) {
-                setUserAgent(agent);
-                setErrorReporter(new ErrorReporter(agent));
-            }
-        };
-        init();
-        return ()=>{
-            mounted = false;
-        };
-    }, []);
-    // Script to disable scrolling on header
-    const disableHeaderScrollScript = `
-    (function() {
-      const header = document.querySelector('header');
-      if (header) {
-        header.style.position = 'fixed';
-        header.style.top = '0';
-        header.style.left = '0';
-        header.style.right = '0';
-        header.style.zIndex = '1000';
-      }
-    })();
-  `;
-    const onLoadEnd = useCallback(()=>{
-        if (Platform.OS === 'ios') {
-            webViewRef.current?.injectJavaScript(disableHeaderScrollScript);
-        }
-    }, []);
-    // Ensure oauthRedirectUrl is encoded properly - only once
-    const safeOAuthRedirectUrl = useMemo(()=>{
-        return smartEncodeURIComponent(oauthRedirectUrl);
-    }, [
-        oauthRedirectUrl
-    ]);
-    const connectorUrl = useMemo(()=>{
-        if (!userAgent) return null;
-        const url = new URL(`https://${connectorId}.quiltt.app`);
-        // For normal parameters, just append them directly
-        url.searchParams.append('mode', 'webview');
-        url.searchParams.append('agent', userAgent);
-        // For the oauth_redirect_url, we need to be careful
-        // If it's already encoded, we need to decode it once to prevent
-        // the automatic encoding that happens with searchParams.append
-        if (isEncoded(safeOAuthRedirectUrl)) {
-            const decodedOnce = decodeURIComponent(safeOAuthRedirectUrl);
-            url.searchParams.append('oauth_redirect_url', decodedOnce);
-        } else {
-            url.searchParams.append('oauth_redirect_url', safeOAuthRedirectUrl);
-        }
-        return url.toString();
-    }, [
-        connectorId,
-        safeOAuthRedirectUrl,
-        userAgent
-    ]);
-    useEffect(()=>{
-        if (preFlightCheck.checked || !connectorUrl || !errorReporter) return;
-        const fetchDataAndSetState = async ()=>{
-            const connectorUrlStatus = await checkConnectorUrl(connectorUrl, errorReporter);
-            setPreFlightCheck(connectorUrlStatus);
-        };
-        fetchDataAndSetState();
-    }, [
-        connectorUrl,
-        preFlightCheck,
-        errorReporter
-    ]);
-    const initInjectedJavaScript = useCallback(()=>{
-        const script = `\
-      const options = {\
-        source: 'quiltt',\
-        type: 'Options',\
-        token: '${session?.token}',\
-        connectorId: '${connectorId}',\
-        connectionId: '${connectionId}',\
-        institution: '${institution}', \
-      };\
-      const compactedOptions = Object.keys(options).reduce((acc, key) => {\
-        if (options[key] !== 'undefined') {\
-          acc[key] = options[key];\
-        }\
-        return acc;\
-      }, {});\
-      window.postMessage(compactedOptions);\
-    `;
-        webViewRef.current?.injectJavaScript(script);
-    }, [
-        connectionId,
-        connectorId,
-        institution,
-        session?.token
-    ]);
-    const isQuilttEvent = useCallback((url)=>url.protocol === 'quilttconnector:', []);
-    const shouldRender = useCallback((url)=>!isQuilttEvent(url), [
-        isQuilttEvent
-    ]);
-    const clearLocalStorage = useCallback(()=>{
-        const script = 'localStorage.clear();';
-        webViewRef.current?.injectJavaScript(script);
-    }, []);
-    const handleQuilttEvent = useCallback((url)=>{
-        url.searchParams.delete('source');
-        url.searchParams.append('connectorId', connectorId);
-        const metadata = parseMetadata(url, connectorId);
-        requestAnimationFrame(()=>{
-            const eventType = url.host;
-            switch(eventType){
-                case 'Load':
-                    console.log('Event: Load');
-                    initInjectedJavaScript();
-                    onEvent?.(ConnectorSDKEventType.Load, metadata);
-                    onLoad?.(metadata);
-                    break;
-                case 'ExitAbort':
-                    console.log('Event: ExitAbort');
-                    clearLocalStorage();
-                    onEvent?.(ConnectorSDKEventType.ExitAbort, metadata);
-                    onExit?.(ConnectorSDKEventType.ExitAbort, metadata);
-                    onExitAbort?.(metadata);
-                    break;
-                case 'ExitError':
-                    console.log('Event: ExitError');
-                    clearLocalStorage();
-                    onEvent?.(ConnectorSDKEventType.ExitError, metadata);
-                    onExit?.(ConnectorSDKEventType.ExitError, metadata);
-                    onExitError?.(metadata);
-                    break;
-                case 'ExitSuccess':
-                    console.log('Event: ExitSuccess');
-                    clearLocalStorage();
-                    onEvent?.(ConnectorSDKEventType.ExitSuccess, metadata);
-                    onExit?.(ConnectorSDKEventType.ExitSuccess, metadata);
-                    onExitSuccess?.(metadata);
-                    break;
-                case 'Authenticate':
-                    console.log('Event: Authenticate');
-                    break;
-                case 'Navigate':
-                    {
-                        console.log('Event: Navigate');
-                        const navigateUrl = url.searchParams.get('url');
-                        if (navigateUrl) {
-                            if (isEncoded(navigateUrl)) {
-                                try {
-                                    const decodedUrl = decodeURIComponent(navigateUrl);
-                                    handleOAuthUrl(decodedUrl);
-                                } catch (_error) {
-                                    console.error('Navigate URL decoding failed, using original');
-                                    handleOAuthUrl(navigateUrl);
-                                }
-                            } else {
-                                handleOAuthUrl(navigateUrl);
-                            }
-                        } else {
-                            console.error('Navigate URL missing from request');
-                        }
-                        break;
-                    }
-                // NOTE: The `OauthRequested` is deprecated and should not be used
-                default:
-                    console.log(`Unhandled event: ${eventType}`);
-                    break;
-            }
-        });
-    }, [
-        clearLocalStorage,
-        connectorId,
-        initInjectedJavaScript,
-        onEvent,
-        onExit,
-        onExitAbort,
-        onExitError,
-        onExitSuccess,
-        onLoad
-    ]);
-    const requestHandler = useCallback((request)=>{
-        const url = new URL(request.url);
-        if (isQuilttEvent(url)) {
-            handleQuilttEvent(url);
-            return false;
-        }
-        if (shouldRender(url)) {
-            return true;
-        }
-        // Plaid set oauth url by doing window.location.href = url
-        // So we use `handleOAuthUrl` as a catch all and assume all url got to this step is Plaid OAuth url
-        handleOAuthUrl(url);
-        return false;
-    }, [
-        handleQuilttEvent,
-        isQuilttEvent,
-        shouldRender
-    ]);
-    // Expose method to handle OAuth callbacks from parent component
-    useImperativeHandle(ref, ()=>({
-            handleOAuthCallback: (callbackUrl)=>{
-                try {
-                    console.log('Handling OAuth callback:', callbackUrl);
-                    const url = new URL(callbackUrl);
-                    // Extract OAuth callback parameters
-                    const oauthParams = {};
-                    url.searchParams.forEach((value, key)=>{
-                        oauthParams[key] = value;
-                    });
-                    // Send OAuth callback data to the connector via postMessage
-                    // This preserves the connector's state and allows events to fire properly
-                    const message = {
-                        source: 'quiltt',
-                        type: 'OAuthCallback',
-                        data: {
-                            url: callbackUrl,
-                            params: oauthParams
-                        }
-                    };
-                    const script = `
-              (function() {
-                try {
-                  window.postMessage(${JSON.stringify(message)});
-                  console.log('OAuth callback message sent to connector');
-                } catch (e) {
-                  console.error('Failed to send OAuth callback message:', e);
-                }
-              })();
-              true;
-            `;
-                    webViewRef.current?.injectJavaScript(script);
-                } catch (error) {
-                    console.error('Error handling OAuth callback:', error);
-                }
-            }
-        }), []);
-    if (!preFlightCheck.checked || !connectorUrl) {
-        return /*#__PURE__*/ jsx(LoadingScreen, {
-            testId: "loading-screen"
-        });
-    }
-    if (preFlightCheck.error) {
-        return /*#__PURE__*/ jsx(ErrorScreen, {
-            testId: "error-screen",
-            error: preFlightCheck.error,
-            cta: ()=>onExitError?.({
-                    connectorId
-                })
-        });
-    }
-    return /*#__PURE__*/ jsx(AndroidSafeAreaView, {
-        testId: testId,
-        children: /*#__PURE__*/ jsx(WebView, {
-            ref: webViewRef,
-            // Plaid keeps sending window.location = 'about:srcdoc' and causes some noise in RN
-            domStorageEnabled: true,
-            javaScriptEnabled: true,
-            onLoadEnd: onLoadEnd,
-            onShouldStartLoadWithRequest: requestHandler,
-            originWhitelist: [
-                '*'
-            ],
-            scrollEnabled: true,
-            showsHorizontalScrollIndicator: false,
-            showsVerticalScrollIndicator: false,
-            source: {
-                uri: connectorUrl
-            },
-            style: styles.webview,
-            testID: "webview",
-            webviewDebuggingEnabled: true,
-            ...Platform.OS === 'ios' ? {
-                allowsBackForwardNavigationGestures: false,
-                allowsInlineMediaPlayback: true,
-                automaticallyAdjustContentInsets: false,
-                bounces: false,
-                contentInsetAdjustmentBehavior: 'never',
-                dataDetectorTypes: 'none',
-                decelerationRate: 'normal',
-                keyboardDisplayRequiresUserAction: false,
-                scrollEventThrottle: 16,
-                startInLoadingState: true
-            } : {
-                androidLayerType: 'hardware',
-                cacheEnabled: true,
-                cacheMode: 'LOAD_CACHE_ELSE_NETWORK',
-                overScrollMode: 'never'
-            }
-        })
-    });
-});
-// Add styles for the WebView container
-const styles = StyleSheet.create({
-    webviewContainer: {
-        flex: 1,
-        backgroundColor: '#ffffff'
-    },
-    webview: {
-        flex: 1,
-        overflow: 'hidden'
-    }
-});
-QuilttConnector.displayName = 'QuilttConnector';
-
-/**
- * React Native-specific QuilttAuthProvider that injects platform information
- * into the GraphQL client's User-Agent header.
- *
- * If a token is provided, will validate the token against the api and then import
- * it into trusted storage. While this process is happening, the component is put
- * into a loading state and the children are not rendered to prevent race conditions
- * from triggering within the transitionary state.
- */ const QuilttAuthProvider = ({ graphqlClient, token, children })=>{
-    // Create React Native-specific GraphQL client with platform info if no custom client provided
-    const platformClient = useMemo(()=>{
-        if (graphqlClient) {
-            return graphqlClient;
-        }
-        const platformInfo = getPlatformInfoSync();
-        return new QuilttClient({
-            cache: new InMemoryCache(),
-            versionLink: createVersionLink(platformInfo)
-        });
-    }, [
-        graphqlClient
-    ]);
-    return /*#__PURE__*/ jsx(QuilttAuthProvider$1, {
-        token: token,
-        graphqlClient: platformClient,
-        children: children
-    });
-};
-
-/**
- * React Native-specific QuilttProvider that combines settings and auth providers
- * with platform-specific GraphQL client configuration.
- */ const QuilttProvider = ({ clientId, graphqlClient, token, children })=>{
-    return /*#__PURE__*/ jsx(QuilttSettingsProvider, {
-        clientId: clientId,
-        children: /*#__PURE__*/ jsx(QuilttAuthProvider, {
-            token: token,
-            graphqlClient: graphqlClient,
-            children: children
-        })
-    });
-};
+export * from './components/index.js';
+export * from './providers/index.js';
 
 // Hermes doesn't have atob
 // https://github.com/facebook/hermes/issues/1178
 if (!global.atob) {
     global.atob = decode;
 }
-
-export { QuilttAuthProvider, QuilttConnector, QuilttProvider, checkConnectorUrl, handleOAuthUrl };