react-native-debug-toolkit 0.6.3 → 2.0.0

package/lib/features/ConsoleLogFeature.js

@@ -1,70 +0,0 @@
-const MAX_LOGS = 200; // Max number of console logs to store
-const logs = [];
-const originalConsole = {}; // Store original console methods
-
-const _interceptConsole = () => {
-  const levels = ['log', 'info', 'warn', 'error'];
-  levels.forEach(level => {
-    if (typeof console[level] === 'function') { // Check if it's actually a function
-      originalConsole[level] = console[level]; // Store original
-
-      console[level] = (...args) => {
-        // Call original console method first
-        originalConsole[level].apply(console, args); // Use apply for proper context
-
-        // Add log entry
-        if (logs.length >= MAX_LOGS) {
-          logs.shift(); // Remove the oldest log if limit is reached
-        }
-
-        // Store log data
-        logs.push({
-          timestamp: new Date(),
-          level: level,
-          data: args, // Store all arguments passed to console[level]
-        });
-
-        // TODO: Notify UI if needed
-      };
-    }
-  });
-};
-
-const _restoreConsole = () => {
-  Object.keys(originalConsole).forEach(level => {
-    if (originalConsole[level]) {
-      console[level] = originalConsole[level];
-      delete originalConsole[level]; // Clean up stored method
-    }
-  });
-};
-
-const setup = () => {
-  _interceptConsole();
-};
-
-const getData = () => {
-  return logs;
-};
-
-const cleanup = () => {
-  _restoreConsole();
-  logs.length = 0; // More efficient way to clear array
-};
-
-// Factory function remains similar but uses the module-level functions
-export const createConsoleLogFeature = () => {
-  // Ensure setup is only called once if multiple features might be created (though unlikely for console)
-  // A simple flag could work here if needed, but maybe setup belongs in the main toolkit init.
-  return {
-    name: 'console',
-    label: 'Console Logs',
-    setup: setup, // Reference module-level function
-    getData: getData, // Reference module-level function
-    cleanup: cleanup, // Reference module-level function
-  };
-};
-
-// Note: This refactor removes the class structure entirely, relying on module scope
-// for the "singleton" nature. Decide if this fits the overall pattern of other features.
-// The original class-based singleton is also perfectly valid.

package/lib/features/NavigationLogFeature.js

@@ -1,45 +0,0 @@
-const MAX_LOGS = 200; // Max number of navigation logs to store
-const logs = [];
-const originalNavigationMethods = {}; // Store original navigation methods
-
-const setup = () => {
-  // Note: Actual navigation interception will be done in the main app code
-  // This is just a setup function for compatibility with the feature API
-};
-
-// Function to add navigation log
-export const addNavigationLog = (action, from, to, startTime, duration, debugLog) => {
-  // Store log data
-  logs.push({
-    timestamp: new Date(),
-    action: action, // push, pop, replace, etc.
-    from: from,     // source route info
-    to: to,         // destination route info
-    startTime: startTime,
-    duration: duration,
-    debugLog: debugLog,
-  });
-
-  // Trim logs if they exceed the maximum limit
-  if (logs.length > MAX_LOGS) {
-    logs.splice(0, logs.length - MAX_LOGS);
-  }
-};
-
-const getData = () => {
-  return logs;
-};
-
-const cleanup = () => {
-  logs.length = 0; // Clear array
-};
-
-export const createNavigationLogFeature = () => {
-  return {
-    name: 'navigation',
-    label: 'Navigation Logs',
-    setup: setup,
-    getData: getData,
-    cleanup: cleanup,
-  };
-}; 

package/lib/features/NetworkFeature.js

