@rejourneyco/react-native 1.0.7

package/lib/commonjs/sdk/navigation.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCurrentRouteFromState = getCurrentRouteFromState;
+exports.getScreenNameFromPath = getScreenNameFromPath;
+exports.normalizeScreenName = normalizeScreenName;
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 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;
+  name = name.replace(/[^\x20-\x7E\s]/g, '');
+  name = name.split(/[-_]/).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
+  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();
+    }
+  }
+  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();
+    }
+  }
+  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);
+  });
+  name = name.replace(/\[\]/g, '');
+  name = name.replace(/([a-z])([A-Z])/g, '$1 $2');
+  name = name.replace(/\s+/g, ' ').trim();
+  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) {
+  if (segments.length > 0) {
+    const cleanSegments = segments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
+    if (cleanSegments.length > 0) {
+      const processedSegments = cleanSegments.map(s => {
+        if (s.startsWith('[') && s.endsWith(']')) {
+          const param = s.slice(1, -1);
+          if (param === 'id' || param === 'slug') return null;
+          if (param === 'id' || param === 'slug') return null;
+          const clean = param.replace(/Id$/i, '');
+          return clean.charAt(0).toUpperCase() + clean.slice(1);
+        }
+        return s.charAt(0).toUpperCase() + s.slice(1);
+      }).filter(Boolean);
+      if (processedSegments.length > 0) {
+        return processedSegments.join(' > ');
+      }
+    }
+  }
+  if (!pathname || pathname === '/') {
+    return 'Home';
+  }
+  const cleanPath = pathname.replace(/^\/(tabs)?/, '').replace(/\([^)]+\)/g, '').replace(/\[([^\]]+)\]/g, (_, param) => {
+    if (param === 'id' || param === 'slug') return '';
+    const clean = param.replace(/Id$/i, '');
+    return clean.charAt(0).toUpperCase() + clean.slice(1);
+  }).replace(/\/+/g, '/').replace(/^\//, '').replace(/\/$/, '').replace(/\//g, ' > ').trim();
+  if (!cleanPath) {
+    return 'Home';
+  }
+  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 (route.state) {
+    return getCurrentRouteFromState(route.state);
+  }
+  return route.name || null;
+}
+//# sourceMappingURL=navigation.js.map

package/lib/commonjs/sdk/networkInterceptor.js

@@ -0,0 +1,375 @@
+"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;
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 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
+ */
+
+let originalFetch = null;
+let originalXHROpen = null;
+let originalXHRSend = null;
+let logCallback = null;
+const MAX_PENDING_REQUESTS = 100;
+const pendingRequests = new Array(MAX_PENDING_REQUESTS).fill(null);
+let pendingHead = 0;
+let pendingTail = 0;
+let pendingCount = 0;
+let flushTimer = null;
+const FLUSH_INTERVAL = 500;
+const endpointCounts = new Map();
+const SAMPLE_WINDOW = 10000;
+const MAX_PER_ENDPOINT = 20;
+const config = {
+  enabled: true,
+  ignorePatterns: [],
+  maxUrlLength: 300,
+  captureSizes: false
+};
+const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
+
+/**
+ * Scrub sensitive data from URL
+ */
+function scrubUrl(url) {
+  try {
+    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;
+      }
+    });
+    return modified ? urlObj.toString() : url;
+  } catch {
+    // Ignore error, fallback to primitive scrubbing
+
+    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--;
+  }
+  request.url = scrubUrl(request.url);
+  pendingRequests[pendingTail] = request;
+  pendingTail = (pendingTail + 1) % MAX_PENDING_REQUESTS;
+  pendingCount++;
+  if (!flushTimer) {
+    flushTimer = setTimeout(flushPendingRequests, FLUSH_INTERVAL);
+  }
+}
+
+/**
+ * Flush pending requests to callback
+ */
+function flushPendingRequests() {
+  flushTimer = null;
+  if (!logCallback || pendingCount === 0) return;
+  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
+      }
+    }
+  }
+}
+
+/**
+ * Parse URL efficiently (only extract what we need)
+ */
+function parseUrlFast(url) {
+  // Fast path for common patterns
+  let hostEnd = -1;
+  let pathStart = -1;
+  const protoEnd = url.indexOf('://');
+  if (protoEnd !== -1) {
+    const afterProto = protoEnd + 3;
+    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) : '/'
+    };
+  }
+  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) {
+    if (!config.enabled || !logCallback) {
+      return originalFetch(input, init);
+    }
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+    if (shouldIgnoreUrl(url)) {
+      return originalFetch(input, init);
+    }
+
+    // Parse URL and check sampling
+    const {
+      path
+    } = parseUrlFast(url);
+    if (!shouldSampleRequest(path)) {
+      return originalFetch(input, init);
+    }
+    const startTime = Date.now();
+    const method = (init?.method || 'GET').toUpperCase();
+    return originalFetch(input, init).then(response => {
+      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 => {
+      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();
+    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);
+    }
+    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
+      });
+    };
+    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;
+  if (options?.ignoreUrls) {
+    config.ignorePatterns = options.ignoreUrls.filter(p => typeof p === 'string');
+  }
+  if (options?.captureSizes !== undefined) {
+    config.captureSizes = options.captureSizes;
+  }
+  interceptFetch();
+  interceptXHR();
+}
+
+/**
+ * Disable network interception
+ */
+function disableNetworkInterceptor() {
+  config.enabled = false;
+  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