react-native-inapp-inspector 1.1.34 → 2.0.0

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

@@ -0,0 +1,125 @@
+export interface NativeDeviceMetrics {
+    totalRAM?: number;
+    freeRAM?: number;
+    usedRAM?: number;
+    residentMemory?: number;
+    virtualMemory?: number;
+    isLowMemory?: boolean;
+    nativeHeapAllocated?: number;
+    nativeHeapSize?: number;
+    nativeHeapFree?: number;
+    freeStorage?: number;
+    totalStorage?: number;
+    batteryPercent?: number;
+    isCharging?: boolean;
+    deviceModel?: string;
+    deviceBrand?: string;
+    osVersion?: string;
+    apiLevel?: number;
+    cpuAbi?: string;
+}
+export interface NativeCrashEvent {
+    platform: 'android' | 'ios';
+    error: string;
+    name?: string;
+    stack?: string;
+    threadName?: string;
+    timestamp: number;
+}
+export declare const isNativeModuleAvailable: () => boolean;
+/**
+ * Retrieves low-level native hardware and system metrics (RAM, Heap, Disk, Battery, CPU).
+ */
+export declare const getNativeDeviceMetrics: () => Promise<NativeDeviceMetrics | 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 declare const enableNativeCrashProtection: (options?: {
+    showFloatingButton?: boolean;
+}) => Promise<boolean>;
+/**
+ * Subscribes to fatal native crash events caught by the iOS / Kotlin exception handlers.
+ */
+export declare const subscribeNativeCrashes: (callback: (event: NativeCrashEvent) => void) => (() => void);
+export interface FloatingButtonOptions {
+    size?: number;
+    x?: number;
+    y?: number;
+}
+/**
+ * Displays the 100% native main-thread floating overlay button.
+ * Dragging & touches run on the native UI thread, completely isolated from JS thread stalls.
+ */
+export declare const showNativeFloatingButton: (options?: FloatingButtonOptions) => Promise<boolean>;
+/**
+ * Hides the native floating overlay button.
+ */
+export declare const hideNativeFloatingButton: () => Promise<boolean>;
+/**
+ * Updates the badge/status dot on the native floating overlay button.
+ */
+export declare const setNativeFloatingButtonBadge: (hasBadge: boolean) => Promise<boolean>;
+/**
+ * Subscribes to tap events on the native floating button.
+ */
+export declare const subscribeNativeFloatingButtonPress: (callback: () => void) => (() => void);
+/**
+ * Starts hardware-accurate native UI thread FPS tracking (CADisplayLink / Choreographer).
+ */
+export declare const startNativeFpsMonitoring: () => Promise<boolean>;
+/**
+ * Stops native FPS tracking.
+ */
+export declare const stopNativeFpsMonitoring: () => Promise<boolean>;
+export interface NativeFpsMetrics {
+    fps: number;
+    targetFps: number;
+}
+/**
+ * Reads the latest live hardware FPS from CADisplayLink (iOS) or Choreographer (Android).
+ */
+export declare const getNativeFpsMetrics: () => Promise<NativeFpsMetrics>;
+/**
+ * Subscribes to physical hardware shake events (or Cmd+Ctrl+Z on iOS simulator).
+ */
+export declare const subscribeNativeDeviceShake: (callback: () => void) => (() => void);
+/**
+ * Reads a persisted value synchronously from native NSUserDefaults / SharedPreferences.
+ */
+export declare const getNativeStorageItem: (key: string) => Promise<string | null>;
+/**
+ * Persists a key-value pair to native NSUserDefaults / SharedPreferences with 0ms latency.
+ */
+export declare const setNativeStorageItem: (key: string, value: string | null) => Promise<boolean>;
+export type HapticStyle = 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error';
+/**
+ * Triggers hardware native haptic feedback (iOS UIFeedbackGenerator / Android VibrationEffect).
+ */
+export declare const triggerNativeHaptic: (style?: HapticStyle) => Promise<boolean>;
+export interface NativeSystemMetrics {
+    thermalState: 'nominal' | 'fair' | 'serious' | 'critical';
+    residentRamMb: number;
+    totalPhysicalRamMb: number;
+    fps: number;
+    activeCpuCores: number;
+}
+/**
+ * Retrieves live system thermal state and RAM telemetry directly from native layer.
+ */
+export declare const getNativeSystemMetrics: () => Promise<NativeSystemMetrics | null>;
+/**
+ * Pushes a log payload to native background worker queues for instant native page caching.
+ */
+export declare const pushNativeLogRecord: (pageKey: "apis" | "logs" | "analytics" | "crash", jsonPayload: string) => Promise<boolean>;
+export interface NativeCachedPageResult<T = any> {
+    pageKey: string;
+    total: number;
+    offset: number;
+    items: T[];
+}
+/**
+ * Fetches pre-indexed, pre-sliced page data directly from native background memory queues.
+ * Delivers instantaneous 0ms page loading without blocking JS render thread.
+ */
+export declare const fetchNativeCachedPage: <T = any>(pageKey: "apis" | "logs" | "analytics" | "crash", offset?: number, limit?: number, query?: string) => Promise<NativeCachedPageResult<T> | null>;

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/AppColors.d.ts

