@rejourneyco/react-native 1.0.0

package/lib/commonjs/sdk/navigation.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCurrentRouteFromState = getCurrentRouteFromState;
+exports.getScreenNameFromPath = getScreenNameFromPath;
+exports.normalizeScreenName = normalizeScreenName;
+/**
+ * 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
+ */
+function normalizeScreenName(raw) {
+  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
+ */
+function getScreenNameFromPath(pathname, segments) {
+  // 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
+ */
+function getCurrentRouteFromState(state) {
+  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;
+}
+//# sourceMappingURL=navigation.js.map

package/lib/commonjs/sdk/networkInterceptor.js

@@ -0,0 +1,412 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.disableNetworkInterceptor = disableNetworkInterceptor;
+exports.enableNetworkInterceptor = enableNetworkInterceptor;
+exports.flushNetworkRequests = flushNetworkRequests;
+exports.getNetworkInterceptorStats = getNetworkInterceptorStats;
+exports.initNetworkInterceptor = initNetworkInterceptor;
+exports.restoreNetworkInterceptor = restoreNetworkInterceptor;
+/**
+ * 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
+ */
+
+// Store original implementations
+let originalFetch = null;
+let originalXHROpen = null;
+let originalXHRSend = null;
+
+// Callback to log network requests (called asynchronously)
+let logCallback = null;
+
+// Pending requests buffer (circular buffer for memory efficiency)
+const MAX_PENDING_REQUESTS = 100;
+const pendingRequests = new Array(MAX_PENDING_REQUESTS).fill(null);
+let pendingHead = 0;
+let pendingTail = 0;
+let pendingCount = 0;
+
+// Flush timer
+let flushTimer = null;
+const FLUSH_INTERVAL = 500; // Flush every 500ms
+
+// Sampling for high-frequency endpoints
+const endpointCounts = new Map();
+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: [],
+  // 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) {
+  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) {
+  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) {
+  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) {
+  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() {
+  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) {
+  // 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() {
+  if (typeof globalThis.fetch === 'undefined') return;
+  if (originalFetch) return;
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = function optimizedFetch(input, init) {
+    // 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.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();
+
+    // 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() {
+  if (typeof XMLHttpRequest === 'undefined') return;
+  if (originalXHROpen) return;
+  originalXHROpen = XMLHttpRequest.prototype.open;
+  originalXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function (method, url, async = true, username, password) {
+    const urlString = typeof url === 'string' ? url : url.toString();
+
+    // Store minimal info
+    this.__rj = {
+      m: method.toUpperCase(),
+      u: urlString,
+      t: 0
+    };
+    return originalXHROpen.call(this, method, urlString, async, username, password);
+  };
+  XMLHttpRequest.prototype.send = function (body) {
+    const data = this.__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,
+        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
+ */
+function initNetworkInterceptor(callback, options) {
+  logCallback = callback;
+
+  // Convert patterns to simple strings for fast matching
+  if (options?.ignoreUrls) {
+    config.ignorePatterns = options.ignoreUrls.filter(p => 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
+ */
+function disableNetworkInterceptor() {
+  config.enabled = false;
+
+  // Flush any pending requests
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Re-enable network interception
+ */
+function enableNetworkInterceptor() {
+  config.enabled = true;
+}
+
+/**
+ * Force flush pending requests (call before app termination)
+ */
+function flushNetworkRequests() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Restore original fetch and XHR
+ */
+function restoreNetworkInterceptor() {
+  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
+ */
+function getNetworkInterceptorStats() {
+  return {
+    pendingCount,
+    endpointCount: endpointCounts.size,
+    enabled: config.enabled
+  };
+}
+//# sourceMappingURL=networkInterceptor.js.map