react-native-inapp-inspector 1.0.0

package/dist/commonjs/customHooks/consoleLogger.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupConsoleLogger = exports.getConsoleLogs = exports.clearConsoleLogs = exports.subscribeConsoleLogs = void 0;
+const logFilters_1 = require("./logFilters");
+let logs = [];
+let listeners = [];
+let counter = 0;
+let isIntercepting = false;
+const MAX_LOGS = 100;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const formatArgs = (args) => {
+    return args
+        .map(arg => {
+        if (arg === null)
+            return 'null';
+        if (arg === undefined)
+            return 'undefined';
+        if (typeof arg === 'object') {
+            try {
+                return JSON.stringify(arg, null, 2);
+            }
+            catch {
+                return Object.prototype.toString.call(arg);
+            }
+        }
+        return String(arg);
+    })
+        .join(' ');
+};
+const getCallerFromStack = () => {
+    try {
+        const stack = new Error().stack;
+        if (!stack)
+            return 'Unknown';
+        const lines = stack.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip internal console logger stack frames and native helpers
+            if (line.includes('consoleLogger') ||
+                line.includes('setupConsoleLogger') ||
+                line.includes('node_modules') ||
+                line.includes('Error')) {
+                continue;
+            }
+            return line.trim().replace(/^at /, '');
+        }
+    }
+    catch (e) { }
+    return 'Unknown';
+};
+const notify = () => {
+    const snapshot = [...logs];
+    listeners.forEach(cb => cb(snapshot));
+};
+const addLog = (type, args, sourceMethod) => {
+    if (isIntercepting)
+        return;
+    isIntercepting = true;
+    try {
+        const message = formatArgs(args);
+        // Check if the log should be ignored based on starting prefixes across all categories
+        const allPrefixes = [
+            ...((logFilters_1.IGNORED_LOG_PREFIXES && logFilters_1.IGNORED_LOG_PREFIXES.info) || []),
+            ...((logFilters_1.IGNORED_LOG_PREFIXES && logFilters_1.IGNORED_LOG_PREFIXES.warn) || []),
+            ...((logFilters_1.IGNORED_LOG_PREFIXES && logFilters_1.IGNORED_LOG_PREFIXES.error) || []),
+        ].filter(p => typeof p === 'string' && p.trim().length > 0);
+        if (allPrefixes.some(prefix => message
+            .toLowerCase()
+            .trim()
+            .startsWith(prefix.toLowerCase().trim()) ||
+            message.toLowerCase().trim().includes(prefix.toLowerCase().trim()))) {
+            return;
+        }
+        const caller = getCallerFromStack();
+        const newLog = {
+            id: counter++,
+            type,
+            message,
+            timestamp: Date.now(),
+            caller,
+            sourceMethod,
+        };
+        logs.unshift(newLog);
+        logs = logs.slice(0, MAX_LOGS);
+        notify();
+    }
+    catch (e) {
+        // Fail-safe to prevent crash during logging
+    }
+    finally {
+        isIntercepting = false;
+    }
+};
+// ─── Public API ───────────────────────────────────────────────────────────────
+const subscribeConsoleLogs = (callback) => {
+    listeners.push(callback);
+    callback([...logs]);
+    return () => {
+        listeners = listeners.filter(l => l !== callback);
+    };
+};
+exports.subscribeConsoleLogs = subscribeConsoleLogs;
+const clearConsoleLogs = () => {
+    logs = [];
+    notify();
+};
+exports.clearConsoleLogs = clearConsoleLogs;
+const getConsoleLogs = () => [...logs];
+exports.getConsoleLogs = getConsoleLogs;
+const setupConsoleLogger = () => {
+    if (global.__CONSOLE_LOGGER_INITIALIZED__)
+        return;
+    const originalConsole = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+    };
+    // Intercept console.log
+    console.log = (...args) => {
+        addLog('info', args, 'log');
+        originalConsole.log(...args);
+    };
+    // Intercept console.info
+    console.info = (...args) => {
+        addLog('info', args, 'info');
+        originalConsole.info(...args);
+    };
+    // Intercept console.warn
+    console.warn = (...args) => {
+        addLog('warn', args, 'warn');
+        originalConsole.warn(...args);
+    };
+    // Intercept console.error
+    console.error = (...args) => {
+        addLog('error', args, 'error');
+        originalConsole.error(...args);
+    };
+    global.__CONSOLE_LOGGER_INITIALIZED__ = true;
+};
+exports.setupConsoleLogger = setupConsoleLogger;

package/dist/commonjs/customHooks/logFilters.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for console logs to ignore.
+ * Logs matching any of these starting prefixes will be filtered out.
+ */
+export declare const IGNORED_LOG_PREFIXES: Record<'info' | 'warn' | 'error', string[]>;

