react-native-inapp-inspector 1.1.35 → 2.0.0

package/dist/esm/native/NativeInspector.js

@@ -0,0 +1,289 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+import NativeNetworkInspector from './NativeNetworkInspector';
+// Seamless TurboModule (New Architecture / JSI) & Legacy NativeModules Bridge resolution
+const NativeModule = NativeNetworkInspector || NativeModules.NetworkInspectorModule;
+export const isNativeModuleAvailable = () => {
+    return !!NativeModule;
+};
+const nativeEmitter = isNativeModuleAvailable()
+    ? new NativeEventEmitter(NativeModule)
+    : null;
+/**
+ * Retrieves low-level native hardware and system metrics (RAM, Heap, Disk, Battery, CPU).
+ */
+export const getNativeDeviceMetrics = async () => {
+    if (!NativeModule || !NativeModule.getDeviceMetrics) {
+        return null;
+    }
+    try {
+        const metrics = await NativeModule.getDeviceMetrics();
+        return metrics;
+    }
+    catch (error) {
+        return null;
+    }
+};
+/**
+ * Enables native signal and uncaught exception protection in the iOS / Android runtime.
+ * Automatically ensures the native floating icon is shown and available before UI renders.
+ */
+export const enableNativeCrashProtection = async (options) => {
+    if (!NativeModule || !NativeModule.enableNativeCrashProtection) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.enableNativeCrashProtection();
+        if (options?.showFloatingButton !== false) {
+            await showNativeFloatingButton();
+        }
+        return !!result;
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Subscribes to fatal native crash events caught by the iOS / Kotlin exception handlers.
+ */
+export const subscribeNativeCrashes = (callback) => {
+    if (!nativeEmitter) {
+        return () => { };
+    }
+    try {
+        const subscription = nativeEmitter.addListener('onNativeCrash', callback);
+        return () => {
+            subscription.remove();
+        };
+    }
+    catch (e) {
+        return () => { };
+    }
+};
+/**
+ * Displays the 100% native main-thread floating overlay button.
+ * Dragging & touches run on the native UI thread, completely isolated from JS thread stalls.
+ */
+export const showNativeFloatingButton = async (options) => {
+    if (!NativeModule || !NativeModule.showFloatingButton) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.showFloatingButton(options || {});
+        return !!result;
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Hides the native floating overlay button.
+ */
+export const hideNativeFloatingButton = async () => {
+    if (!NativeModule || !NativeModule.hideFloatingButton) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.hideFloatingButton();
+        return !!result;
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Updates the badge/status dot on the native floating overlay button.
+ */
+export const setNativeFloatingButtonBadge = async (hasBadge) => {
+    if (!NativeModule || !NativeModule.setFloatingButtonBadge) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.setFloatingButtonBadge(hasBadge);
+        return !!result;
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Subscribes to tap events on the native floating button.
+ */
+export const subscribeNativeFloatingButtonPress = (callback) => {
+    if (!nativeEmitter) {
+        return () => { };
+    }
+    try {
+        const subscription = nativeEmitter.addListener('onFloatingButtonPress', callback);
+        return () => {
+            subscription.remove();
+        };
+    }
+    catch (e) {
+        return () => { };
+    }
+};
+/**
+ * Starts hardware-accurate native UI thread FPS tracking (CADisplayLink / Choreographer).
+ */
+export const startNativeFpsMonitoring = async () => {
+    if (!NativeModule || !NativeModule.startFpsMonitoring) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.startFpsMonitoring();
+        return !!result;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Stops native FPS tracking.
+ */
+export const stopNativeFpsMonitoring = async () => {
+    if (!NativeModule || !NativeModule.stopFpsMonitoring) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.stopFpsMonitoring();
+        return !!result;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Reads the latest live hardware FPS from CADisplayLink (iOS) or Choreographer (Android).
+ */
+export const getNativeFpsMetrics = async () => {
+    if (!NativeModule || !NativeModule.getFpsMetrics) {
+        return { fps: 60, targetFps: 60 };
+    }
+    try {
+        const metrics = await NativeModule.getFpsMetrics();
+        return {
+            fps: typeof metrics?.fps === 'number' ? metrics.fps : 60,
+            targetFps: typeof metrics?.targetFps === 'number' ? metrics.targetFps : 60,
+        };
+    }
+    catch {
+        return { fps: 60, targetFps: 60 };
+    }
+};
+/**
+ * Subscribes to physical hardware shake events (or Cmd+Ctrl+Z on iOS simulator).
+ */
+export const subscribeNativeDeviceShake = (callback) => {
+    if (!nativeEmitter) {
+        return () => { };
+    }
+    try {
+        const subscription = nativeEmitter.addListener('onDeviceShake', callback);
+        return () => {
+            subscription.remove();
+        };
+    }
+    catch {
+        return () => { };
+    }
+};
+/**
+ * Reads a persisted value synchronously from native NSUserDefaults / SharedPreferences.
+ */
+export const getNativeStorageItem = async (key) => {
+    if (!NativeModule || !NativeModule.getNativeStorageItem) {
+        return null;
+    }
+    try {
+        const val = await NativeModule.getNativeStorageItem(key);
+        return typeof val === 'string' ? val : null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Persists a key-value pair to native NSUserDefaults / SharedPreferences with 0ms latency.
+ */
+export const setNativeStorageItem = async (key, value) => {
+    if (!NativeModule || !NativeModule.setNativeStorageItem) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.setNativeStorageItem(key, value);
+        return !!result;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Triggers hardware native haptic feedback (iOS UIFeedbackGenerator / Android VibrationEffect).
+ */
+export const triggerNativeHaptic = async (style = 'light') => {
+    if (!NativeModule || !NativeModule.triggerHaptic) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.triggerHaptic(style);
+        return !!result;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Retrieves live system thermal state and RAM telemetry directly from native layer.
+ */
+export const getNativeSystemMetrics = async () => {
+    if (!NativeModule || !NativeModule.getNativeSystemMetrics) {
+        return null;
+    }
+    try {
+        const metrics = await NativeModule.getNativeSystemMetrics();
+        return metrics;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Pushes a log payload to native background worker queues for instant native page caching.
+ */
+export const pushNativeLogRecord = async (pageKey, jsonPayload) => {
+    if (!NativeModule || !NativeModule.pushNativeLogRecord) {
+        return false;
+    }
+    try {
+        const result = await NativeModule.pushNativeLogRecord(pageKey, jsonPayload);
+        return !!result;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Fetches pre-indexed, pre-sliced page data directly from native background memory queues.
+ * Delivers instantaneous 0ms page loading without blocking JS render thread.
+ */
+export const fetchNativeCachedPage = async (pageKey, offset = 0, limit = 50, query = '') => {
+    if (!NativeModule || !NativeModule.getNativeCachedPage) {
+        return null;
+    }
+    try {
+        const rawJson = await NativeModule.getNativeCachedPage(pageKey, offset, limit, query);
+        if (!rawJson)
+            return null;
+        const parsed = JSON.parse(rawJson);
+        const parsedItems = (parsed.items || []).map((item) => typeof item === 'string' ? JSON.parse(item) : item);
+        return {
+            pageKey: parsed.pageKey || pageKey,
+            total: parsed.total || 0,
+            offset: parsed.offset || offset,
+            items: parsedItems,
+        };
+    }
+    catch {
+        return null;
+    }
+};

package/dist/esm/native/NativeNetworkInspector.d.ts

@@ -0,0 +1,22 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    enableNativeCrashProtection(): Promise<boolean>;
+    getDeviceMetrics(): Promise<Object>;
+    showFloatingButton(options: Object): Promise<boolean>;
+    hideFloatingButton(): Promise<boolean>;
+    setFloatingButtonBadge(hasBadge: boolean): Promise<boolean>;
+    setFloatingButtonPosition(x: number, y: number): Promise<boolean>;
+    startFpsMonitoring(): Promise<boolean>;
+    stopFpsMonitoring(): Promise<boolean>;
+    getFpsMetrics(): Promise<Object>;
+    getNativeStorageItem(key: string): Promise<string | null>;
+    setNativeStorageItem(key: string, value: string | null): Promise<boolean>;
+    triggerHaptic(style: string): Promise<boolean>;
+    getNativeSystemMetrics(): Promise<Object>;
+    pushNativeLogRecord(pageKey: string, jsonPayload: string): Promise<boolean>;
+    getNativeCachedPage(pageKey: string, offset: number, limit: number, query: string): Promise<string>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec;
+export default _default;

package/dist/esm/native/NativeNetworkInspector.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('NetworkInspectorModule');

package/dist/esm/styles/index.js

@@ -140,8 +140,8 @@ export const getRawStyles = (colors) => ({
     // #2 — scroll-to-top button, always shown at the bottom right.
     scrollTopBtn: {
         position: 'absolute',
-        bottom: 25,
-        right: 15,
+        bottom: 22,
+        right: 16,
         width: 38,
         height: 38,
         borderRadius: 19,
@@ -150,10 +150,10 @@ export const getRawStyles = (colors) => ({
         justifyContent: 'center',
         shadowColor: colors.black,
         shadowOffset: { width: 0, height: 3 },
-        shadowOpacity: 0.25,
-        shadowRadius: 5,
-        elevation: 6,
-        zIndex: 50,
+        shadowOpacity: 0.3,
+        shadowRadius: 6,
+        elevation: 12,
+        zIndex: 999,
     },
     detailScroll: { flex: 1 },
     closeButtonSquare: {

package/dist/esm/types/enums.d.ts

@@ -25,7 +25,7 @@ export declare const StatusFilter: {
     readonly FiveXx: "5xx";
     readonly Failed: "Failed";
 };
-export type StatusFilter = (typeof StatusFilter)[keyof typeof StatusFilter];
+export type StatusFilter = (typeof StatusFilter)[keyof typeof StatusFilter] | string;
 export declare const SortOrder: {
     readonly Newest: "newest";
     readonly Oldest: "oldest";

package/dist/esm/types/interfaces.d.ts

@@ -140,6 +140,9 @@ export interface PersistedSettings {
     defaultTab?: string;
     maxNetworkLogs?: number;
     maxConsoleLogs?: number;
+    maxAnalyticsEventsLimit?: number;
+    maxCrashLogs?: number;
+    isAutoRamLimitEnabled?: boolean;
     showConsoleLevels?: {
         info: boolean;
         warn: boolean;
@@ -197,6 +200,7 @@ export interface InspectorContextValue {
     activePulseAnim: Animated.Value;
     unreadPulseAnim: Animated.Value;
     runClearAllWithAnimation: () => void;
+    useNativeFab: boolean;
     fabPan: Animated.ValueXY;
     fabPanResponder: PanResponderInstance;
     fabDraggedRef: React.MutableRefObject<boolean>;
@@ -313,6 +317,11 @@ export interface InspectorContextValue {
     setMaxNetworkLogs: React.Dispatch<React.SetStateAction<number>>;
     maxConsoleLogs: number;
     setMaxConsoleLogs: React.Dispatch<React.SetStateAction<number>>;
+    maxAnalyticsEventsLimit: number;
+    setMaxAnalyticsEventsLimit: React.Dispatch<React.SetStateAction<number>>;
+    isAutoRamLimitEnabled: boolean;
+    setIsAutoRamLimitEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    deviceFreeRamMb: number;
     reduxAutoRefresh: boolean;
     setReduxAutoRefreshState: React.Dispatch<React.SetStateAction<boolean>>;
     reduxExpandDepth: number;

package/ios/NetworkInspectorModule.h

@@ -1,8 +1,14 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNInAppInspectorSpec/RNInAppInspectorSpec.h>
+@interface NetworkInspectorModule : RCTEventEmitter <NativeNetworkInspectorSpec, RCTBridgeModule>
+#else
 @interface NetworkInspectorModule : RCTEventEmitter <RCTBridgeModule>
+#endif
 
 - (void)emitCrashEventWithMessage:(NSString *)message stackTrace:(NSString *)stackTrace;
 
 @end
+