react-native-debug-toolkit 3.1.3 → 3.1.4

package/src/core/DebugToolkit.tsx

@@ -1,176 +1,190 @@
-import type { AnyDebugFeature } from '../types';
+import type { AnyDebugFeature, DebugFeatureListener, FeatureDataProvider } from '../types';
 
-type Listener = () => void;
+class DebugToolkitCore implements FeatureDataProvider {
+  private _features: AnyDebugFeature[] = [];
+  private _launcherVisible = false;
+  private _panelOpen = false;
+  private _enabled = true;
+  private _listeners = new Set<DebugFeatureListener>();
 
-const listeners = new Set<Listener>();
-let _features: AnyDebugFeature[] = [];
-let _launcherVisible = false;
-let _panelOpen = false;
-let _enabled = true;
+  private notify(): void {
+    this._listeners.forEach((l) => l());
+  }
 
-function notify(): void {
-  listeners.forEach((l) => l());
-}
-
-function setupFeature(feature: AnyDebugFeature): void {
-  feature.setup?.();
-}
+  // --- FeatureDataProvider ---
 
-function cleanupFeature(feature: AnyDebugFeature): void {
-  feature.cleanup?.();
-}
+  get features(): AnyDebugFeature[] {
+    return [...this._features];
+  }
 
-export const DebugToolkit = {
-  subscribe(listener: Listener): () => void {
-    listeners.add(listener);
+  subscribe(listener: DebugFeatureListener): () => void {
+    this._listeners.add(listener);
     return () => {
-      listeners.delete(listener);
+      this._listeners.delete(listener);
     };
-  },
+  }
 
-  get features(): AnyDebugFeature[] {
-    return [..._features];
-  },
+  // --- Enabled ---
 
   get enabled(): boolean {
-    return _enabled;
-  },
-
-  get launcherVisible(): boolean {
-    return _launcherVisible;
-  },
+    return this._enabled;
+  }
 
   setEnabled(enabled: boolean): void {
-    if (_enabled === enabled) return;
-    _enabled = enabled;
+    if (this._enabled === enabled) return;
+    this._enabled = enabled;
     if (!enabled) {
-      _launcherVisible = false;
-      _features.forEach(cleanupFeature);
-      _features = [];
+      this._launcherVisible = false;
+      this._features.forEach((f) => f.cleanup?.());
+      this._features = [];
     }
-    notify();
-  },
+    this.notify();
+  }
+
+  // --- Feature Management ---
 
   replaceFeatures(features: AnyDebugFeature[]): void {
-    if (!_enabled) return;
+    if (!this._enabled) return;
     const next = features.filter(
       (f, i, arr) =>
         f && typeof f.name === 'string' && arr.findIndex((item) => item.name === f.name) === i,
     );
-    const prevMap = new Map(_features.map((f) => [f.name, f]));
+    const prevMap = new Map(this._features.map((f) => [f.name, f]));
     const nextMap = new Map(next.map((f) => [f.name, f]));
 
-    _features.forEach((f) => {
-      if (!nextMap.get(f.name) || nextMap.get(f.name) !== f) cleanupFeature(f);
+    this._features.forEach((f) => {
+      if (!nextMap.get(f.name) || nextMap.get(f.name) !== f) f.cleanup?.();
     });
     next.forEach((f) => {
-      if (!prevMap.get(f.name) || prevMap.get(f.name) !== f) setupFeature(f);
+      if (!prevMap.get(f.name) || prevMap.get(f.name) !== f) f.setup?.();
     });
 
-    _features = next;
-    notify();
-  },
+    this._features = next;
+    this.notify();
+  }
 
   addFeature(feature: AnyDebugFeature): void {
-    if (!_enabled || !feature || typeof feature.name !== 'string') {
+    if (!this._enabled || !feature || typeof feature.name !== 'string') {
       return;
     }
 
-    const existingIndex = _features.findIndex((f) => f.name === feature.name);
+    const existingIndex = this._features.findIndex((f) => f.name === feature.name);
     if (existingIndex >= 0) {
-      const existing = _features[existingIndex]!;
+      const existing = this._features[existingIndex]!;
       if (existing === feature) {
         return;
       }
 
-      cleanupFeature(existing);
-      setupFeature(feature);
-      _features = [
-        ..._features.slice(0, existingIndex),
+      existing.cleanup?.();
+      feature.setup?.();
+      this._features = [
+        ...this._features.slice(0, existingIndex),
         feature,
-        ..._features.slice(existingIndex + 1),
+        ...this._features.slice(existingIndex + 1),
       ];
-      notify();
+      this.notify();
       return;
     }
 
-    setupFeature(feature);
-    _features = [..._features, feature];
-    notify();
-  },
+    feature.setup?.();
+    this._features = [...this._features, feature];
+    this.notify();
+  }
 
   removeFeature(name: string): void {
-    if (!_enabled) {
+    if (!this._enabled) {
       return;
     }
 
-    const feature = _features.find((f) => f.name === name);
+    const feature = this._features.find((f) => f.name === name);
     if (!feature) {
       return;
     }
 
-    cleanupFeature(feature);
-    _features = _features.filter((f) => f.name !== name);
-    if (_features.length === 0) {
-      _launcherVisible = false;
+    feature.cleanup?.();
+    this._features = this._features.filter((f) => f.name !== name);
+    if (this._features.length === 0) {
+      this._launcherVisible = false;
     }
-    notify();
-  },
-
-  reset(): void {
-    _launcherVisible = false;
-    _panelOpen = false;
-    _features.forEach(cleanupFeature);
-    _features = [];
-    notify();
-  },
+    this.notify();
+  }
 
   hasFeatures(): boolean {
-    return _features.length > 0;
-  },
+    return this._features.length > 0;
+  }
+
+  // --- Panel ---
 
   get panelOpen(): boolean {
-    return _panelOpen;
-  },
+    return this._panelOpen;
+  }
 
   openPanel(): void {
-    if (!_enabled || _panelOpen) return;
-    _panelOpen = true;
-    notify();
-  },
+    if (!this._enabled || this._panelOpen) return;
+    this._panelOpen = true;
+    this.notify();
+  }
 
   closePanel(): void {
-    if (!_panelOpen) return;
-    _panelOpen = false;
-    notify();
-  },
+    if (!this._panelOpen) return;
+    this._panelOpen = false;
+    this.notify();
+  }
 
   togglePanel(): void {
-    if (_panelOpen) {
-      DebugToolkit.closePanel();
+    if (this._panelOpen) {
+      this.closePanel();
     } else {
-      DebugToolkit.openPanel();
+      this.openPanel();
     }
-  },
+  }
+
+  // --- Launcher ---
+
+  get launcherVisible(): boolean {
+    return this._launcherVisible;
+  }
 
   showLauncher(): void {
-    if (!_enabled) return;
-    _launcherVisible = true;
-    notify();
-  },
+    if (!this._enabled) return;
+    this._launcherVisible = true;
+    this.notify();
+  }
 
   hideLauncher(): void {
-    _launcherVisible = false;
-    notify();
-  },
+    if (!this._launcherVisible) return;
+    this._launcherVisible = false;
+    this.notify();
+  }
+
+  // --- Bulk Operations ---
 
   clearAll(): void {
-    _features.forEach((f) => f.clear?.());
-    notify();
-  },
+    this._features.forEach((f) => f.clear?.());
+    this.notify();
+  }
+
+  reset(): void {
+    this._launcherVisible = false;
+    this._panelOpen = false;
+    this._features.forEach((f) => f.cleanup?.());
+    this._features = [];
+    this.notify();
+  }
 
   destroy(): void {
-    DebugToolkit.reset();
-    listeners.clear();
-  },
-};
+    this.reset();
+    this._listeners.clear();
+  }
+}
+
+/** Module-level default instance for non-React scenarios and backward compatibility. */
+export const debugToolkit = new DebugToolkitCore();
+
+export type DebugToolkit = DebugToolkitCore;
+
+/**
+ * @deprecated Use `debugToolkit` or get instance from `initializeDebugToolkit()`.
+ * This is the default module-level instance exported for backward compatibility.
+ */
+export const DebugToolkit = debugToolkit;

