react-native-debug-toolkit 2.0.0 → 2.1.0

package/src/index.ts

@@ -1,12 +1,14 @@
 // Core
 export { DebugToolkit } from './core/DebugToolkit';
 export { DebugToolkitProvider, useDebugToolkit } from './core/DebugToolkitProvider';
-export { initializeDebugToolkit, isDebugMode } from './initialize';
+export { DebugView } from './components/DebugView';
+export type { DebugViewProps } from './components/DebugView';
+export { initializeDebugToolkit } from './initialize';
 export type { InitializeOptions, FeatureConfigs } from './initialize';
 
 // Feature factories
 export { createNetworkFeature } from './features/NetworkFeature';
-export type { NetworkFeatureAPI, NetworkFeatureConfig } from './features/NetworkFeature';
+export type { NetworkFeatureConfig, AxiosInstanceLike } from './features/NetworkFeature';
 export { createConsoleLogFeature } from './features/ConsoleLogFeature';
 export type { ConsoleFeatureConfig } from './features/ConsoleLogFeature';
 export { createZustandLogFeature, zustandLogMiddleware, addZustandLog } from './features/ZustandLogFeature';
@@ -15,14 +17,12 @@ export { createNavigationLogFeature, addNavigationLog } from './features/Navigat
 export type { NavigationFeatureConfig } from './features/NavigationLogFeature';
 export { createTrackFeature, addTrackLog } from './features/TrackFeature';
 export type { TrackFeatureConfig, TrackEventData } from './features/TrackFeature';
-export { createThirdPartyLibsFeature } from './features/ThirdPartyLibsFeature';
 export { createEnvironmentFeature } from './features/EnvironmentFeature';
 export type { EnvironmentFeatureAPI } from './features/EnvironmentFeature';
 export { createClipboardFeature } from './features/ClipboardFeature';
 
 // Hooks
 export { useNavigationLogger } from './hooks/useNavigationLogger';
-export { useSlideDetailAnimation } from './hooks/useSlideDetailAnimation';
 
 // Utilities
 export { safeStringify } from './utils/safeStringify';
@@ -31,19 +31,15 @@ export type { CopyResult, CopyOptions, CopyMethod } from './utils/copyToComputer
 
 // Types
 export type {
+  AnyDebugFeature,
   BuiltInFeatureName,
   DebugFeature,
-  DebugFeatureFactory,
-  DebugFeatureInput,
   DebugFeatureRenderProps,
-  DebugToolkitConfig,
-  DebugToolkitAPI,
   NetworkLogEntry,
   ConsoleLogEntry,
   ZustandLogEntry,
   NavigationLogEntry,
   TrackLogEntry,
-  ThirdPartyLib,
   EnvironmentConfig,
   EnvironmentState,
 } from './types';

package/src/initialize.ts

@@ -9,17 +9,11 @@ import { createNavigationLogFeature } from './features/NavigationLogFeature';
 import type { NavigationFeatureConfig } from './features/NavigationLogFeature';
 import { createTrackFeature } from './features/TrackFeature';
 import type { TrackFeatureConfig } from './features/TrackFeature';
-import { createThirdPartyLibsFeature } from './features/ThirdPartyLibsFeature';
 import { createEnvironmentFeature } from './features/EnvironmentFeature';
 import { createClipboardFeature } from './features/ClipboardFeature';
-import { NativeDebugLibs } from './native/NativeDebugLibs';
-import type {
-  BuiltInFeatureName,
-  DebugFeature,
-  DebugFeatureInput,
-} from './types';
+import type { AnyDebugFeature, BuiltInFeatureName } from './types';
 
