react-native-inapp-inspector 1.1.35 → 2.0.1

package/dist/esm/customHooks/analyticsLogger.js

@@ -43,7 +43,7 @@ const addEvent = (event) => {
     if (!isAnalyticsModuleEnabled)
         return;
     events.unshift(event);
-    events = events.slice(0, 200);
+    events = events.slice(0, 75);
     notify();
 };
 // ─── Public subscribe / query API ────────────────────────────────────────────
@@ -94,10 +94,11 @@ export const logAnalyticsEvent = (name, params = {}, userProperties = {}) => {
  *   setupAnalyticsLogger(analytics());
  */
 let isAnalyticsPatched = false;
-export const isAnalyticsConnected = () => isAnalyticsPatched ||
-    events.length > 0 ||
-    Object.keys(currentUserProperties).length > 0 ||
-    currentUserId != null;
+/**
+ * Returns true if analytics logging is active (always ready for custom and Firebase events).
+ */
+export const isAnalyticsConnected = () => true;
+export const isFirebaseAnalyticsPatched = () => isAnalyticsPatched;
 export const setupAnalyticsLogger = (analyticsInstance) => {
     if (!analyticsInstance) {
         console.warn('[AnalyticsLogger] No analytics instance provided — skipping setup.');

package/dist/esm/customHooks/crashHandler.js

@@ -1,6 +1,7 @@
 import { LogBox, NativeModules, TurboModuleRegistry, NativeEventEmitter, Platform, AppState, Dimensions, } from 'react-native';
 import { CrashExportFormat, CrashType } from '../types/enums';
 import { addLogFromCrash } from './consoleLogger';
+import { showNativeFloatingButton, setNativeFloatingButtonBadge, } from '../native/NativeInspector';
 import { t } from '../i18n';
 export { CrashExportFormat };
 let crashListeners = [];
@@ -9,7 +10,7 @@ let lastHandledErrorTimestamp = 0;
 let crashRecordsStore = [];
 let breadcrumbsStore = [];
 const MAX_BREADCRUMBS = 50;
-let maxStoredCrashes = 100;
+let maxStoredCrashes = 50;
 const appStartTime = Date.now();
 let isCrashModuleEnabled = false;
 export const setCrashModuleEnabled = (enabled) => {
@@ -365,6 +366,12 @@ export const handleInterceptedCrash = (errorOrTitle, rawStack, isFatal = false,
             logId: log?.id,
             crashRecord,
         });
+        // Ensure native floating icon is visible & badged even if React UI is broken
+        try {
+            showNativeFloatingButton();
+            setNativeFloatingButtonBadge(true);
+        }
+        catch { }
         return crashRecord;
     }
     catch (err) {

package/dist/esm/helpers/index.d.ts

@@ -1,4 +1,5 @@
 import { NetworkLog, RouteInfo, DiffResult, JsonContent, StackFrameType } from '../types';
+export * from './searchQueryParser';
 export declare const getDomainColor: (domain: string) => string;
 export declare const formatDateTime: (timestamp: number) => string;
 export declare const formatTimestamp: (timestamp: number) => string;

package/dist/esm/helpers/index.js

@@ -5,6 +5,7 @@ import { showToast } from './toast';
 import { AppColors } from '../styles/AppColors';
 // Constants
 import { DOMAIN_COLORS, DURATION_FAST_MS, DURATION_SLOW_MS } from '../constants';
+export * from './searchQueryParser';
 export const getDomainColor = (domain) => {
     if (!domain)
         return DOMAIN_COLORS[0];
@@ -156,9 +157,18 @@ export const getFetchCommand = (log) => {
 export const deduplicateLogs = (raw) => {
     const map = new Map();
     raw.forEach(entry => {
-        if (!map.has(entry.id) || entry.status != null) {
+        if (!map.has(entry.id)) {
             map.set(entry.id, entry);
         }
+        else {
+            const existing = map.get(entry.id);
+            if (existing.status == null && entry.status != null) {
+                map.set(entry.id, entry);
+            }
+            else if ((entry.startTime ?? 0) >= (existing.startTime ?? 0)) {
+                map.set(entry.id, entry);
+            }
+        }
     });
     return Array.from(map.values()).sort((a, b) => b.id - a.id);
 };

package/dist/esm/helpers/searchQueryParser.d.ts

@@ -0,0 +1,6 @@
+import { NetworkLog } from '../types';
+/**
+ * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
+ * and checks whether a given NetworkLog matches all tokens.
+ */
+export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string): boolean;

package/dist/esm/helpers/searchQueryParser.js

@@ -0,0 +1,233 @@
+/**
+ * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
+ * and checks whether a given NetworkLog matches all tokens.
+ */
+export function matchNetworkLogQuery(log, searchQuery, routePath) {
+    if (!searchQuery || searchQuery.trim().length === 0)
+        return true;
+    const rawTokens = searchQuery
+        .trim()
+        .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    if (rawTokens.length === 0)
+        return true;
+    const methodStr = (log.method || '').toLowerCase();
+    const urlStr = (log.url || '').toLowerCase();
+    const statusNum = typeof log.status === 'number' ? log.status : parseInt(String(log.status || 0), 10);
+    const statusStr = String(log.status ?? '');
+    const durationNum = log.duration || 0;
+    const clientStr = (log.client || '').toLowerCase();
+    const reqStr = typeof log.request === 'string' ? log.request : JSON.stringify(log.request || '');
+    const resStr = typeof log.response === 'string' ? log.response : JSON.stringify(log.response || '');
+    const reqHeadersStr = JSON.stringify(log.requestHeaders || '').toLowerCase();
+    const resHeadersStr = JSON.stringify(log.responseHeaders || '').toLowerCase();
+    const pathStr = routePath ? routePath.toLowerCase() : '';
+    const fullSearchCorpus = [
+        methodStr,
+        urlStr,
+        statusStr,
+        pathStr,
+        clientStr,
+        reqStr.toLowerCase(),
+        resStr.toLowerCase(),
+        reqHeadersStr,
+        resHeadersStr,
+    ].join(' ');
+    for (const rawToken of rawTokens) {
+        const token = rawToken.replace(/^["']|["']$/g, '').trim();
+        if (!token)
+            continue;
+        const lowerToken = token.toLowerCase();
+        // 1. method:<VAL> or m:<VAL>
+        if (lowerToken.startsWith('method:') || lowerToken.startsWith('m:')) {
+            const targetMethod = lowerToken.replace(/^(method:|m:)/, '').trim();
+            if (targetMethod.startsWith('!')) {
+                if (methodStr === targetMethod.slice(1))
+                    return false;
+            }
+            else {
+                if (methodStr !== targetMethod)
+                    return false;
+            }
+            continue;
+        }
+        // 2. status:<VAL> or s:<VAL>
+        if (lowerToken.startsWith('status:') || lowerToken.startsWith('s:')) {
+            const val = lowerToken.replace(/^(status:|s:)/, '').trim();
+            if (val.startsWith('>=')) {
+                const threshold = parseInt(val.slice(2), 10);
+                if (isNaN(threshold) || statusNum < threshold)
+                    return false;
+            }
+            else if (val.startsWith('>')) {
+                const threshold = parseInt(val.slice(1), 10);
+                if (isNaN(threshold) || statusNum <= threshold)
+                    return false;
+            }
+            else if (val.startsWith('<=')) {
+                const threshold = parseInt(val.slice(2), 10);
+                if (isNaN(threshold) || statusNum > threshold)
+                    return false;
+            }
+            else if (val.startsWith('<')) {
+                const threshold = parseInt(val.slice(1), 10);
+                if (isNaN(threshold) || statusNum >= threshold)
+                    return false;
+            }
+            else if (val.endsWith('xx') || val.endsWith('x')) {
+                const prefix = val.replace(/x/g, '');
+                if (!statusStr.startsWith(prefix))
+                    return false;
+            }
+            else {
+                const targetCode = parseInt(val, 10);
+                if (!isNaN(targetCode)) {
+                    if (statusNum !== targetCode)
+                        return false;
+                }
+                else if (!statusStr.includes(val)) {
+                    return false;
+                }
+            }
+            continue;
+        }
+        // 3. is:<FLAG>
+        if (lowerToken.startsWith('is:')) {
+            const flag = lowerToken.slice(3).trim();
+            if (flag === 'error' || flag === 'failed' || flag === 'err' || flag === 'fail') {
+                const isErr = log.status === 0 || log.status == null || statusNum >= 400;
+                if (!isErr)
+                    return false;
+            }
+            else if (flag === 'success' || flag === 'ok' || flag === '2xx') {
+                const isSuccess = statusNum >= 200 && statusNum < 300;
+                if (!isSuccess)
+                    return false;
+            }
+            else if (flag === 'slow') {
+                if (durationNum < 1000)
+                    return false;
+            }
+            else if (flag === 'fast') {
+                if (durationNum >= 200)
+                    return false;
+            }
+            else if (flag === 'graphql' || flag === 'gql') {
+                const isGql = urlStr.includes('graphql') ||
+                    clientStr === 'graphql' ||
+                    clientStr === 'apollo';
+                if (!isGql)
+                    return false;
+            }
+            else if (flag === 'https') {
+                if (!urlStr.startsWith('https'))
+                    return false;
+            }
+            else if (flag === 'http') {
+                if (urlStr.startsWith('https') || !urlStr.startsWith('http'))
+                    return false;
+            }
+            else if (flag === 'json') {
+                const isJson = reqHeadersStr.includes('application/json') ||
+                    resHeadersStr.includes('application/json') ||
+                    urlStr.includes('.json');
+                if (!isJson)
+                    return false;
+            }
+            continue;
+        }
+        // 4. slow:<DURATION> or dur:<DURATION> or duration:<DURATION>
+        if (lowerToken.startsWith('slow:') ||
+            lowerToken.startsWith('dur:') ||
+            lowerToken.startsWith('duration:')) {
+            const val = lowerToken.replace(/^(slow:|dur:|duration:)/, '').trim();
+            let thresholdMs = 0;
+            let isGreater = true;
+            let cleanVal = val;
+            if (val.startsWith('>=')) {
+                isGreater = true;
+                cleanVal = val.slice(2);
+            }
+            else if (val.startsWith('>')) {
+                isGreater = true;
+                cleanVal = val.slice(1);
+            }
+            else if (val.startsWith('<=')) {
+                isGreater = false;
+                cleanVal = val.slice(2);
+            }
+            else if (val.startsWith('<')) {
+                isGreater = false;
+                cleanVal = val.slice(1);
+            }
+            if (cleanVal.endsWith('s') && !cleanVal.endsWith('ms')) {
+                thresholdMs = parseFloat(cleanVal.slice(0, -1)) * 1000;
+            }
+            else if (cleanVal.endsWith('ms')) {
+                thresholdMs = parseFloat(cleanVal.slice(0, -2));
+            }
+            else {
+                thresholdMs = parseFloat(cleanVal);
+            }
+            if (!isNaN(thresholdMs)) {
+                if (isGreater) {
+                    if (durationNum < thresholdMs)
+                        return false;
+                }
+                else {
+                    if (durationNum > thresholdMs)
+                        return false;
+                }
+            }
+            continue;
+        }
+        // 5. client:<CLIENT> or c:<CLIENT>
+        if (lowerToken.startsWith('client:') || lowerToken.startsWith('c:')) {
+            const targetClient = lowerToken.replace(/^(client:|c:)/, '').trim();
+            if (!clientStr.includes(targetClient))
+                return false;
+            continue;
+        }
+        // 6. domain:<DOMAIN> or d:<DOMAIN>
+        if (lowerToken.startsWith('domain:') || lowerToken.startsWith('d:')) {
+            const targetDomain = lowerToken.replace(/^(domain:|d:)/, '').trim();
+            if (!urlStr.includes(targetDomain))
+                return false;
+            continue;
+        }
+        // 7. path:<PATH> or p:<PATH>
+        if (lowerToken.startsWith('path:') || lowerToken.startsWith('p:')) {
+            const targetPath = lowerToken.replace(/^(path:|p:)/, '').trim();
+            if (!urlStr.includes(targetPath) && !pathStr.includes(targetPath)) {
+                return false;
+            }
+            continue;
+        }
+        // 8. req:<TERM> or body:<TERM>
+        if (lowerToken.startsWith('req:') || lowerToken.startsWith('body:')) {
+            const target = lowerToken.replace(/^(req:|body:)/, '').trim();
+            if (!reqStr.toLowerCase().includes(target))
+                return false;
+            continue;
+        }
+        // 9. res:<TERM>
+        if (lowerToken.startsWith('res:')) {
+            const target = lowerToken.slice(4).trim();
+            if (!resStr.toLowerCase().includes(target))
+                return false;
+            continue;
+        }
+        // 10. header:<TERM> or h:<TERM>
+        if (lowerToken.startsWith('header:') || lowerToken.startsWith('h:')) {
+            const target = lowerToken.replace(/^(header:|h:)/, '').trim();
+            if (!reqHeadersStr.includes(target) && !resHeadersStr.includes(target)) {
+                return false;
+            }
+            continue;
+        }
+        // 11. Generic Plain Substring Match
+        if (!fullSearchCorpus.includes(lowerToken)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/esm/helpers/settingsStore.d.ts

@@ -6,3 +6,12 @@ export declare function saveSettings(settings: PersistedSettings): void;
 export declare function clearPersistedSettings(): Promise<void>;
 export declare const isPersistentStorageAvailable: () => boolean;
 export declare function getCustomStorage(): InspectorStorage | null;
+export interface RamLimitsProfile {
+    maxNetworkLogs: number;
+    maxConsoleLogs: number;
+    maxAnalyticsEvents: number;
+    maxCrashRecords: number;
+    profileName: 'High-End' | 'Standard' | 'Compact' | 'Ultra-Light';
+    freeRamMb: number;
+}
+export declare function calculateRamBasedLimits(freeRamMb: number): RamLimitsProfile;

package/dist/esm/helpers/settingsStore.js

@@ -3,6 +3,7 @@
 // Backed by iOS Settings (NSUserDefaults) for iOS, or custom storage if passed (e.g. AsyncStorage/MMKV).
 // Contains an in-memory fallback for Android or Jest test environments.
 import { Platform, Settings } from 'react-native';
+import { getNativeStorageItem, setNativeStorageItem, isNativeModuleAvailable, } from '../native/NativeInspector';
 // In-memory fallback (settings survive for the app session only).
 const memory = new Map();
 let customStorage = null;
@@ -19,6 +20,13 @@ export async function loadSettings() {
             const parsed = JSON.parse(raw);
             return parsed && typeof parsed === 'object' ? parsed : {};
         }
+        if (isNativeModuleAvailable()) {
+            const raw = await getNativeStorageItem(SETTINGS_KEY);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                return parsed && typeof parsed === 'object' ? parsed : {};
+            }
+        }
         if (Platform.OS === 'ios') {
             const raw = Settings.get(SETTINGS_KEY);
             if (!raw)
@@ -29,7 +37,7 @@ export async function loadSettings() {
             }
             return raw && typeof raw === 'object' ? raw : {};
         }
-        // Android/fallback: memory
+        // In-memory fallback
         const raw = memory.get(SETTINGS_KEY);
         if (!raw)
             return {};
@@ -47,11 +55,13 @@ export function saveSettings(settings) {
             customStorage.setItem(SETTINGS_KEY, raw);
             return;
         }
+        if (isNativeModuleAvailable()) {
+            setNativeStorageItem(SETTINGS_KEY, raw);
+        }
         if (Platform.OS === 'ios') {
             Settings.set({ [SETTINGS_KEY]: raw });
             return;
         }
-        // Android/fallback: memory
         memory.set(SETTINGS_KEY, raw);
     }
     catch {
@@ -69,6 +79,9 @@ export async function clearPersistedSettings() {
             }
             return;
         }
+        if (isNativeModuleAvailable()) {
+            await setNativeStorageItem(SETTINGS_KEY, null);
+        }
         if (Platform.OS === 'ios') {
             Settings.set({ [SETTINGS_KEY]: null });
             return;
@@ -80,8 +93,50 @@ export async function clearPersistedSettings() {
     }
 }
 export const isPersistentStorageAvailable = () => {
-    return customStorage !== null || Platform.OS === 'ios';
+    return customStorage !== null || isNativeModuleAvailable() || Platform.OS === 'ios';
 };
 export function getCustomStorage() {
     return customStorage;
 }
+export function calculateRamBasedLimits(freeRamMb) {
+    if (freeRamMb >= 3000) {
+        return {
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 75,
+            maxCrashRecords: 50,
+            profileName: 'High-End',
+            freeRamMb,
+        };
+    }
+    else if (freeRamMb >= 1500) {
+        return {
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 75,
+            maxCrashRecords: 50,
+            profileName: 'Standard',
+            freeRamMb,
+        };
+    }
+    else if (freeRamMb >= 600) {
+        return {
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 50,
+            maxCrashRecords: 25,
+            profileName: 'Compact',
+            freeRamMb,
+        };
+    }
+    else {
+        return {
+            maxNetworkLogs: 50,
+            maxConsoleLogs: 50,
+            maxAnalyticsEvents: 25,
+            maxCrashRecords: 15,
+            profileName: 'Ultra-Light',
+            freeRamMb,
+        };
+    }
+}

package/dist/esm/index.d.ts

@@ -12,4 +12,5 @@ export { connectReduxStore, inspectorReduxMiddleware, getReduxState, subscribeRe
 export { getEventCategory, registerGAPlugin, type GAPlugin, } from './helpers/gaAnalyticsRegistry';
 export { usePerformanceTracker, useComponentProfiler, useNavigationProfiler, trackComponentRender, trackNavigationTransition, trackHeavyTask, measureAsync, getHermesMemoryStats, registerComponentProfile, subscribeRenderProfiles, getRenderProfiles, logPerformanceEvent, clearPerformanceEvents, subscribePerformanceEvents, getPerformanceEvents, getInitialRenderProfiles, getInitialPerformanceEvents, generateFixSnippet, } from './customHooks/performanceTracker';
 export { InspectLog, InspectTrackTime, InspectCatch, type InspectLogOptions, } from './decorators';
+export { getNativeDeviceMetrics, enableNativeCrashProtection, subscribeNativeCrashes, showNativeFloatingButton, hideNativeFloatingButton, setNativeFloatingButtonBadge, subscribeNativeFloatingButtonPress, subscribeNativeDeviceShake, startNativeFpsMonitoring, stopNativeFpsMonitoring, getNativeFpsMetrics, getNativeStorageItem, setNativeStorageItem, isNativeModuleAvailable, type NativeDeviceMetrics, type NativeCrashEvent, type FloatingButtonOptions, type NativeFpsMetrics, } from './native/NativeInspector';
 export { ActiveTab, Method, StatusFilter, SortOrder, LocalFilter, ModalAnimationType, SettingsPage, SettingsSubTab, LogFilter, ConsoleLogType, AnalyticsEventSource, GAEventCategory, StackFrameType, DiffResultType, BundleSubTab, PerformanceSubTab, CrashType, CrashExportFormat, CrashDetailSubTab, CrashFilterType, BreadcrumbType, } from './types';