package/src/core/initialize.ts

@@ -1,5 +1,5 @@
 import { DebugToolkit } from './DebugToolkit';
-import { createNetworkFeature } from '../features/network';
+import { createNetworkFeature, addToBlacklist } from '../features/network';
 import type { NetworkFeatureConfig } from '../features/network';
 import { createConsoleLogFeature } from '../features/console';
 import type { ConsoleFeatureConfig } from '../features/console';
@@ -11,16 +11,11 @@ import { createTrackFeature } from '../features/track';
 import type { TrackFeatureConfig } from '../features/track';
 import { createEnvironmentFeature } from '../features/environment';
 import { createClipboardFeature } from '../features/clipboard';
-import { daemonClient, restoreDaemonStreaming } from '../utils/DaemonClient';
-import { _addDaemonEndpointToNetworkBlacklist } from '../features/network';
+import { daemonClient } from '../utils/DaemonClient';
 import type { AnyDebugFeature, BuiltInFeatureName } from '../types';
 
 const isDebugMode = __DEV__;
 
-daemonClient.setEndpointDetector((url) => {
-  _addDaemonEndpointToNetworkBlacklist(url);
-});
-
 /** Feature-specific configuration map */
 export interface FeatureConfigs {
   network?: boolean | NetworkFeatureConfig;
@@ -114,13 +109,17 @@ export function initializeDebugToolkit(
 
     DebugToolkit.replaceFeatures(resolvedFeatures);
 
+    daemonClient.setEndpointDetector((url) => {
+      addToBlacklist(url);
+    });
+
     if (DebugToolkit.hasFeatures()) {
       DebugToolkit.showLauncher();
     } else {
       DebugToolkit.hideLauncher();
     }
 
-    restoreDaemonStreaming().catch(() => {});
+    daemonClient.restore().catch(() => {});
 
     return DebugToolkit;
   } catch (error) {

package/src/features/environment/index.ts

@@ -5,7 +5,7 @@ import type {
   EnvironmentConfig,
   EnvironmentState,
 } from '../../types';
-import { urlRewriter } from '../../utils/urlRewriterRegistry';
+import { setUrlRewriter } from '../../utils/urlRewriter';
 
 // Lazy AsyncStorage loader
 type AsyncStorageModule = {
@@ -32,10 +32,6 @@ function getAsyncStorage(): AsyncStorageModule | null {
 
 const STORAGE_KEY = 'debug_toolkit_env_id';
 
-// Module-level state for synchronous URL rewriting
-let currentHostsMap: Map<string, string> | null = null;
-let activeEnvironmentId: string | null = null;
-
 function buildHostsMap(
   environments: EnvironmentConfig[],
   targetId: string | null,
@@ -53,24 +49,6 @@ function buildHostsMap(
   return map;
 }
 
-function createUrlRewriter(): (url: string) => string {
-  return (url: string): string => {
-    if (!currentHostsMap) return url;
-
-    try {
-      const parsed = new URL(url);
-      const targetHost = currentHostsMap.get(parsed.host);
-      if (targetHost) {
-        return url.replace(parsed.host, targetHost);
-      }
-    } catch {
-      // Not a valid URL or relative URL — return unchanged
-    }
-
-    return url;
-  };
-}
-
 export interface EnvironmentFeatureAPI extends DebugFeature<EnvironmentState> {
   registerEnvironments: (environments: EnvironmentConfig[]) => void;
   switchEnvironment: (environmentId: string | null) => void;
@@ -83,6 +61,26 @@ export const createEnvironmentFeature = (
   const listeners = new Set<DebugFeatureListener>();
   let environments: EnvironmentConfig[] = initialEnvironments ?? [];
   let initialized = false;
+  let currentHostsMap: Map<string, string> | null = null;
+  let activeEnvironmentId: string | null = null;
+
+  const createUrlRewriter = (): ((url: string) => string) => {
+    return (url: string): string => {
+      if (!currentHostsMap) return url;
+
+      try {
+        const parsed = new URL(url);
+        const targetHost = currentHostsMap.get(parsed.host);
+        if (targetHost) {
+          return url.replace(parsed.host, targetHost);
+        }
+      } catch {
+        // Not a valid URL or relative URL — return unchanged
+      }
+
+      return url;
+    };
+  };
 
   const getCurrentState = (): EnvironmentState => ({
     environments,
@@ -102,9 +100,9 @@ export const createEnvironmentFeature = (
     if (initialized) {
       try {
         if (envId && environments.length > 0) {
-          urlRewriter.set(createUrlRewriter());
+          setUrlRewriter(createUrlRewriter());
         } else {
-          urlRewriter.set(null);
+          setUrlRewriter(null);
         }
       } catch (err) {
         if (__DEV__) console.warn('[DebugToolkit] Failed to set URL rewriter:', err);
@@ -149,7 +147,7 @@ export const createEnvironmentFeature = (
 
       // Install rewriter if an environment is already selected
       if (activeEnvironmentId && environments.length > 0) {
-        urlRewriter.set(createUrlRewriter());
+        setUrlRewriter(createUrlRewriter());
       }
 
       // Async persistence load (will override if a preference exists)
@@ -162,7 +160,7 @@ export const createEnvironmentFeature = (
     },
     cleanup: () => {
       if (!initialized) return;
-      urlRewriter.set(null);
+      setUrlRewriter(null);
       activeEnvironmentId = null;
       currentHostsMap = null;
       notify();

package/src/features/network/index.ts

@@ -1,15 +1,15 @@
 import { NetworkLogTab } from './NetworkLogTab';
 
-import type { DebugFeature, NetworkLogEntry } from '../../types';
+import type { NetworkLogEntry } from '../../types';
+import { createChannelFeature } from '../../utils/createChannelFeature';
 import { createEventChannel } from '../../utils/createEventChannel';
-import { createPersistedObservableStore } from '../../utils/createPersistedObservableStore';
 import { KEYS } from '../../utils/debugPreferences';
-import { urlRewriter } from '../../utils/urlRewriterRegistry';
 import {
   startXMLHttpRequest,
   resetInterceptors,
 } from './networkInterceptor';
 import type { NetworkLogPayload } from './networkInterceptor';
+import { setUrlRewriter as setInterceptorUrlRewriter } from '../../utils/urlRewriter';
 
 // ─── Utilities ────────────────────────────────────────
 
@@ -35,7 +35,6 @@ function emitNetworkLog(entry: NetworkLogPayload): void {
 
 // ─── Feature factory ──────────────────────────────────
 
-const DEFAULT_MAX_LOGS = 200;
 const daemonEndpointBlacklist: Array<string | RegExp> = [];
 
 export interface NetworkFeatureConfig {
@@ -45,54 +44,33 @@ export interface NetworkFeatureConfig {
   blacklist?: Array<string | RegExp>;
 }
 
-export const createNetworkFeature = (config?: NetworkFeatureConfig): DebugFeature<NetworkLogEntry[]> => {
-  const maxLogs = config?.maxLogs ?? DEFAULT_MAX_LOGS;
-  const blacklist: Array<string | RegExp> = config?.blacklist ? [...config.blacklist] : [];
-  const logStore = createPersistedObservableStore<NetworkLogEntry>({
-    storageKey: KEYS.networkLogs,
-    maxPersist: 30,
-  });
-  let initialized = false;
-  let unsubscribeLogs: (() => void) | null = null;
-  let stopXhrFn: (() => void) | null = null;
-
-  const handleLog = (entry: NetworkLogPayload) => {
-    if (isUrlBlacklisted(entry.request.url, [...blacklist, ...daemonEndpointBlacklist])) {
-      return;
-    }
-    logStore.push({ ...entry, id: logStore.nextId() }, maxLogs);
-  };
-
-  return {
-    name: 'network',
-    label: 'Network',
-    renderContent: NetworkLogTab,
-    setup: () => {
-      if (initialized) {
-        return;
-      }
-      unsubscribeLogs = networkChannel.subscribe(handleLog);
-      stopXhrFn = startXMLHttpRequest(emitNetworkLog);
-      initialized = true;
+export const createNetworkFeature = (config?: NetworkFeatureConfig) => {
+  const userBlacklist = config?.blacklist ? [...config.blacklist] : [];
+
+  return createChannelFeature<NetworkLogPayload, NetworkLogEntry>(
+    () => networkChannel,
+    (payload, id) => ({ ...payload, id }),
+    {
+      name: 'network',
+      label: 'Network',
+      renderContent: NetworkLogTab,
+      maxLogs: config?.maxLogs,
+      persist: { storageKey: KEYS.networkLogs, maxPersist: 30 },
+      beforePush: (payload) => {
+        if (isUrlBlacklisted(payload.request.url, [...userBlacklist, ...daemonEndpointBlacklist])) {
+          return null;
+        }
+        return payload;
+      },
+      onSetup: () => {
+        const stopXhr = startXMLHttpRequest(emitNetworkLog);
+        return () => {
+          setInterceptorUrlRewriter(null);
+          stopXhr();
+        };
+      },
     },
-    getSnapshot: () => logStore.getData(),
-    clear: () => {
-      logStore.clear();
-    },
-    cleanup: () => {
-      if (!initialized) {
-        return;
-      }
-      urlRewriter.set(null);
-      unsubscribeLogs?.();
-      unsubscribeLogs = null;
-      stopXhrFn?.();
-      stopXhrFn = null;
-      logStore.clear();
-      initialized = false;
-    },
-    subscribe: (listener) => logStore.subscribe(listener),
-  };
+  );
 };
 
 function normalizeDaemonEndpoint(endpoint: string): string {
@@ -109,7 +87,7 @@ function normalizeDaemonEndpoint(endpoint: string): string {
   }
 }
 
-export function _addDaemonEndpointToNetworkBlacklist(endpoint: string): void {
+export function addToBlacklist(endpoint: string): void {
   const normalized = normalizeDaemonEndpoint(endpoint);
   if (!normalized || daemonEndpointBlacklist.includes(normalized)) {
     return;

package/src/features/network/networkInterceptor.ts

@@ -1,5 +1,5 @@
 import type { NetworkLogEntry } from '../../types';
-import { urlRewriter } from '../../utils/urlRewriterRegistry';
+import { getUrlRewriter } from '../../utils/urlRewriter';
 
 type NetworkLogPayload = Omit<NetworkLogEntry, 'id'>;
 
@@ -11,7 +11,7 @@ export type { NetworkLogPayload };
 // ─── Shared helpers ────────────────────────────────────
 
 function rewriteUrl(url: string): string {
-  const rewriter = urlRewriter.get();
+  const rewriter = getUrlRewriter();
   if (!rewriter) {
     return url;
   }
@@ -193,7 +193,7 @@ export function startXMLHttpRequest(
     url: string,
     ...args: unknown[]
   ) {
-    const rewrittenUrl = urlRewriter.get() ? rewriteUrl(url) : url;
+    const rewrittenUrl = rewriteUrl(url);
     if (shouldIgnoreUrl(rewrittenUrl)) {
       return originalXhrOpen!.call(this, method, rewrittenUrl, ...args);
     }

package/src/index.ts

@@ -42,21 +42,16 @@ export type {
   ReportResult,
   ReportToDaemonOptions,
 } from './utils/DaemonClient';
-export {
-  getDefaultDaemonEndpoint,
-  reportDebugDeviceToDaemon,
-  checkDaemonConnection,
-  startStreaming,
-  stopStreaming,
-  isStreaming,
-} from './utils/DaemonClient';
+export { getDefaultDaemonEndpoint } from './utils/DaemonClient';
 
 // Types
 export type {
   AnyDebugFeature,
   BuiltInFeatureName,
   DebugFeature,
+  DebugFeatureListener,
   DebugFeatureRenderProps,
+  FeatureDataProvider,
   NetworkLogEntry,
   ConsoleLogEntry,
   ZustandLogEntry,

package/src/types/feature.ts

@@ -19,6 +19,12 @@ export interface DebugFeatureRenderProps<TSnapshot = unknown> {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyDebugFeature = DebugFeature<any>;
 
+/** Provides feature list and change notifications to consumers (e.g., DaemonClient). */
+export interface FeatureDataProvider {
+  readonly features: AnyDebugFeature[];
+  subscribe(listener: DebugFeatureListener): () => void;
+}
+
 export interface DebugFeature<TSnapshot = unknown> {
   name: string;
   label: string;

package/src/types/index.ts

@@ -4,6 +4,7 @@ export type {
   DebugFeature,
   DebugFeatureListener,
   DebugFeatureRenderProps,
+  FeatureDataProvider,
 } from './feature';
 
 export type {