-export const isDebugMode = __DEV__;
+const isDebugMode = __DEV__;
 
 /** Feature-specific configuration map */
 export interface FeatureConfigs {
@@ -28,25 +22,24 @@ export interface FeatureConfigs {
   zustand?: boolean | ZustandFeatureConfig;
   navigation?: boolean | NavigationFeatureConfig;
   track?: boolean | TrackFeatureConfig;
-  thirdPartyLibs?: boolean;
   environment?: Parameters<typeof createEnvironmentFeature>[0];
   clipboard?: boolean;
 }
 
 export interface InitializeOptions {
-  doraemonProductId?: string;
+  features?: FeatureConfigs;
   enabled?: boolean;
 }
 
 /** Registry mapping feature names to creator functions */
+// Config param requires `any` — each factory accepts a different config type.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const featureRegistry: Record<BuiltInFeatureName, (config?: any) => DebugFeature<any>> = {
+const featureRegistry: Record<BuiltInFeatureName, (config?: any) => AnyDebugFeature> = {
   network: createNetworkFeature,
   console: createConsoleLogFeature,
   zustand: createZustandLogFeature,
   navigation: createNavigationLogFeature,
   track: createTrackFeature,
-  thirdPartyLibs: createThirdPartyLibsFeature,
   environment: createEnvironmentFeature,
   clipboard: createClipboardFeature,
 };
@@ -57,55 +50,14 @@ const DEFAULT_FEATURES: BuiltInFeatureName[] = [
   'navigation',
   'zustand',
   'track',
-  'thirdPartyLibs',
   'clipboard',
 ];
 
-function resolveFeatures(
-  features: DebugFeatureInput[],
-): DebugFeature<any>[] {
-  return features.reduce<DebugFeature<any>[]>((resolvedFeatures, identifier) => {
-    let feature: DebugFeature<any> | null = null;
-
-    if (typeof identifier === 'string') {
-      const creator = featureRegistry[identifier as BuiltInFeatureName];
-      if (!creator) {
-        console.warn(`[DebugToolkit] Unknown feature: "${identifier}"`);
-        return resolvedFeatures;
-      }
-      feature = creator();
-    } else if (typeof identifier === 'function') {
-      try {
-        feature = identifier();
-      } catch (error) {
-        console.error('[DebugToolkit] Feature creator failed:', error);
-        return resolvedFeatures;
-      }
-    } else if (identifier && typeof identifier === 'object' && identifier.name) {
-      feature = identifier;
-    } else {
-      console.warn('[DebugToolkit] Invalid feature identifier:', identifier);
-      return resolvedFeatures;
-    }
-
-    if (feature) {
-      resolvedFeatures.push(feature);
-    }
-
-    return resolvedFeatures;
-  }, []);
-}
-
-/**
- * Resolve feature configs to DebugFeature instances.
- */
-function resolveFeatureConfigs(configs: FeatureConfigs): DebugFeature<any>[] {
-  const features: DebugFeature<any>[] = [];
-
+function resolveFeatureConfigs(configs: FeatureConfigs): AnyDebugFeature[] {
+  const features: AnyDebugFeature[] = [];
   const entries = Object.entries(configs) as [BuiltInFeatureName, unknown][];
 
   for (const [name, config] of entries) {
-    // Skip false/explicitly disabled
     if (config === false) continue;
 
     const creator = featureRegistry[name];
@@ -114,7 +66,6 @@ function resolveFeatureConfigs(configs: FeatureConfigs): DebugFeature<any>[] {
       continue;
     }
 
-    // config === true or undefined → use defaults
     if (config === true || config === undefined) {
       features.push(creator());
     } else if (typeof config === 'object') {
@@ -125,90 +76,47 @@ function resolveFeatureConfigs(configs: FeatureConfigs): DebugFeature<any>[] {
   return features;
 }
 
+function resolveDefaultFeatures(): AnyDebugFeature[] {
+  return DEFAULT_FEATURES.map((name) => featureRegistry[name]!());
+}
+
 /**
  * Initialize the debug toolkit.
  *
- * @param featuresOrOptions - Either an array of feature inputs (legacy), or a full config object.
- * @param options - Options when using legacy array mode.
- *
  * @example
- * // Legacy mode (still supported)
- * initializeDebugToolkit(['network', 'console'], { enabled: true });
- *
- * // Config object mode (recommended)
  * initializeDebugToolkit({
- *   features: {
- *     network: { maxLogs: 100 },
- *     console: true,
- *     track: true,
- *     environment: { environments: [...] },
- *   },
+ *   features: { network: true, console: true },
  *   enabled: true,
  * });
  */
 export function initializeDebugToolkit(
-  featuresOrOptions?: DebugFeatureInput[] | {
-    features?: FeatureConfigs;
-    enabled?: boolean;
-    doraemonProductId?: string;
-  },
-  options: InitializeOptions = {},
-): DebugToolkit | null {
-  // Determine which mode we're in
-  let resolvedFeatures: DebugFeature<any>[];
-  let enabled: boolean;
-  let doraemonProductId: string | undefined;
-
-  if (Array.isArray(featuresOrOptions)) {
-    // Legacy mode
-    resolvedFeatures = resolveFeatures(featuresOrOptions);
-    enabled = options.enabled ?? isDebugMode;
-    doraemonProductId = options.doraemonProductId;
-  } else if (featuresOrOptions && typeof featuresOrOptions === 'object' && !('name' in featuresOrOptions)) {
-    // Config object mode
-    const config = featuresOrOptions;
-    enabled = config.enabled ?? isDebugMode;
-    doraemonProductId = config.doraemonProductId;
-
-    if (config.features) {
-      resolvedFeatures = resolveFeatureConfigs(config.features);
-    } else {
-      resolvedFeatures = resolveFeatures(DEFAULT_FEATURES);
-    }
-  } else {
-    // Default - no args or single feature
-    resolvedFeatures = resolveFeatures(
-      featuresOrOptions ? [featuresOrOptions as DebugFeatureInput] : DEFAULT_FEATURES,
-    );
-    enabled = options.enabled ?? isDebugMode;
-    doraemonProductId = options.doraemonProductId;
-  }
+  options?: InitializeOptions,
+): typeof DebugToolkit {
+  const enabled = options?.enabled ?? isDebugMode;
+
+  const resolvedFeatures = options?.features
+    ? resolveFeatureConfigs(options.features)
+    : resolveDefaultFeatures();
 
   try {
-    const toolkit = DebugToolkit.getInstance(enabled);
-    toolkit.setEnabled(enabled);
+    DebugToolkit.setEnabled(enabled);
 
     if (!enabled) {
-      toolkit.reset();
-      return toolkit;
-    }
-
-    // Initialize native debug libs if configured
-    if (doraemonProductId) {
-      NativeDebugLibs.installDoraemonKit(doraemonProductId);
+      DebugToolkit.reset();
+      return DebugToolkit;
     }
 
-    toolkit.replaceFeatures(resolvedFeatures);
+    DebugToolkit.replaceFeatures(resolvedFeatures);
 
-    if (toolkit.hasFeatures()) {
-      toolkit.showPanel();
+    if (DebugToolkit.hasFeatures()) {
+      DebugToolkit.showPanel();
     } else {
-      toolkit.hidePanel();
+      DebugToolkit.hidePanel();
     }
 
-    return toolkit;
+    return DebugToolkit;
   } catch (error) {
     console.error('[DebugToolkit] Initialization failed:', error);
-    return null;
+    return DebugToolkit;
   }
 }