@rejourneyco/react-native 1.0.0

package/src/sdk/navigation.ts

@@ -0,0 +1,157 @@
+/**
+ * Rejourney Navigation Utilities
+ * 
+ * Helper functions for extracting human-readable screen names from
+ * React Navigation / Expo Router state.
+ * 
+ * These functions are used internally by the SDK's automatic navigation
+ * detection. You don't need to import or use these directly.
+ */
+
+/**
+ * Normalize a screen name to be human-readable
+ * Handles common patterns from React Native / Expo Router
+ * 
+ * @param raw - Raw screen name to normalize
+ * @returns Cleaned, human-readable screen name
+ */
+export function normalizeScreenName(raw: string): string {
+    if (!raw) return 'Unknown';
+
+    let name = raw;
+
+    // 1. Remove non-printable characters and weird symbols (often from icons)
+    name = name.replace(/[^\x20-\x7E\s]/g, '');
+
+    // 2. Handle hyphens: my-recipes -> My Recipes
+    name = name.split(/[-_]/).map(word =>
+        word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+    ).join(' ');
+
+    // 3. Remove common suffixes
+    const suffixes = ['Screen', 'Page', 'View', 'Controller', 'ViewController', 'VC'];
+    for (const suffix of suffixes) {
+        if (name.endsWith(suffix) && name.length > suffix.length) {
+            name = name.slice(0, -suffix.length).trim();
+        }
+    }
+
+    // 4. Remove common prefixes (React Native internals)
+    const prefixes = ['RNS', 'RCT', 'RN', 'UI'];
+    for (const prefix of prefixes) {
+        if (name.startsWith(prefix) && name.length > prefix.length + 2) {
+            name = name.slice(prefix.length).trim();
+        }
+    }
+
+    // 5. Handle dynamic route params: [id] -> (omit), [userId] -> "User"
+    name = name.replace(/\[([a-zA-Z]+)(?:Id)?\]/g, (_, param) => {
+        const clean = param.replace(/Id$/i, '');
+        if (clean.length < 2) return '';
+        return clean.charAt(0).toUpperCase() + clean.slice(1);
+    });
+
+    // 6. Remove leftover brackets
+    name = name.replace(/\[\]/g, '');
+
+    // 7. Convert camelCase/PascalCase to Title Case with spaces
+    name = name.replace(/([a-z])([A-Z])/g, '$1 $2');
+
+    // 8. Clean up multiple spaces and trim
+    name = name.replace(/\s+/g, ' ').trim();
+
+    // 9. Capitalize first letter
+    if (name.length > 0) {
+        name = name.charAt(0).toUpperCase() + name.slice(1);
+    }
+
+    return name || 'Unknown';
+}
+
+/**
+ * Get a human-readable screen name from Expo Router path and segments
+ * 
+ * @param pathname - The current route pathname
+ * @param segments - Route segments from useSegments()
+ * @returns Human-readable screen name
+ */
+export function getScreenNameFromPath(pathname: string, segments: string[]): string {
+    // Use segments for cleaner names if available
+    if (segments.length > 0) {
+        // Filter out group markers like (tabs), (auth), etc.
+        const cleanSegments = segments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
+
+        if (cleanSegments.length > 0) {
+            // Process each segment
+            const processedSegments = cleanSegments.map(s => {
+                // Handle dynamic params like [id]
+                if (s.startsWith('[') && s.endsWith(']')) {
+                    const param = s.slice(1, -1);
+                    // Skip pure ID params, keep meaningful ones
+                    if (param === 'id' || param === 'slug') return null;
+                    // Extract meaningful part: userId -> User
+                    const clean = param.replace(/Id$/i, '');
+                    return clean.charAt(0).toUpperCase() + clean.slice(1);
+                }
+                // Regular segment - capitalize
+                return s.charAt(0).toUpperCase() + s.slice(1);
+            }).filter(Boolean);
+
+            if (processedSegments.length > 0) {
+                return processedSegments.join(' > ');
+            }
+        }
+    }
+
+    // Fall back to pathname
+    if (!pathname || pathname === '/') {
+        return 'Home';
+    }
+
+    // Clean up the path
+    let cleanPath = pathname
+        .replace(/^\/(tabs)?/, '') // Remove leading slash and (tabs)
+        .replace(/\([^)]+\)/g, '') // Remove all group markers like (settings)
+        .replace(/\[([^\]]+)\]/g, (_, param) => {
+            // Handle dynamic params in path
+            if (param === 'id' || param === 'slug') return '';
+            const clean = param.replace(/Id$/i, '');
+            return clean.charAt(0).toUpperCase() + clean.slice(1);
+        })
+        .replace(/\/+/g, '/') // Collapse multiple slashes
+        .replace(/^\//, '') // Remove leading slash
+        .replace(/\/$/, '') // Remove trailing slash
+        .replace(/\//g, ' > ') // Replace slashes with arrows
+        .trim();
+
+    if (!cleanPath) {
+        return 'Home';
+    }
+
+    // Capitalize first letter of each word
+    return cleanPath
+        .split(' > ')
+        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+        .filter(s => s.length > 0)
+        .join(' > ') || 'Home';
+}
+
+/**
+ * Get the current route name from a navigation state object
+ * 
+ * @param state - React Navigation state object
+ * @returns Current route name or null
+ */
+export function getCurrentRouteFromState(state: any): string | null {
+    if (!state || !state.routes) return null;
+
+    const route = state.routes[state.index ?? state.routes.length - 1];
+    if (!route) return null;
+
+    // If nested state, recurse
+    if (route.state) {
+        return getCurrentRouteFromState(route.state);
+    }
+
+    return route.name || null;
+}

package/src/sdk/networkInterceptor.ts

@@ -0,0 +1,440 @@
+/**
+ * Network Interceptor for Rejourney - Optimized Version
+ * 
+ * Automatically intercepts fetch() and XMLHttpRequest to log API calls.
+ * 
+ * PERFORMANCE OPTIMIZATIONS:
+ * - Minimal synchronous overhead (just captures timing, no processing)
+ * - Batched async logging (doesn't block requests)
+ * - Circular buffer with max size limit
+ * - Sampling for high-frequency endpoints
+ * - No string allocations in hot path
+ * - Lazy URL parsing
+ * - PII Scrubbing for query parameters
+ */
+
+import type { NetworkRequestParams } from '../types';
+
+// Store original implementations
+let originalFetch: typeof fetch | null = null;
+let originalXHROpen: typeof XMLHttpRequest.prototype.open | null = null;
+let originalXHRSend: typeof XMLHttpRequest.prototype.send | null = null;
+
+// Callback to log network requests (called asynchronously)
+let logCallback: ((request: NetworkRequestParams) => void) | null = null;
+
+// Pending requests buffer (circular buffer for memory efficiency)
+const MAX_PENDING_REQUESTS = 100;
+const pendingRequests: (NetworkRequestParams | null)[] = new Array(MAX_PENDING_REQUESTS).fill(null);
+let pendingHead = 0;
+let pendingTail = 0;
+let pendingCount = 0;
+
+// Flush timer
+let flushTimer: ReturnType<typeof setTimeout> | null = null;
+const FLUSH_INTERVAL = 500; // Flush every 500ms
+
+// Sampling for high-frequency endpoints
+const endpointCounts = new Map<string, { count: number; lastReset: number }>();
+const SAMPLE_WINDOW = 10000; // 10 second window
+const MAX_PER_ENDPOINT = 20; // Max 20 requests per endpoint per window
+
+// Configuration
+const config = {
+  enabled: true,
+  ignorePatterns: [] as string[], // Simple string patterns for fast matching
+  maxUrlLength: 300, // Shorter for efficiency
+  captureSizes: false, // Disabled by default for performance
+};
+
+// PII Scrubbing - Sensitive keys to look for in query params
+const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
+
+/**
+ * Scrub sensitive data from URL
+ */
+function scrubUrl(url: string): string {
+  try {
+    // Fast check if URL might contain params
+    if (url.indexOf('?') === -1) return url;
+
+    const urlObj = new URL(url);
+    let modified = false;
+
+    SENSITIVE_KEYS.forEach(key => {
+      if (urlObj.searchParams.has(key)) {
+        urlObj.searchParams.set(key, '[REDACTED]');
+        modified = true;
+      }
+    });
+
+    // Also scan for partial matches (case-insensitive) if strict scrubbing needed
+    // But for performance, we stick to exact keys or common variations
+
+    return modified ? urlObj.toString() : url;
+  } catch {
+    // If URL parsing fails (relative URL?), try primitive replacement
+    let scrubbed = url;
+    SENSITIVE_KEYS.forEach(key => {
+      const regex = new RegExp(`([?&])${key}=[^&]*`, 'gi');
+      scrubbed = scrubbed.replace(regex, `$1${key}=[REDACTED]`);
+    });
+    return scrubbed;
+  }
+}
+
+/**
+ * Fast check if URL should be ignored (no regex for speed)
+ */
+function shouldIgnoreUrl(url: string): boolean {
+  const patterns = config.ignorePatterns;
+  for (let i = 0; i < patterns.length; i++) {
+    const pattern = patterns[i];
+    if (pattern && url.indexOf(pattern) !== -1) return true;
+  }
+  return false;
+}
+
+/**
+ * Check if we should sample this request (rate limiting per endpoint)
+ */
+function shouldSampleRequest(urlPath: string): boolean {
+  const now = Date.now();
+  let entry = endpointCounts.get(urlPath);
+
+  if (!entry || now - entry.lastReset > SAMPLE_WINDOW) {
+    entry = { count: 0, lastReset: now };
+    endpointCounts.set(urlPath, entry);
+  }
+
+  entry.count++;
+  return entry.count <= MAX_PER_ENDPOINT;
+}
+
+/**
+ * Add request to pending buffer (non-blocking)
+ */
+function queueRequest(request: NetworkRequestParams): void {
+  if (pendingCount >= MAX_PENDING_REQUESTS) {
+    // Buffer full, drop oldest
+    pendingHead = (pendingHead + 1) % MAX_PENDING_REQUESTS;
+    pendingCount--;
+  }
+
+  // Scrub URL before queuing
+  request.url = scrubUrl(request.url);
+
+  pendingRequests[pendingTail] = request;
+  pendingTail = (pendingTail + 1) % MAX_PENDING_REQUESTS;
+  pendingCount++;
+
+  // Schedule flush if not already scheduled
+  if (!flushTimer) {
+    flushTimer = setTimeout(flushPendingRequests, FLUSH_INTERVAL);
+  }
+}
+
+/**
+ * Flush pending requests to callback
+ */
+function flushPendingRequests(): void {
+  flushTimer = null;
+
+  if (!logCallback || pendingCount === 0) return;
+
+  // Process all pending requests
+  while (pendingCount > 0) {
+    const request = pendingRequests[pendingHead];
+    pendingRequests[pendingHead] = null; // Allow GC
+    pendingHead = (pendingHead + 1) % MAX_PENDING_REQUESTS;
+    pendingCount--;
+
+    if (request) {
+      try {
+        logCallback(request);
+      } catch {
+        // Ignore logging errors
+      }
+    }
+  }
+}
+
+/**
+ * Parse URL efficiently (only extract what we need)
+ */
+function parseUrlFast(url: string): { host: string; path: string } {
+  // Fast path for common patterns
+  let hostEnd = -1;
+  let pathStart = -1;
+
+  // Find :// 
+  const protoEnd = url.indexOf('://');
+  if (protoEnd !== -1) {
+    const afterProto = protoEnd + 3;
+    // Find end of host (first / after ://)
+    const slashPos = url.indexOf('/', afterProto);
+    if (slashPos !== -1) {
+      hostEnd = slashPos;
+      pathStart = slashPos;
+    } else {
+      hostEnd = url.length;
+      pathStart = url.length;
+    }
+
+    return {
+      host: url.substring(afterProto, hostEnd),
+      path: pathStart < url.length ? url.substring(pathStart) : '/',
+    };
+  }
+
+  // Relative URL
+  return { host: '', path: url };
+}
+
+/**
+ * Intercept fetch - minimal overhead version
+ */
+function interceptFetch(): void {
+  if (typeof globalThis.fetch === 'undefined') return;
+  if (originalFetch) return;
+
+  originalFetch = globalThis.fetch;
+
+  globalThis.fetch = function optimizedFetch(
+    input: RequestInfo | URL,
+    init?: RequestInit
+  ): Promise<Response> {
+    // Fast path: if disabled or no callback, skip entirely
+    if (!config.enabled || !logCallback) {
+      return originalFetch!(input, init);
+    }
+
+    // Extract URL string (minimal work)
+    const url = typeof input === 'string'
+      ? input
+      : input instanceof URL
+        ? input.href
+        : (input as Request).url;
+
+    // Fast ignore check
+    if (shouldIgnoreUrl(url)) {
+      return originalFetch!(input, init);
+    }
+
+    // Parse URL and check sampling
+    const { path } = parseUrlFast(url);
+    if (!shouldSampleRequest(path)) {
+      return originalFetch!(input, init);
+    }
+
+    // Capture start time (only synchronous work)
+    const startTime = Date.now();
+    const method = ((init?.method || 'GET').toUpperCase()) as NetworkRequestParams['method'];
+
+    // Call original fetch
+    return originalFetch!(input, init).then(
+      (response) => {
+        // Success - queue the log asynchronously
+        queueRequest({
+          requestId: `f${startTime}`,
+          method,
+          url: url.length > config.maxUrlLength ? url.substring(0, config.maxUrlLength) : url,
+          statusCode: response.status,
+          duration: Date.now() - startTime,
+          startTimestamp: startTime,
+          endTimestamp: Date.now(),
+          success: response.ok,
+        });
+        return response;
+      },
+      (error) => {
+        // Error - queue the log asynchronously  
+        queueRequest({
+          requestId: `f${startTime}`,
+          method,
+          url: url.length > config.maxUrlLength ? url.substring(0, config.maxUrlLength) : url,
+          statusCode: 0,
+          duration: Date.now() - startTime,
+          startTimestamp: startTime,
+          endTimestamp: Date.now(),
+          success: false,
+          errorMessage: error?.message || 'Network error',
+        });
+        throw error;
+      }
+    );
+  };
+}
+
+/**
+ * Intercept XMLHttpRequest - minimal overhead version
+ */
+function interceptXHR(): void {
+  if (typeof XMLHttpRequest === 'undefined') return;
+  if (originalXHROpen) return;
+
+  originalXHROpen = XMLHttpRequest.prototype.open;
+  originalXHRSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function (
+    method: string,
+    url: string | URL,
+    async: boolean = true,
+    username?: string | null,
+    password?: string | null
+  ): void {
+    const urlString = typeof url === 'string' ? url : url.toString();
+
+    // Store minimal info
+    (this as any).__rj = {
+      m: method.toUpperCase(),
+      u: urlString,
+      t: 0,
+    };
+
+    return originalXHROpen!.call(this, method, urlString, async, username, password);
+  };
+
+  XMLHttpRequest.prototype.send = function (body?: any): void {
+    const data = (this as any).__rj;
+
+    if (!config.enabled || !logCallback || !data || shouldIgnoreUrl(data.u)) {
+      return originalXHRSend!.call(this, body);
+    }
+
+    // Check sampling
+    const { path } = parseUrlFast(data.u);
+    if (!shouldSampleRequest(path)) {
+      return originalXHRSend!.call(this, body);
+    }
+
+    data.t = Date.now();
+
+    const onComplete = () => {
+      const endTime = Date.now();
+      queueRequest({
+        requestId: `x${data.t}`,
+        method: data.m as NetworkRequestParams['method'],
+        url: data.u.length > config.maxUrlLength ? data.u.substring(0, config.maxUrlLength) : data.u,
+        statusCode: this.status,
+        duration: endTime - data.t,
+        startTimestamp: data.t,
+        endTimestamp: endTime,
+        success: this.status >= 200 && this.status < 400,
+        errorMessage: this.status === 0 ? 'Network error' : undefined,
+      });
+    };
+
+    // Use load/error events (more efficient than readystatechange)
+    // Note: We use basic addEventListener without options for RN compatibility
+    this.addEventListener('load', onComplete);
+    this.addEventListener('error', onComplete);
+    this.addEventListener('abort', onComplete);
+
+    return originalXHRSend!.call(this, body);
+  };
+}
+
+/**
+ * Initialize network interception
+ */
+export function initNetworkInterceptor(
+  callback: (request: NetworkRequestParams) => void,
+  options?: {
+    ignoreUrls?: (string | RegExp)[];
+    captureSizes?: boolean;
+  }
+): void {
+  logCallback = callback;
+
+  // Convert patterns to simple strings for fast matching
+  if (options?.ignoreUrls) {
+    config.ignorePatterns = options.ignoreUrls
+      .filter((p): p is string => typeof p === 'string');
+    // Note: RegExp patterns are not supported in optimized version for performance
+  }
+
+  if (options?.captureSizes !== undefined) {
+    config.captureSizes = options.captureSizes;
+  }
+
+  interceptFetch();
+  interceptXHR();
+}
+
+/**
+ * Disable network interception
+ */
+export function disableNetworkInterceptor(): void {
+  config.enabled = false;
+
+  // Flush any pending requests
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Re-enable network interception
+ */
+export function enableNetworkInterceptor(): void {
+  config.enabled = true;
+}
+
+/**
+ * Force flush pending requests (call before app termination)
+ */
+export function flushNetworkRequests(): void {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Restore original fetch and XHR
+ */
+export function restoreNetworkInterceptor(): void {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+
+  if (originalXHROpen && originalXHRSend) {
+    XMLHttpRequest.prototype.open = originalXHROpen;
+    XMLHttpRequest.prototype.send = originalXHRSend;
+    originalXHROpen = null;
+    originalXHRSend = null;
+  }
+
+  logCallback = null;
+
+  // Clear state
+  pendingHead = 0;
+  pendingTail = 0;
+  pendingCount = 0;
+  endpointCounts.clear();
+
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+}
+
+/**
+ * Get stats for debugging
+ */
+export function getNetworkInterceptorStats(): {
+  pendingCount: number;
+  endpointCount: number;
+  enabled: boolean;
+} {
+  return {
+    pendingCount,
+    endpointCount: endpointCounts.size,
+    enabled: config.enabled,
+  };
+}