react-native-debug-toolkit 2.0.0 → 2.1.0

package/src/features/ConsoleLogFeature.ts

@@ -1,67 +1,76 @@
 import { ConsoleLogTab } from '../components/ConsoleLogTab';
 import type { ConsoleLogEntry, DebugFeature } from '../types';
-import { createEventChannel } from '../utils/createEventChannel';
 import { createObservableStore } from '../utils/createObservableStore';
 
-type ConsoleLogPayload = Omit<ConsoleLogEntry, 'id'>;
-
-const DEFAULT_MAX_LOGS = 200;
-const consoleChannel = createEventChannel<ConsoleLogPayload>();
-const originalConsole: Partial<Record<ConsoleLogEntry['level'], (...args: unknown[]) => void>> =
-  {};
 const LEVELS: ConsoleLogEntry['level'][] = ['log', 'info', 'warn', 'error'];
 
-let consoleCaptureRefCount = 0;
+// ─── Console capture manager (encapsulated mutable state) ──
+
+const consoleCapture = (() => {
+  const originalMethods: Partial<Record<ConsoleLogEntry['level'], (...args: unknown[]) => void>> = {};
+  let refCount = 0;
 
-function stopConsoleCapture(): void {
-  consoleCaptureRefCount = Math.max(0, consoleCaptureRefCount - 1);
+  function stop(): void {
+    refCount = Math.max(0, refCount - 1);
+    if (refCount > 0) return;
 
-  if (consoleCaptureRefCount > 0) {
-    return;
+    LEVELS.forEach((level) => {
+      const original = originalMethods[level];
+      if (original) {
+        console[level] = original;
+        delete originalMethods[level];
+      }
+    });
   }
 
-  LEVELS.forEach((level) => {
-    const originalMethod = originalConsole[level];
+  function isIntercepted(): boolean {
+    return LEVELS.some((level) => originalMethods[level] !== undefined);
+  }
 
-    if (!originalMethod) {
-      return;
+  function start(emit: (entry: ConsoleLogEntry) => void): () => void {
+    refCount += 1;
+    if (isIntercepted()) {
+      return () => { stop(); };
     }
 
-    console[level] = originalMethod;
-    delete originalConsole[level];
-  });
-}
-
-function startConsoleCapture(): () => void {
-  consoleCaptureRefCount += 1;
-
-  if (consoleCaptureRefCount > 1) {
-    return () => {
-      stopConsoleCapture();
-    };
+    LEVELS.forEach((level) => {
+      originalMethods[level] = console[level];
+
+      console[level] = (...args: unknown[]) => {
+        originalMethods[level]?.apply(console, args);
+        if (level === 'log' && typeof args[0] === 'string' && args[0].startsWith('[DebugToolkit:Copy]')) {
+          return;
+        }
+        emit({
+          id: '',
+          timestamp: Date.now(),
+          level,
+          data: args,
+        });
+      };
+    });
+
+    return () => { stop(); };
   }
 
-  LEVELS.forEach((level) => {
-    originalConsole[level] = console[level];
-
-    console[level] = (...args: unknown[]) => {
-      originalConsole[level]?.apply(console, args);
-      // Skip DebugToolkit's own copy-to-computer logs to avoid Console tab noise
-      if (level === 'log' && typeof args[0] === 'string' && args[0].startsWith('[DebugToolkit:Copy]')) {
-        return;
-      }
-      consoleChannel.emit({
-        timestamp: Date.now(),
-        level,
-        data: args,
+  return {
+    start,
+    reset() {
+      LEVELS.forEach((level) => {
+        const original = originalMethods[level];
+        if (original) {
+          console[level] = original;
+          delete originalMethods[level];
+        }
       });
-    };
-  });
-
-  return () => {
-    stopConsoleCapture();
+      refCount = 0;
+    },
   };
-}
+})();
+
+// ─── Feature factory ──────────────────────────────────
+
+const DEFAULT_MAX_LOGS = 200;
 
 export interface ConsoleFeatureConfig {
   /** Maximum number of console logs to keep (default: 200) */
@@ -73,7 +82,6 @@ export const createConsoleLogFeature = (config?: ConsoleFeatureConfig): DebugFea
   const logStore = createObservableStore<ConsoleLogEntry>();
   let nextId = 0;
   let initialized = false;
-  let unsubscribeLogs: (() => void) | null = null;
   let stopCapture: (() => void) | null = null;
 
   return {
@@ -81,33 +89,18 @@ export const createConsoleLogFeature = (config?: ConsoleFeatureConfig): DebugFea
     label: 'Console',
     renderContent: ConsoleLogTab,
     setup: () => {
-      if (initialized) {
-        return;
-      }
+      if (initialized) return;
 
-      unsubscribeLogs = consoleChannel.subscribe((entry) => {
-        logStore.push(
-          {
-            ...entry,
-            id: String(nextId++),
-          },
-          maxLogs,
-        );
+      stopCapture = consoleCapture.start((entry) => {
+        logStore.push({ ...entry, id: String(nextId++) }, maxLogs);
       });
-      stopCapture = startConsoleCapture();
       initialized = true;
     },
     getData: () => logStore.getData(),
-    clear: () => {
-      logStore.clear();
-    },
+    clear: () => { logStore.clear(); },
     cleanup: () => {
-      if (!initialized) {
-        return;
-      }
+      if (!initialized) return;
 
-      unsubscribeLogs?.();
-      unsubscribeLogs = null;
       stopCapture?.();
       stopCapture = null;
       logStore.clear();
@@ -116,3 +109,8 @@ export const createConsoleLogFeature = (config?: ConsoleFeatureConfig): DebugFea
     subscribe: (listener) => logStore.subscribe(listener),
   };
 };
+
+/** Reset module-level state for testing */
+export function _resetConsoleForTesting(): void {
+  consoleCapture.reset();
+}

package/src/features/EnvironmentFeature.ts

@@ -1,7 +1,7 @@
 import { EnvironmentTab } from '../components/EnvironmentTab';
 import type { DebugFeature, EnvironmentConfig, EnvironmentState } from '../types';
 import { createObservableStore } from '../utils/createObservableStore';
-import { setUrlRewriter } from './NetworkFeature';
+import { urlRewriter } from '../utils/urlRewriterRegistry';
 
 // Lazy AsyncStorage loader
 type AsyncStorageModule = {
@@ -97,9 +97,9 @@ export const createEnvironmentFeature = (
     if (initialized) {
       try {
         if (envId && environments.length > 0) {
-          setUrlRewriter(createUrlRewriter());
+          urlRewriter.set(createUrlRewriter());
         } else {
-          setUrlRewriter(null);
+          urlRewriter.set(null);
         }
       } catch (err) {
         if (__DEV__) console.warn('[DebugToolkit] Failed to set URL rewriter:', err);
@@ -144,11 +144,7 @@ export const createEnvironmentFeature = (
 
       // Install rewriter if an environment is already selected
       if (activeEnvironmentId && environments.length > 0) {
-        try {
-          setUrlRewriter(createUrlRewriter());
-        } catch {
-          // NetworkFeature may not be available
-        }
+        urlRewriter.set(createUrlRewriter());
       }
 
       // Async persistence load (will override if a preference exists)
@@ -161,11 +157,7 @@ export const createEnvironmentFeature = (
     },
     cleanup: () => {
       if (!initialized) return;
-      try {
-        setUrlRewriter(null);
-      } catch (err) {
-        if (__DEV__) console.warn('[DebugToolkit] Failed to set URL rewriter:', err);
-      }
+      urlRewriter.set(null);
       activeEnvironmentId = null;
       currentHostsMap = null;
       stateStore.clear();

package/src/features/NavigationLogFeature.ts

@@ -1,12 +1,11 @@
 import { NavigationLogTab } from '../components/NavigationLogTab';
 import type { DebugFeature, NavigationLogEntry } from '../types';
 import { createEventChannel } from '../utils/createEventChannel';
-import { createObservableStore } from '../utils/createObservableStore';
+import { createChannelFeature } from '../utils/createChannelFeature';
 
 type NavigationLogPayload = Omit<NavigationLogEntry, 'id'>;
 
-const DEFAULT_MAX_LOGS = 200;
-const navigationChannel = createEventChannel<NavigationLogPayload>();
+let navigationChannel = createEventChannel<NavigationLogPayload>();
 
 export const addNavigationLog = (
   action: string,
@@ -32,43 +31,14 @@ export interface NavigationFeatureConfig {
   maxLogs?: number;
 }
 
-export const createNavigationLogFeature = (config?: NavigationFeatureConfig): DebugFeature<NavigationLogEntry> => {
-  const maxLogs = config?.maxLogs ?? DEFAULT_MAX_LOGS;
-  const logStore = createObservableStore<NavigationLogEntry>();
-  let nextId = 0;
-  let unsubscribeLogs: (() => void) | null = null;
-  let initialized = false;
+export const createNavigationLogFeature = (config?: NavigationFeatureConfig): DebugFeature<NavigationLogEntry> =>
+  createChannelFeature(
+    () => navigationChannel,
+    (payload, id) => ({ ...payload, id }),
+    { name: 'navigation', label: 'Navigation', renderContent: NavigationLogTab, maxLogs: config?.maxLogs },
+  );
 
-  return {
-    name: 'navigation',
-    label: 'Navigation',
-    renderContent: NavigationLogTab,
-    setup: () => {
-      if (initialized) {
-        return;
-      }
-
-      unsubscribeLogs = navigationChannel.subscribe((entry) => {
-        logStore.push(
-          {
-            ...entry,
-            id: String(nextId++),
-          },
-          maxLogs,
-        );
-      });
-      initialized = true;
-    },
-    getData: () => logStore.getData(),
-    clear: () => {
-      logStore.clear();
-    },
-    cleanup: () => {
-      unsubscribeLogs?.();
-      unsubscribeLogs = null;
-      logStore.clear();
-      initialized = false;
-    },
-    subscribe: (listener) => logStore.subscribe(listener),
-  };
-};
+/** Reset module-level state for testing */
+export function _resetNavigationForTesting(): void {
+  navigationChannel = createEventChannel<NavigationLogPayload>();
+}