@quiltt/react-native 5.0.0 → 5.0.1

package/dist/providers/index.cjs

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var core = require('@quiltt/core');
+var react = require('@quiltt/react');
+var reactNative = require('react-native');
+require('react-native-device-info');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+/**
+ * Gets the React version from the runtime
+ */ const getReactVersion = ()=>{
+    return React__default.default.version || 'unknown';
+};
+/**
+ * Gets the React Native version from Platform constants
+ */ const getReactNativeVersion = ()=>{
+    try {
+        const rnVersion = reactNative.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 = reactNative.Platform.OS // 'ios' or 'android'
+        ;
+        const osVersion = reactNative.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';
+    }
+};
+/**
+ * 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`;
+};
+
+/**
+ * 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 = React.useMemo(()=>{
+        if (graphqlClient) {
+            return graphqlClient;
+        }
+        const platformInfo = getPlatformInfoSync();
+        return new core.QuilttClient({
+            cache: new core.InMemoryCache(),
+            versionLink: core.createVersionLink(platformInfo)
+        });
+    }, [
+        graphqlClient
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(react.QuilttAuthProvider, {
+        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__*/ jsxRuntime.jsx(react.QuilttSettingsProvider, {
+        clientId: clientId,
+        children: /*#__PURE__*/ jsxRuntime.jsx(QuilttAuthProvider, {
+            token: token,
+            graphqlClient: graphqlClient,
+            children: children
+        })
+    });
+};
+
+exports.QuilttAuthProvider = QuilttAuthProvider;
+exports.QuilttProvider = QuilttProvider;

package/dist/providers/index.d.ts

@@ -0,0 +1,24 @@
+import { FC } from 'react';
+import { QuilttAuthProviderProps as QuilttAuthProviderProps$1, QuilttSettingsProviderProps } from '@quiltt/react';
+
+type QuilttAuthProviderProps = QuilttAuthProviderProps$1;
+/**
+ * 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.
+ */
+declare const QuilttAuthProvider: FC<QuilttAuthProviderProps>;
+
+type QuilttProviderProps = QuilttSettingsProviderProps & QuilttAuthProviderProps;
+/**
+ * React Native-specific QuilttProvider that combines settings and auth providers
+ * with platform-specific GraphQL client configuration.
+ */
+declare const QuilttProvider: FC<QuilttProviderProps>;
+
+export { QuilttAuthProvider, QuilttProvider };
+export type { QuilttAuthProviderProps };

package/dist/providers/index.js