package/dist/commonjs/customHooks/logFilters.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORED_LOG_PREFIXES = void 0;
+/**
+ * Configuration for console logs to ignore.
+ * Logs matching any of these starting prefixes will be filtered out.
+ */
+exports.IGNORED_LOG_PREFIXES = {
+    info: [
+        // Add prefixes of info logs you want to ignore, e.g.:
+        // 'Starting server',
+        'VirtualizedList: You have a large list that is slow to update',
+    ],
+    warn: [
+        // Add prefixes of warning logs you want to ignore, e.g.:
+        // 'Require cycle:',
+        // 'ViewPropTypes will be removed',
+        'This method is deprecated (as well as all React Native Firebase namespaced API) and will be removed in the next major release as part of move to match Firebase Web modular SDK API.',
+        'SerializableStateInvariantMiddleware took',
+        'Non-serializable values were found in the navigation state.',
+        'SafeAreaView has been deprecated and will be removed in a future release.',
+        'Clipboard has been extracted from react-native core and will be removed in a future release.',
+        'You should always pass contentWidth prop to properly handle screen rotations and have a seamless support for images scaling.',
+        'Selector unknown returned a different result when called with the same parameters.',
+        'You seem to update props of the "TRenderEngineProvider" component in short periods of time',
+        'A non-serializable value was detected in an action',
+    ],
+    error: [
+        // Add prefixes of error logs you want to ignore, e.g.:
+        // 'Warning: Each child in a list should have a unique',
+        'A non-serializable value was detected in the state, in the path: `tierStatusCalculator.date`',
+        'VirtualizedLists should never be nested inside plain ScrollViews with the same orientation because it can break windowing and other functionality - use another VirtualizedList-backed container instead.',
+    ],
+};

package/dist/commonjs/customHooks/networkLogger.d.ts

@@ -0,0 +1,20 @@
+import './webViewLogger';
+type NetworkLog = {
+    id: number;
+    url: string;
+    method: string;
+    status?: number;
+    request?: any;
+    response?: any;
+    duration?: number;
+    startTime: number;
+    caller?: string;
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+};
+export declare const subscribeNetworkLogs: (callback: (logs: NetworkLog[]) => void) => () => void;
+export declare const clearNetworkLogs: () => void;
+export declare const getNetworkLogs: () => NetworkLog[];
+export declare const setupNetworkLogger: () => void;
+export declare const addAxiosInterceptors: (axiosInstance: any) => void;
+export {};