@@ -154,6 +154,20 @@ declare const LightColors: {
     greyBorder: string;
     paperBg: string;
     contentBg: string;
+    toastBg: string;
+    toastBorder: string;
+    mintGreenBg: string;
+    mintGreenBorder: string;
+    mintGreenText: string;
+    amberWarmBg: string;
+    amberWarmBorder: string;
+    amberWarmText: string;
+    violetSoftBg: string;
+    violetSoftBorder: string;
+    violetSoftText: string;
+    skySoftBg: string;
+    skySoftBorder: string;
+    skySoftText: string;
     domainColors: string[];
 };
 export declare const getThemeColors: (isDark: boolean) => {
@@ -312,6 +326,20 @@ export declare const getThemeColors: (isDark: boolean) => {
     greyBorder: string;
     paperBg: string;
     contentBg: string;
+    toastBg: string;
+    toastBorder: string;
+    mintGreenBg: string;
+    mintGreenBorder: string;
+    mintGreenText: string;
+    amberWarmBg: string;
+    amberWarmBorder: string;
+    amberWarmText: string;
+    violetSoftBg: string;
+    violetSoftBorder: string;
+    violetSoftText: string;
+    skySoftBg: string;
+    skySoftBorder: string;
+    skySoftText: string;
     domainColors: string[];
 };
 export declare const AppColors: typeof LightColors;

package/dist/esm/styles/AppColors.js

@@ -161,6 +161,21 @@ const LightColors = {
     greyBorder: '#E3DFEC',
     paperBg: '#FBF9FC',
     contentBg: '#F8F7FB',
+    // ─── Toast / Glass / Chip Tokens ───
+    toastBg: '#0F172AEE',
+    toastBorder: '#33415588',
+    mintGreenBg: '#ECFDF5',
+    mintGreenBorder: '#A7F3D0',
+    mintGreenText: '#059669',
+    amberWarmBg: '#FFFBEB',
+    amberWarmBorder: '#FDE68A',
+    amberWarmText: '#92400E',
+    violetSoftBg: '#EDE9FE',
+    violetSoftBorder: '#DDD6FE',
+    violetSoftText: '#7C3AED',
+    skySoftBg: '#E0F2FE',
+    skySoftBorder: '#BAE6FD',
+    skySoftText: '#0284C7',
     // ─── Domain Colors (Thai Airways Themed) ───
     domainColors: [
         '#5C2D91',
@@ -237,6 +252,21 @@ const DarkColors = {
     amber700: '#C5A059',
     amber800: '#B89758',
     green500: '#22C55E',
+    // ─── Toast / Glass / Chip Tokens (Dark) ───
+    toastBg: '#1E293BEE',
+    toastBorder: '#47556988',
+    mintGreenBg: '#064E3B66',
+    mintGreenBorder: '#05966988',
+    mintGreenText: '#34D399',
+    amberWarmBg: '#451A0366',
+    amberWarmBorder: '#D9770688',
+    amberWarmText: '#FCD34D',
+    violetSoftBg: '#3B076466',
+    violetSoftBorder: '#7C3AED88',
+    violetSoftText: '#C084FC',
+    skySoftBg: '#082F4966',
+    skySoftBorder: '#0284C788',
+    skySoftText: '#38BDF8',
     green600: '#16A34A',
     green700: '#15803D',
     green800: '#166534',

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
+