@@ -0,0 +1,100 @@
+import { jsx } from 'react/jsx-runtime';
+import React, { useMemo } from 'react';
+import { QuilttClient, InMemoryCache, createVersionLink } from '@quiltt/core';
+import { QuilttAuthProvider as QuilttAuthProvider$1, QuilttSettingsProvider } from '@quiltt/react';
+import { Platform } from 'react-native';
+import 'react-native-device-info';
+
+/**
+ * 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';
+    }
+};
+/**
+ * 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`;
+};
+
+/**
+ * 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 { QuilttAuthProvider, QuilttProvider };

package/dist/utils/index.cjs

@@ -0,0 +1,221 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Honeybadger = require('@honeybadger-io/react-native');
+var React = require('react');
+var reactNative = require('react-native');
+var core = require('@quiltt/core');
+var DeviceInfo = require('react-native-device-info');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Honeybadger__default = /*#__PURE__*/_interopDefault(Honeybadger);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var DeviceInfo__default = /*#__PURE__*/_interopDefault(DeviceInfo);
+
+var version = "5.0.1";
+
+// Custom Error Reporter to avoid hooking into or colliding with a client's Honeybadger singleton
+class ErrorReporter {
+    constructor(userAgent){
+        // Create an isolated Honeybadger instance to avoid colliding with client's singleton
+        this.client = Honeybadger__default.default.factory({
+            apiKey: process.env.HONEYBADGER_API_KEY_REACT_NATIVE || '',
+            environment: userAgent,
+            revision: version,
+            reportData: true,
+            enableUncaught: false,
+            enableUnhandledRejection: false
+        });
+    }
+    async notify(error, context) {
+        if (!this.client) {
+            console.warn('ErrorReporter: Honeybadger client not initialized');
+            return;
+        }
+        try {
+            // Set context for this error report
+            if (context) {
+                this.client.setContext(context);
+            }
+            // Notify Honeybadger
+            await this.client.notify(error);
+        } catch (err) {
+            console.error('ErrorReporter: Failed to send error report', err);
+        } finally{
+            // Clear context after reporting (always runs if context was set)
+            if (context) {
+                this.client.clear();
+            }
+        }
+    }
+}
+
+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';
+};
+
+/**
+ * Gets the React version from the runtime
+ */ const getReactVersion = ()=>{
+    return React__default.default.version || 'unknown';
+};
+/**
+ * Gets the React Native version from Platform constants
+ */ const getReactNativeVersion = ()=>{
+    try {
+        const rnVersion = reactNative.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 = reactNative.Platform.OS // 'ios' or 'android'
+        ;
+        const osVersion = reactNative.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
+ */ const getDeviceModel = async ()=>{
+    try {
+        const model = await DeviceInfo__default.default.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 core.getUserAgent(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;
+};
+/**
+ * Creates a URL with proper parameter encoding
+ * @param baseUrl The base URL string
+ * @param params Object containing key-value pairs to be added as search params
+ * @returns A properly formatted URL string
+ */ const createUrlWithParams = (baseUrl, params)=>{
+    try {
+        const url = new URL(baseUrl);
+        // Add each parameter without additional encoding
+        // (URLSearchParams.append will encode them automatically)
+        Object.entries(params).forEach(([key, value])=>{
+            // Skip undefined or null values
+            if (value == null) return;
+            // For oauth_redirect_url specifically, ensure it's not double encoded
+            if (key === 'oauth_redirect_url' && isEncoded(value)) {
+                // Decode once to counteract the automatic encoding that will happen
+                const decodedOnce = decodeURIComponent(value);
+                url.searchParams.append(key, decodedOnce);
+            } else {
+                url.searchParams.append(key, value);
+            }
+        });
+        return url.toString();
+    } catch (error) {
+        console.error('Error creating URL with params:', error);
+        return baseUrl;
+    }
+};
+/**
+ * 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;
+};
+
+exports.ErrorReporter = ErrorReporter;
+exports.createUrlWithParams = createUrlWithParams;
+exports.getDeviceModel = getDeviceModel;
+exports.getErrorMessage = getErrorMessage;
+exports.getOSInfo = getOSInfo;
+exports.getPlatformInfo = getPlatformInfo;
+exports.getPlatformInfoSync = getPlatformInfoSync;
+exports.getReactNativeVersion = getReactNativeVersion;
+exports.getReactVersion = getReactVersion;
+exports.getUserAgent = getUserAgent;
+exports.isEncoded = isEncoded;
+exports.normalizeUrlEncoding = normalizeUrlEncoding;
+exports.smartEncodeURIComponent = smartEncodeURIComponent;

package/dist/utils/index.d.ts

@@ -0,0 +1,66 @@
+declare class ErrorReporter {
+    private client;
+    constructor(userAgent: string);
+    notify(error: Error, context?: any): Promise<void>;
+}
+
+declare const getErrorMessage: (responseStatus?: number, error?: Error) => string;
+
+/**
+ * Gets the React version from the runtime
+ */
+declare const getReactVersion: () => string;
+/**
+ * Gets the React Native version from Platform constants
+ */
+declare const getReactNativeVersion: () => string;
+/**
+ * Gets OS information (platform and version)
+ */
+declare const getOSInfo: () => string;
+/**
+ * Gets device model information
+ */
+declare const getDeviceModel: () => Promise<string>;
+/**
+ * Generates platform information string for React Native
+ * Format: React/<version>; ReactNative/<version>; <OS>/<version>; <device-model>
+ */
+declare const getPlatformInfo: () => Promise<string>;
+/**
+ * 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
+ */
+declare const getPlatformInfoSync: () => string;
+/**
+ * Generates User-Agent string for React Native SDK
+ * Format: Quiltt/<sdk-version> (React/<version>; ReactNative/<version>; <OS>/<version>; <device-model>)
+ */
+declare const getUserAgent: (sdkVersion: string) => Promise<string>;
+
+/**
+ * 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
+ */
+declare const isEncoded: (str: string) => boolean;
+/**
+ * Smart URL encoder that ensures a string is encoded exactly once
+ * @param str The string to encode
+ * @returns A properly URL encoded string
+ */
+declare const smartEncodeURIComponent: (str: string) => string;
+/**
+ * Creates a URL with proper parameter encoding
+ * @param baseUrl The base URL string
+ * @param params Object containing key-value pairs to be added as search params
+ * @returns A properly formatted URL string
+ */
+declare const createUrlWithParams: (baseUrl: string, params: Record<string, string>) => string;
+/**
+ * Normalizes a URL string by decoding it once if it appears to be double-encoded
+ */
+declare const normalizeUrlEncoding: (urlStr: string) => string;
+
+export { ErrorReporter, createUrlWithParams, getDeviceModel, getErrorMessage, getOSInfo, getPlatformInfo, getPlatformInfoSync, getReactNativeVersion, getReactVersion, getUserAgent, isEncoded, normalizeUrlEncoding, smartEncodeURIComponent };