package/dist/commonjs/customHooks/networkLogger.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAxiosInterceptors = exports.setupNetworkLogger = exports.getNetworkLogs = exports.clearNetworkLogs = exports.subscribeNetworkLogs = void 0;
+require("./webViewLogger");
+let logs = [];
+let listeners = [];
+let counter = 0;
+const ALLOWED_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function normaliseHeaders(raw) {
+    if (!raw)
+        return undefined;
+    if (typeof raw.forEach === 'function') {
+        const result = {};
+        raw.forEach((value, key) => {
+            result[key] = value;
+        });
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    if (Array.isArray(raw)) {
+        const result = {};
+        raw.forEach(([key, value]) => {
+            result[key] = value;
+        });
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    const obj = raw;
+    const result = {};
+    Object.entries(obj).forEach(([key, value]) => {
+        if (value != null) {
+            result[key] = String(value);
+        }
+    });
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+// ✅ Parse FormData for File Upload previews
+function parseRequestData(data) {
+    if (!data)
+        return data;
+    if (data && data._parts && Array.isArray(data._parts)) {
+        const parsedFormData = {};
+        data._parts.forEach((part) => {
+            const key = part[0];
+            const value = part[1];
+            if (value && typeof value === 'object' && value.uri) {
+                parsedFormData[key] = {
+                    _isFile: true,
+                    name: value.name || 'unknown',
+                    type: value.type || 'unknown',
+                    uri: value.uri,
+                };
+            }
+            else {
+                parsedFormData[key] = value;
+            }
+        });
+        return { _isFormData: true, ...parsedFormData };
+    }
+    return data;
+}
+// ✅ Magic function to extract file and line number from the call stack
+function getCallerFromStack() {
+    try {
+        const stack = new Error().stack;
+        if (!stack)
+            return 'Unknown';
+        const lines = stack.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip internal react-native network modules and the logger itself
+            if (line.includes('networkLogger') ||
+                line.includes('node_modules') ||
+                line.includes('Error') ||
+                line.includes('regeneratorRuntime')) {
+                continue;
+            }
+            return line.trim().replace(/^at /, '');
+        }
+    }
+    catch (e) { }
+    return 'Unknown';
+}
+// ─── Subscribe ────────────────────────────────────────────────────────────────
+const subscribeNetworkLogs = (callback) => {
+    listeners.push(callback);
+    callback([...logs]);
+    return () => {
+        listeners = listeners.filter(l => l !== callback);
+    };
+};
+exports.subscribeNetworkLogs = subscribeNetworkLogs;
+const clearNetworkLogs = () => {
+    logs = [];
+    notify();
+};
+exports.clearNetworkLogs = clearNetworkLogs;
+const getNetworkLogs = () => [...logs];
+exports.getNetworkLogs = getNetworkLogs;
+// ─── Internal ─────────────────────────────────────────────────────────────────
+const notify = () => {
+    const snapshot = [...logs];
+    listeners.forEach(cb => cb(snapshot));
+};
+const addOrUpdateLog = (log) => {
+    const method = log.method?.toUpperCase();
+    if (!ALLOWED_METHODS.includes(method))
+        return;
+    const index = logs.findIndex(l => l.id === log.id);
+    if (index >= 0) {
+        logs[index] = { ...logs[index], ...log };
+    }
+    else {
+        logs.unshift(log);
+    }
+    logs = logs.slice(0, 100);
+    notify();
+};
+// ─── Setup ────────────────────────────────────────────────────────────────────
+const setupNetworkLogger = () => {
+    if (global.__NETWORK_LOGGER_INITIALIZED__)
+        return;
+    global.__NETWORK_LOGGER__ = addOrUpdateLog;
+    const originalFetch = global.fetch;
+    if (originalFetch) {
+        global.fetch = async (url, options = {}) => {
+            const method = (options?.method || 'GET').toUpperCase();
+            if (!ALLOWED_METHODS.includes(method))
+                return originalFetch(url, options);
+            const id = counter++;
+            const start = Date.now();
+            const finalUrl = typeof url === 'string' ? url : url?.url;
+            const requestHeaders = normaliseHeaders(options?.headers);
+            const caller = getCallerFromStack(); // ✅ Capture call line
+            addOrUpdateLog({
+                id,
+                url: finalUrl,
+                method,
+                startTime: start,
+                caller,
+                request: method === 'GET' ? undefined : parseRequestData(options?.body),
+                requestHeaders,
+            });
+            try {
+                const response = await originalFetch(url, options);
+                const duration = Date.now() - start;
+                const responseHeaders = normaliseHeaders(response.headers);
+                let data = null;
+                const contentType = responseHeaders?.['content-type'] ||
+                    responseHeaders?.['Content-Type'] ||
+                    '';
+                if (contentType.includes('image/')) {
+                    data = '[Image Data]';
+                }
+                else {
+                    try {
+                        const clone = response.clone();
+                        const text = await clone.text();
+                        try {
+                            data = JSON.parse(text);
+                        }
+                        catch {
+                            data = text;
+                        }
+                    }
+                    catch { }
+                }
+                addOrUpdateLog({
+                    id,
+                    url: finalUrl,
+                    method,
+                    status: response.status,
+                    response: data,
+                    duration,
+                    startTime: start,
+                    caller,
+                    responseHeaders,
+                });
+                return response;
+            }
+            catch (error) {
+                addOrUpdateLog({
+                    id,
+                    url: finalUrl,
+                    method,
+                    status: 0,
+                    startTime: start,
+                    response: error,
+                    caller,
+                    duration: Date.now() - start,
+                });
+                throw error;
+            }
+        };
+    }
+    global.__NETWORK_LOGGER_INITIALIZED__ = true;
+};
+exports.setupNetworkLogger = setupNetworkLogger;
+// ─── Axios interceptor helper ─────────────────────────────────────────────────
+const addAxiosInterceptors = (axiosInstance) => {
+    axiosInstance.interceptors.request.use(async (config) => {
+        const method = (config.method || 'GET').toUpperCase();
+        if (!ALLOWED_METHODS.includes(method))
+            return config;
+        const id = counter++;
+        const start = Date.now();
+        const caller = getCallerFromStack(); // ✅ Capture call line
+        config.__logId = id;
+        config.__logStart = start;
+        config.__logCaller = caller;
+        let url = config.url ?? '';
+        if (!url.startsWith('http'))
+            url = `${config.baseURL ?? ''}${url}`;
+        addOrUpdateLog({
+            id,
+            url,
+            method,
+            startTime: start,
+            caller,
+            request: method === 'GET' ? undefined : parseRequestData(config.data),
+            requestHeaders: normaliseHeaders(config.headers),
+        });
+        return config;
+    });
+    axiosInstance.interceptors.response.use((response) => {
+        const config = response.config || {};
+        const id = config.__logId;
+        const start = config.__logStart;
+        const caller = config.__logCaller;
+        const method = (config.method || 'GET').toUpperCase();
+        if (id == null || !ALLOWED_METHODS.includes(method))
+            return response;
+        let url = config.url ?? '';
+        if (!url.startsWith('http'))
+            url = `${config.baseURL ?? ''}${url}`;
+        addOrUpdateLog({
+            id,
+            url,
+            method,
+            status: response.status,
+            response: response.data,
+            startTime: start || Date.now(),
+            duration: start != null ? Date.now() - start : undefined,
+            caller,
+            responseHeaders: normaliseHeaders(response.headers),
+        });
+        return response;
+    }, (error) => {
+        const config = error.config || {};
+        const id = config.__logId;
+        const start = config.__logStart;
+        const caller = config.__logCaller;
+        const method = (config.method || 'GET').toUpperCase();
+        if (id != null && ALLOWED_METHODS.includes(method)) {
+            let url = config.url ?? '';
+            if (!url.startsWith('http'))
+                url = `${config.baseURL ?? ''}${url}`;
+            addOrUpdateLog({
+                id,
+                url,
+                method,
+                status: error.response?.status ?? 0,
+                response: error.response?.data ?? error.message,
+                startTime: start || Date.now(),
+                duration: start != null ? Date.now() - start : undefined,
+                caller,
+                responseHeaders: normaliseHeaders(error.response?.headers),
+            });
+        }
+        return Promise.reject(error);
+    });
+};
+exports.addAxiosInterceptors = addAxiosInterceptors;

package/dist/commonjs/customHooks/useAccordion.d.ts

@@ -0,0 +1,17 @@
+import { Animated } from 'react-native';
+declare const useAccordion: (initialOpen?: boolean, maxBodyHeight?: number, duration?: number) => {
+    isOpen: boolean;
+    toggleOpen: () => void;
+    forceOpen: (open: boolean) => void;
+    chevronStyle: {
+        transform: {
+            rotate: Animated.AnimatedInterpolation<string | number>;
+        }[];
+    };
+    bodyStyle: {
+        maxHeight: Animated.AnimatedInterpolation<string | number>;
+        overflow: "hidden";
+        opacity: Animated.AnimatedInterpolation<string | number>;
+    };
+};
+export default useAccordion;

package/dist/commonjs/customHooks/useAccordion.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const useAccordion = (initialOpen = false, maxBodyHeight = 1200, duration = 280) => {
+    const [isOpen, setIsOpen] = (0, react_1.useState)(initialOpen);
+    const animVal = (0, react_1.useRef)(new react_native_1.Animated.Value(initialOpen ? 1 : 0)).current;
+    const toggleOpen = (0, react_1.useCallback)(() => {
+        const next = !isOpen;
+        setIsOpen(next);
+        react_native_1.Animated.timing(animVal, {
+            toValue: next ? 1 : 0,
+            duration,
+            useNativeDriver: false,
+        }).start();
+    }, [isOpen, animVal, duration]);
+    const forceOpen = (0, react_1.useCallback)((open) => {
+        setIsOpen(open);
+        react_native_1.Animated.timing(animVal, {
+            toValue: open ? 1 : 0,
+            duration,
+            useNativeDriver: false,
+        }).start();
+    }, [animVal, duration]);
+    const chevronStyle = {
+        transform: [
+            {
+                rotate: animVal.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: ['0deg', '180deg'],
+                }),
+            },
+        ],
+    };
+    const bodyStyle = {
+        maxHeight: animVal.interpolate({
+            inputRange: [0, 1],
+            outputRange: [0, maxBodyHeight],
+        }),
+        overflow: 'hidden',
+        opacity: animVal.interpolate({
+            inputRange: [0, 0.4, 1],
+            outputRange: [0, 0.7, 1],
+        }),
+    };
+    return { isOpen, toggleOpen, forceOpen, chevronStyle, bodyStyle };
+};
+exports.default = useAccordion;

package/dist/commonjs/customHooks/webViewLogger.d.ts

@@ -0,0 +1,22 @@
+export interface WebViewLog {
+    id: number;
+    type: 'log' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+}
+export interface WebViewNavState {
+    url: string;
+    title?: string;
+    timestamp: number;
+}
+export declare const addWebViewLog: (type: "log" | "info" | "warn" | "error", message: string) => void;
+export declare const addWebViewNav: (url: string, title?: string) => void;
+export declare const addWebViewHtml: (url: string, html: string, css?: string, js?: string) => void;
+export declare const getWebViewLogs: () => WebViewLog[];
+export declare const getWebViewNavHistory: () => WebViewNavState[];
+export declare const getWebViewHtml: () => string;
+export declare const getWebViewCss: () => string;
+export declare const getWebViewJs: () => string;
+export declare const getWebViewHtmlUrl: () => string;
+export declare const clearWebViewData: () => void;
+export declare const subscribeWebView: (cb: () => void) => () => void;