@@ -1,389 +0,0 @@
-import React from 'react'
-
-class NetworkFeature {
-  static instance = null
-  static MAX_LOGS = 200
-
-  constructor() {
-    if (NetworkFeature.instance) {
-      return NetworkFeature.instance
-    }
-
-    this.logs = []
-    this.pendingAxiosRequests = new Map()
-    this.originalFetch = null
-    this.blacklist = [] // URL patterns to exclude from logging
-
-    NetworkFeature.instance = this
-  }
-
-  setup() {
-
-    // this._interceptFetch()
-    return this
-  }
-
-  getData() {
-    return this.logs
-  }
-
-  cleanup() {
-    if (this.originalFetch) {
-      global.fetch = this.originalFetch
-      this.originalFetch = null
-    }
-
-    this.logs = []
-    this.pendingAxiosRequests.clear()
-  }
-
-  // Check if a URL matches any pattern in the blacklist
-  isUrlBlacklisted(url) {
-    if (!url) return false
-    
-    return this.blacklist.some(pattern => {
-      if (pattern instanceof RegExp) {
-        return pattern.test(url)
-      }
-      return url.includes(pattern)
-    })
-  }
-
-  // Add a URL pattern to blacklist
-  addUrlToBlacklist(pattern) {
-    if (!this.blacklist.some(p => 
-        (p instanceof RegExp && pattern instanceof RegExp) ? 
-        p.toString() === pattern.toString() : p === pattern)) {
-      this.blacklist.push(pattern)
-    }
-  }
-
-  // Remove a URL pattern from blacklist
-  removeUrlFromBlacklist(pattern) {
-    this.blacklist = this.blacklist.filter(p => 
-      (p instanceof RegExp && pattern instanceof RegExp) ? 
-      p.toString() !== pattern.toString() : p !== pattern)
-  }
-
-  // Clear all patterns from blacklist
-  clearBlacklist() {
-    this.blacklist = []
-  }
-
-  setupAxiosInterceptors(axiosInstance) {
-
-    axiosInstance.interceptors.request.use(
-      (config) => {
-        // Generate a unique ID if one doesn't exist
-        if (!config.headers) {
-          config.headers = {}
-        }
-
-        if (!config.headers['X-Request-Id']) {
-          config.headers['X-Request-Id'] =
-            Date.now().toString() + Math.random().toString(36).substring(2, 10)
-        }
-
-        const trackId = config.headers['X-Request-Id']
-        this.pendingAxiosRequests.set(trackId, {
-          timestamp: new Date(),
-          startTime: Date.now(),
-        })
-
-        return config
-      },
-      (error) => {
-        this.logAxiosError(error)
-        return Promise.reject(error)
-      },
-    )
-
-    axiosInstance.interceptors.response.use(
-      (response) => {
-        this.logAxiosResponse(response)
-        return response
-      },
-      (error) => {
-        this.logAxiosError(error)
-        return Promise.reject(error)
-      },
-    )
-  }
-
-  logAxiosResponse(response) {
-    if (!response || !response.config || !response.config.headers) {
-      return
-    }
-
-    const trackId = response.config.headers['X-Request-Id']
-    const pendingRequest = this.pendingAxiosRequests.get(trackId)
-
-    if (!pendingRequest) {
-      return
-    }
-
-    const url = `${response.config.baseURL || ''}${response.config.url}`
-    
-    // Skip logging if URL is blacklisted
-    if (this.isUrlBlacklisted(url)) {
-      this.pendingAxiosRequests.delete(trackId)
-      return
-    }
-
-    if (this.logs.length >= NetworkFeature.MAX_LOGS) {
-      this.logs.shift()
-    }
-
-    // Calculate duration
-    const duration = Date.now() - pendingRequest.startTime
-
-    const logEntry = {
-      timestamp: pendingRequest.timestamp,
-      duration: Math.round(duration),
-      request: {
-        url: url,
-        method: response.config.method?.toUpperCase() || 'GET',
-        headers: response.config.headers,
-        body: response.config.data || response.config.params,
-      },
-      response: {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-      },
-    }
-
-    if (response.data && typeof response.data === 'object') {
-      logEntry.response.success = response.data.success !== false
-      logEntry.response.data = response.data
-    } else {
-      logEntry.response.success =
-        response.status >= 200 && response.status < 300
-
-      if (response.data) {
-        logEntry.response.data = response.data
-      }
-    }
-
-    this.logs.push(logEntry)
-    this.pendingAxiosRequests.delete(trackId)
-  }
-
-  logAxiosError(error) {
-    if (!error.config) {
-      return
-    }
-
-    if (!error.config.headers) {
-      error.config.headers = {}
-    }
-
-    const trackId = error.config.headers['X-Request-Id']
-    const pendingRequest = this.pendingAxiosRequests.get(trackId)
-
-    const startTime = pendingRequest
-      ? pendingRequest.startTime
-      : Date.now() - 100
-      
-    const url = `${error.config.baseURL || ''}${error.config.url}`
-    
-    // Skip logging if URL is blacklisted
-    if (this.isUrlBlacklisted(url)) {
-      this.pendingAxiosRequests.delete(trackId)
-      return
-    }
-
-    if (this.logs.length >= NetworkFeature.MAX_LOGS) {
-      this.logs.shift()
-    }
-
-    const duration = Date.now() - startTime
-
-    const logEntry = {
-      timestamp: pendingRequest ? pendingRequest.timestamp : new Date(),
-      duration: Math.round(duration),
-      request: {
-        url: url,
-        method: error.config.method?.toUpperCase() || 'GET',
-        headers: error.config.headers,
-        body: error.config.data || error.config.params,
-      },
-      error: error.message,
-      success: false,
-    }
-
-    if (error.response && error.response.data) {
-      logEntry.response = {
-        status: error.response.status,
-        statusText: error.response.statusText,
-        headers: error.response.headers,
-        data: error.response.data,
-        success: false,
-      }
-    }
-
-    this.logs.push(logEntry)
-    this.pendingAxiosRequests.delete(trackId)
-  }
-
-  _interceptFetch() {
-
-    this.originalFetch = global.fetch
-
-    global.fetch = async (...args) => {
-      const request = args[0]
-      const options = args[1] || {}
-      const startTime = Date.now()
-
-      try {
-        const response = await this.originalFetch(...args)
-        this._logFetchResponse(request, options, response.clone(), startTime)
-        return response
-      } catch (error) {
-        this._logFetchError(request, options, error, startTime)
-        throw error
-      }
-    }
-  }
-
-  _logFetchResponse(request, options, response, startTime) {
-    const requestUrl = typeof request === 'string' ? request : request.url
-    
-    // Skip logging if URL is blacklisted
-    if (this.isUrlBlacklisted(requestUrl)) {
-      return
-    }
-    
-    if (this.logs.length >= NetworkFeature.MAX_LOGS) {
-      this.logs.shift()
-    }
-
-    const duration = Date.now() - startTime
-
-    const commonData = {
-      timestamp: new Date(),
-      duration: Math.round(duration),
-      request: {
-        url: requestUrl,
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        body: options.body,
-      },
-    }
-
-    // Try to parse JSON response
-    response
-      .text()
-      .then((text) => {
-        let responseData
-        let success = response.status >= 200 && response.status < 300
-
-        try {
-          // Try to parse as JSON
-          if (text) {
-            responseData = JSON.parse(text)
-
-            // Use API success flag if available
-            if (responseData && typeof responseData.success !== 'undefined') {
-              success = !!responseData.success
-            }
-          }
-        } catch (e) {
-          // Not JSON, use text response
-          responseData = text
-        }
-
-        const logEntry = {
-          ...commonData,
-          response: {
-            status: response.status,
-            statusText: response.statusText,
-            headers: this._headersToObject(response.headers),
-            data: responseData,
-            success: success,
-          },
-        }
-
-        this.logs.push(logEntry)
-      })
-      .catch((err) => {
-        // Fallback for when we can't read the response body
-        const logEntry = {
-          ...commonData,
-          response: {
-            status: response.status,
-            statusText: response.statusText,
-            headers: this._headersToObject(response.headers),
-            success: response.status >= 200 && response.status < 300,
-          },
-        }
-
-        this.logs.push(logEntry)
-      })
-  }
-
-  _logFetchError(request, options, error, startTime) {
-    const requestUrl = typeof request === 'string' ? request : request.url
-    
-    // Skip logging if URL is blacklisted
-    if (this.isUrlBlacklisted(requestUrl)) {
-      return
-    }
-    
-    if (this.logs.length >= NetworkFeature.MAX_LOGS) {
-      this.logs.shift()
-    }
-
-    const duration = Date.now() - startTime
-
-    this.logs.push({
-      timestamp: new Date(),
-      duration: Math.round(duration),
-      request: {
-        url: requestUrl,
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        body: options.body,
-      },
-      error: error.message,
-      success: false,
-    })
-  }
-
-  // Utility to convert Headers object to plain object
-  _headersToObject(headers) {
-    const result = {}
-
-    if (headers && typeof headers.forEach === 'function') {
-      headers.forEach((value, key) => {
-        result[key] = value
-      })
-    } else if (headers) {
-      // Fallback for non-standard headers object
-      Object.keys(headers).forEach((key) => {
-        result[key] = headers[key]
-      })
-    }
-
-    return result
-  }
-}
-
-export const createNetworkFeature = () => {
-  const feature = new NetworkFeature()
-
-  return {
-    name: 'network',
-    label: 'Network Logs',
-    setup: () => feature.setup(),
-    getData: () => feature.getData(),
-    cleanup: () => feature.cleanup(),
-    setupAxiosInterceptors: (axiosInstance) =>
-      feature.setupAxiosInterceptors(axiosInstance),
-    // Expose blacklist management methods
-    addUrlToBlacklist: (pattern) => feature.addUrlToBlacklist(pattern),
-    removeUrlFromBlacklist: (pattern) => feature.removeUrlFromBlacklist(pattern),
-    clearBlacklist: () => feature.clearBlacklist(),
-    getBlacklist: () => feature.blacklist,
-  }
-}