react-native-debug-toolkit 2.0.0 → 2.1.0

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_DebugToolkit","require","_DebugToolkitProvider","_initialize","_NetworkFeature","_ConsoleLogFeature","_ZustandLogFeature","_NavigationLogFeature","_TrackFeature","_ThirdPartyLibsFeature","_EnvironmentFeature","_ClipboardFeature","_useNavigationLogger","_useSlideDetailAnimation","_safeStringify","_copyToComputer"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAEA,IAAAI,kBAAA,GAAAJ,OAAA;AAEA,IAAAK,kBAAA,GAAAL,OAAA;AAEA,IAAAM,qBAAA,GAAAN,OAAA;AAEA,IAAAO,aAAA,GAAAP,OAAA;AAEA,IAAAQ,sBAAA,GAAAR,OAAA;AACA,IAAAS,mBAAA,GAAAT,OAAA;AAEA,IAAAU,iBAAA,GAAAV,OAAA;AAGA,IAAAW,oBAAA,GAAAX,OAAA;AACA,IAAAY,wBAAA,GAAAZ,OAAA;AAGA,IAAAa,cAAA,GAAAb,OAAA;AACA,IAAAc,eAAA,GAAAd,OAAA","ignoreList":[]}
+{"version":3,"names":["_DebugToolkit","require","_DebugToolkitProvider","_DebugView","_initialize","_NetworkFeature","_ConsoleLogFeature","_ZustandLogFeature","_NavigationLogFeature","_TrackFeature","_EnvironmentFeature","_ClipboardFeature","_useNavigationLogger","_safeStringify","_copyToComputer"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AAIA,IAAAI,eAAA,GAAAJ,OAAA;AAEA,IAAAK,kBAAA,GAAAL,OAAA;AAEA,IAAAM,kBAAA,GAAAN,OAAA;AAEA,IAAAO,qBAAA,GAAAP,OAAA;AAEA,IAAAQ,aAAA,GAAAR,OAAA;AAEA,IAAAS,mBAAA,GAAAT,OAAA;AAEA,IAAAU,iBAAA,GAAAV,OAAA;AAGA,IAAAW,oBAAA,GAAAX,OAAA;AAGA,IAAAY,cAAA,GAAAZ,OAAA;AACA,IAAAa,eAAA,GAAAb,OAAA","ignoreList":[]}

package/lib/commonjs/initialize.js

@@ -4,22 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.initializeDebugToolkit = initializeDebugToolkit;
-exports.isDebugMode = void 0;
 var _DebugToolkit = require("./core/DebugToolkit");
 var _NetworkFeature = require("./features/NetworkFeature");
 var _ConsoleLogFeature = require("./features/ConsoleLogFeature");
 var _ZustandLogFeature = require("./features/ZustandLogFeature");
 var _NavigationLogFeature = require("./features/NavigationLogFeature");
 var _TrackFeature = require("./features/TrackFeature");
-var _ThirdPartyLibsFeature = require("./features/ThirdPartyLibsFeature");
 var _EnvironmentFeature = require("./features/EnvironmentFeature");
 var _ClipboardFeature = require("./features/ClipboardFeature");
-var _NativeDebugLibs = require("./native/NativeDebugLibs");
-const isDebugMode = exports.isDebugMode = __DEV__;
+const isDebugMode = __DEV__;
 
 /** Feature-specific configuration map */
 
 /** 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 = {
   network: _NetworkFeature.createNetworkFeature,
@@ -27,57 +25,20 @@ const featureRegistry = {
   zustand: _ZustandLogFeature.createZustandLogFeature,
   navigation: _NavigationLogFeature.createNavigationLogFeature,
   track: _TrackFeature.createTrackFeature,
-  thirdPartyLibs: _ThirdPartyLibsFeature.createThirdPartyLibsFeature,
   environment: _EnvironmentFeature.createEnvironmentFeature,
   clipboard: _ClipboardFeature.createClipboardFeature
 };
-const DEFAULT_FEATURES = ['network', 'console', 'navigation', 'zustand', 'track', 'thirdPartyLibs', 'clipboard'];
-function resolveFeatures(features) {
-  return features.reduce((resolvedFeatures, identifier) => {
-    let feature = null;
-    if (typeof identifier === 'string') {
-      const creator = featureRegistry[identifier];
-      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.
- */
+const DEFAULT_FEATURES = ['network', 'console', 'navigation', 'zustand', 'track', 'clipboard'];
 function resolveFeatureConfigs(configs) {
   const features = [];
   const entries = Object.entries(configs);
   for (const [name, config] of entries) {
-    // Skip false/explicitly disabled
     if (config === false) continue;
     const creator = featureRegistry[name];
     if (!creator) {
       console.warn(`[DebugToolkit] Unknown feature: "${name}"`);
       continue;
     }
-
-    // config === true or undefined → use defaults
     if (config === true || config === undefined) {
       features.push(creator());
     } else if (typeof config === 'object') {
@@ -86,76 +47,38 @@ function resolveFeatureConfigs(configs) {
   }
   return features;
 }
+function resolveDefaultFeatures() {
+  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,
  * });
  */
-function initializeDebugToolkit(featuresOrOptions, options = {}) {
-  // Determine which mode we're in
-  let resolvedFeatures;
-  let enabled;
-  let doraemonProductId;
-  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] : DEFAULT_FEATURES);
-    enabled = options.enabled ?? isDebugMode;
-    doraemonProductId = options.doraemonProductId;
-  }
+function initializeDebugToolkit(options) {
+  const enabled = options?.enabled ?? isDebugMode;
+  const resolvedFeatures = options?.features ? resolveFeatureConfigs(options.features) : resolveDefaultFeatures();
   try {
-    const toolkit = _DebugToolkit.DebugToolkit.getInstance(enabled);
-    toolkit.setEnabled(enabled);
+    _DebugToolkit.DebugToolkit.setEnabled(enabled);
     if (!enabled) {
-      toolkit.reset();
-      return toolkit;
-    }
-
-    // Initialize native debug libs if configured
-    if (doraemonProductId) {
-      _NativeDebugLibs.NativeDebugLibs.installDoraemonKit(doraemonProductId);
+      _DebugToolkit.DebugToolkit.reset();
+      return _DebugToolkit.DebugToolkit;
     }
-    toolkit.replaceFeatures(resolvedFeatures);
-    if (toolkit.hasFeatures()) {
-      toolkit.showPanel();
+    _DebugToolkit.DebugToolkit.replaceFeatures(resolvedFeatures);
+    if (_DebugToolkit.DebugToolkit.hasFeatures()) {
+      _DebugToolkit.DebugToolkit.showPanel();
     } else {
-      toolkit.hidePanel();
+      _DebugToolkit.DebugToolkit.hidePanel();
     }
-    return toolkit;
+    return _DebugToolkit.DebugToolkit;
   } catch (error) {
     console.error('[DebugToolkit] Initialization failed:', error);
-    return null;
+    return _DebugToolkit.DebugToolkit;
   }
 }
 //# sourceMappingURL=initialize.js.map

package/lib/commonjs/initialize.js.map

@@ -1 +1 @@
-{"version":3,"names":["_DebugToolkit","require","_NetworkFeature","_ConsoleLogFeature","_ZustandLogFeature","_NavigationLogFeature","_TrackFeature","_ThirdPartyLibsFeature","_EnvironmentFeature","_ClipboardFeature","_NativeDebugLibs","isDebugMode","exports","__DEV__","featureRegistry","network","createNetworkFeature","console","createConsoleLogFeature","zustand","createZustandLogFeature","navigation","createNavigationLogFeature","track","createTrackFeature","thirdPartyLibs","createThirdPartyLibsFeature","environment","createEnvironmentFeature","clipboard","createClipboardFeature","DEFAULT_FEATURES","resolveFeatures","features","reduce","resolvedFeatures","identifier","feature","creator","warn","error","name","push","resolveFeatureConfigs","configs","entries","Object","config","undefined","initializeDebugToolkit","featuresOrOptions","options","enabled","doraemonProductId","Array","isArray","toolkit","DebugToolkit","getInstance","setEnabled","reset","NativeDebugLibs","installDoraemonKit","replaceFeatures","hasFeatures","showPanel","hidePanel"],"sourceRoot":"../../src","sources":["initialize.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_DebugToolkit","require","_NetworkFeature","_ConsoleLogFeature","_ZustandLogFeature","_NavigationLogFeature","_TrackFeature","_EnvironmentFeature","_ClipboardFeature","isDebugMode","__DEV__","featureRegistry","network","createNetworkFeature","console","createConsoleLogFeature","zustand","createZustandLogFeature","navigation","createNavigationLogFeature","track","createTrackFeature","environment","createEnvironmentFeature","clipboard","createClipboardFeature","DEFAULT_FEATURES","resolveFeatureConfigs","configs","features","entries","Object","name","config","creator","warn","undefined","push","resolveDefaultFeatures","map","initializeDebugToolkit","options","enabled","resolvedFeatures","DebugToolkit","setEnabled","reset","replaceFeatures","hasFeatures","showPanel","hidePanel","error"],"sourceRoot":"../../src","sources":["initialize.ts"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,eAAA,GAAAD,OAAA;AAEA,IAAAE,kBAAA,GAAAF,OAAA;AAEA,IAAAG,kBAAA,GAAAH,OAAA;AAEA,IAAAI,qBAAA,GAAAJ,OAAA;AAEA,IAAAK,aAAA,GAAAL,OAAA;AAEA,IAAAM,mBAAA,GAAAN,OAAA;AACA,IAAAO,iBAAA,GAAAP,OAAA;AAGA,MAAMQ,WAAW,GAAGC,OAAO;;AAE3B;;AAgBA;AACA;AACA;AACA,MAAMC,eAA8E,GAAG;EACrFC,OAAO,EAAEC,oCAAoB;EAC7BC,OAAO,EAAEC,0CAAuB;EAChCC,OAAO,EAAEC,0CAAuB;EAChCC,UAAU,EAAEC,gDAA0B;EACtCC,KAAK,EAAEC,gCAAkB;EACzBC,WAAW,EAAEC,4CAAwB;EACrCC,SAAS,EAAEC;AACb,CAAC;AAED,MAAMC,gBAAsC,GAAG,CAC7C,SAAS,EACT,SAAS,EACT,YAAY,EACZ,SAAS,EACT,OAAO,EACP,WAAW,CACZ;AAED,SAASC,qBAAqBA,CAACC,OAAuB,EAAqB;EACzE,MAAMC,QAA2B,GAAG,EAAE;EACtC,MAAMC,OAAO,GAAGC,MAAM,CAACD,OAAO,CAACF,OAAO,CAAoC;EAE1E,KAAK,MAAM,CAACI,IAAI,EAAEC,MAAM,CAAC,IAAIH,OAAO,EAAE;IACpC,IAAIG,MAAM,KAAK,KAAK,EAAE;IAEtB,MAAMC,OAAO,GAAGvB,eAAe,CAACqB,IAAI,CAAC;IACrC,IAAI,CAACE,OAAO,EAAE;MACZpB,OAAO,CAACqB,IAAI,CAAC,oCAAoCH,IAAI,GAAG,CAAC;MACzD;IACF;IAEA,IAAIC,MAAM,KAAK,IAAI,IAAIA,MAAM,KAAKG,SAAS,EAAE;MAC3CP,QAAQ,CAACQ,IAAI,CAACH,OAAO,CAAC,CAAC,CAAC;IAC1B,CAAC,MAAM,IAAI,OAAOD,MAAM,KAAK,QAAQ,EAAE;MACrCJ,QAAQ,CAACQ,IAAI,CAACH,OAAO,CAACD,MAAiC,CAAC,CAAC;IAC3D;EACF;EAEA,OAAOJ,QAAQ;AACjB;AAEA,SAASS,sBAAsBA,CAAA,EAAsB;EACnD,OAAOZ,gBAAgB,CAACa,GAAG,CAAEP,IAAI,IAAKrB,eAAe,CAACqB,IAAI,CAAC,CAAE,CAAC,CAAC;AACjE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASQ,sBAAsBA,CACpCC,OAA2B,EACN;EACrB,MAAMC,OAAO,GAAGD,OAAO,EAAEC,OAAO,IAAIjC,WAAW;EAE/C,MAAMkC,gBAAgB,GAAGF,OAAO,EAAEZ,QAAQ,GACtCF,qBAAqB,CAACc,OAAO,CAACZ,QAAQ,CAAC,GACvCS,sBAAsB,CAAC,CAAC;EAE5B,IAAI;IACFM,0BAAY,CAACC,UAAU,CAACH,OAAO,CAAC;IAEhC,IAAI,CAACA,OAAO,EAAE;MACZE,0BAAY,CAACE,KAAK,CAAC,CAAC;MACpB,OAAOF,0BAAY;IACrB;IAEAA,0BAAY,CAACG,eAAe,CAACJ,gBAAgB,CAAC;IAE9C,IAAIC,0BAAY,CAACI,WAAW,CAAC,CAAC,EAAE;MAC9BJ,0BAAY,CAACK,SAAS,CAAC,CAAC;IAC1B,CAAC,MAAM;MACLL,0BAAY,CAACM,SAAS,CAAC,CAAC;IAC1B;IAEA,OAAON,0BAAY;EACrB,CAAC,CAAC,OAAOO,KAAK,EAAE;IACdrC,OAAO,CAACqC,KAAK,CAAC,uCAAuC,EAAEA,KAAK,CAAC;IAC7D,OAAOP,0BAAY;EACrB;AACF","ignoreList":[]}

package/lib/commonjs/interceptors/networkInterceptor.js

@@ -0,0 +1,466 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetInterceptors = resetInterceptors;
+exports.setupAxios = setupAxios;
+exports.startFetch = startFetch;
+exports.startXMLHttpRequest = startXMLHttpRequest;
+var _urlRewriterRegistry = require("../utils/urlRewriterRegistry");
+// ─── Axios types ───────────────────────────────────────
+
+// ─── XMLHttpRequest types ─────────────────────────────
+
+// ─── Shared helpers ────────────────────────────────────
+
+function rewriteUrl(url) {
+  const rewriter = _urlRewriterRegistry.urlRewriter.get();
+  if (!rewriter) {
+    return url;
+  }
+  try {
+    return rewriter(url);
+  } catch {
+    return url;
+  }
+}
+function headersToObject(headers) {
+  const result = {};
+  if (!headers) {
+    return result;
+  }
+  if (typeof headers.forEach === 'function') {
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  Object.keys(headers).forEach(key => {
+    result[key] = headers[key];
+  });
+  return result;
+}
+function getRequestSnapshot(input, init) {
+  const request = input instanceof Request ? input : null;
+  return {
+    url: typeof input === 'string' ? input : request?.url ?? String(input),
+    method: (init?.method || request?.method || 'GET').toUpperCase(),
+    headers: init?.headers ? headersToObject(init.headers) : request?.headers ? headersToObject(request.headers) : undefined,
+    body: init?.body
+  };
+}
+async function parseResponseBody(response) {
+  const raw = await response.clone().text();
+  if (!raw) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseMaybeJson(raw) {
+  if (!raw) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseRawHeaders(rawHeaders) {
+  if (!rawHeaders) {
+    return undefined;
+  }
+  const headers = {};
+  rawHeaders.split(/\r?\n/).forEach(line => {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex <= 0) {
+      return;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+    if (!key) {
+      return;
+    }
+    headers[key] = value;
+  });
+  return Object.keys(headers).length > 0 ? headers : undefined;
+}
+function getXMLHttpRequestConstructor() {
+  const globalWithXhr = globalThis;
+  const candidate = globalWithXhr.XMLHttpRequest;
+  if (typeof candidate !== 'function') {
+    return undefined;
+  }
+  const prototype = candidate.prototype;
+  if (!prototype || typeof prototype.open !== 'function' || typeof prototype.send !== 'function') {
+    return undefined;
+  }
+  return candidate;
+}
+function getXhrResponseHeaders(xhr) {
+  if (typeof xhr.getAllResponseHeaders !== 'function') {
+    return undefined;
+  }
+  try {
+    return parseRawHeaders(xhr.getAllResponseHeaders());
+  } catch {
+    return undefined;
+  }
+}
+function getXhrResponseData(xhr) {
+  const responseType = typeof xhr.responseType === 'string' ? xhr.responseType : '';
+  if (responseType === 'json') {
+    return xhr.response;
+  }
+  if (responseType && responseType !== 'text') {
+    return undefined;
+  }
+  try {
+    if (typeof xhr.responseText === 'string') {
+      return parseMaybeJson(xhr.responseText);
+    }
+  } catch {
+    return undefined;
+  }
+  return typeof xhr.response === 'string' ? parseMaybeJson(xhr.response) : xhr.response;
+}
+
+// ─── Interceptor manager (encapsulated mutable state) ──
+
+let originalFetch = null;
+let fetchRefCount = 0;
+const pendingAxiosRequests = new WeakMap();
+const axiosRegistrations = new WeakMap();
+let originalXMLHttpRequest = null;
+let xhrRefCount = 0;
+const pendingXhrRequests = new WeakMap();
+function stopFetch() {
+  fetchRefCount = Math.max(0, fetchRefCount - 1);
+  if (fetchRefCount === 0 && originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+}
+function startFetch(emit) {
+  fetchRefCount += 1;
+  if (originalFetch) {
+    return () => {
+      stopFetch();
+    };
+  }
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = async function interceptedFetch(input, init) {
+    const startTime = Date.now();
+    let rewrittenInput = input;
+    if (_urlRewriterRegistry.urlRewriter.get()) {
+      if (typeof input === 'string') {
+        rewrittenInput = rewriteUrl(input);
+      } else if (input instanceof Request) {
+        rewrittenInput = new Request(rewriteUrl(input.url), input);
+      }
+    }
+    const request = getRequestSnapshot(rewrittenInput, init);
+    try {
+      const response = await originalFetch.call(globalThis, rewrittenInput, init);
+      const duration = Date.now() - startTime;
+      try {
+        const data = await parseResponseBody(response);
+        emit({
+          timestamp: startTime,
+          duration,
+          request,
+          response: {
+            status: response.status,
+            statusText: response.statusText,
+            data
+          }
+        });
+      } catch {
+        emit({
+          timestamp: startTime,
+          duration,
+          request,
+          response: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        });
+      }
+      return response;
+    } catch (error) {
+      emit({
+        timestamp: startTime,
+        duration: Date.now() - startTime,
+        request,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  };
+  return () => {
+    stopFetch();
+  };
+}
+function emitXhrLog(xhr, emit, error) {
+  const pending = pendingXhrRequests.get(xhr);
+  if (!pending) {
+    return;
+  }
+  const status = typeof xhr.status === 'number' ? xhr.status : 0;
+  const statusText = typeof xhr.statusText === 'string' ? xhr.statusText : undefined;
+  emit({
+    timestamp: pending.timestamp,
+    duration: Date.now() - pending.startTime,
+    request: {
+      url: pending.url,
+      method: pending.method,
+      headers: Object.keys(pending.headers).length > 0 ? pending.headers : undefined,
+      body: pending.body
+    },
+    response: error ? undefined : {
+      status,
+      statusText,
+      headers: getXhrResponseHeaders(xhr),
+      data: getXhrResponseData(xhr),
+      success: status >= 200 && status < 300
+    },
+    error
+  });
+  pendingXhrRequests.delete(xhr);
+}
+function isXhrDone(xhr) {
+  return typeof xhr.readyState === 'number' && xhr.readyState === (xhr.DONE ?? 4);
+}
+function attachXhrCompletion(xhr, emit) {
+  let completed = false;
+  const finish = error => {
+    if (completed) {
+      return;
+    }
+    completed = true;
+    if (typeof xhr.removeEventListener === 'function') {
+      xhr.removeEventListener('loadend', onLoadEnd);
+      xhr.removeEventListener('error', onError);
+      xhr.removeEventListener('abort', onAbort);
+      xhr.removeEventListener('timeout', onTimeout);
+    }
+    emitXhrLog(xhr, emit, error);
+  };
+  const onLoadEnd = () => finish();
+  const onError = () => finish('XMLHttpRequest error');
+  const onAbort = () => finish('XMLHttpRequest aborted');
+  const onTimeout = () => finish('XMLHttpRequest timeout');
+  if (typeof xhr.addEventListener === 'function') {
+    xhr.addEventListener('loadend', onLoadEnd);
+    xhr.addEventListener('error', onError);
+    xhr.addEventListener('abort', onAbort);
+    xhr.addEventListener('timeout', onTimeout);
+    return;
+  }
+  const originalOnReadyStateChange = xhr.onreadystatechange;
+  const originalOnLoadEnd = xhr.onloadend;
+  xhr.onreadystatechange = function interceptedReadyStateChange(event) {
+    originalOnReadyStateChange?.call(this, event);
+    if (isXhrDone(this)) {
+      finish();
+    }
+  };
+  xhr.onloadend = function interceptedLoadEnd(event) {
+    originalOnLoadEnd?.call(this, event);
+    finish();
+  };
+}
+function stopXMLHttpRequest() {
+  xhrRefCount = Math.max(0, xhrRefCount - 1);
+  if (xhrRefCount === 0 && originalXMLHttpRequest) {
+    const prototype = originalXMLHttpRequest.constructor.prototype;
+    prototype.open = originalXMLHttpRequest.open;
+    prototype.send = originalXMLHttpRequest.send;
+    if (originalXMLHttpRequest.setRequestHeader) {
+      prototype.setRequestHeader = originalXMLHttpRequest.setRequestHeader;
+    }
+    originalXMLHttpRequest = null;
+  }
+}
+function startXMLHttpRequest(emit) {
+  xhrRefCount += 1;
+  if (originalXMLHttpRequest) {
+    return () => {
+      stopXMLHttpRequest();
+    };
+  }
+  const XMLHttpRequestConstructor = getXMLHttpRequestConstructor();
+  if (!XMLHttpRequestConstructor) {
+    return () => {
+      stopXMLHttpRequest();
+    };
+  }
+  const prototype = XMLHttpRequestConstructor.prototype;
+  const originalOpen = prototype.open;
+  const originalSend = prototype.send;
+  const originalSetRequestHeader = prototype.setRequestHeader;
+  originalXMLHttpRequest = {
+    constructor: XMLHttpRequestConstructor,
+    open: originalOpen,
+    send: originalSend,
+    setRequestHeader: originalSetRequestHeader
+  };
+  prototype.open = function interceptedOpen(method, url, async, username, password) {
+    const rewrittenUrl = _urlRewriterRegistry.urlRewriter.get() ? rewriteUrl(url) : url;
+    const now = Date.now();
+    pendingXhrRequests.set(this, {
+      method: method.toUpperCase(),
+      url: rewrittenUrl,
+      headers: {},
+      startTime: now,
+      timestamp: now
+    });
+    if (typeof password !== 'undefined') {
+      return originalOpen.call(this, method, rewrittenUrl, async, username, password);
+    }
+    if (typeof username !== 'undefined') {
+      return originalOpen.call(this, method, rewrittenUrl, async, username);
+    }
+    if (typeof async !== 'undefined') {
+      return originalOpen.call(this, method, rewrittenUrl, async);
+    }
+    return originalOpen.call(this, method, rewrittenUrl);
+  };
+  if (originalSetRequestHeader) {
+    prototype.setRequestHeader = function interceptedSetRequestHeader(name, value) {
+      const pending = pendingXhrRequests.get(this);
+      if (pending) {
+        pending.headers[name] = value;
+      }
+      return originalSetRequestHeader.call(this, name, value);
+    };
+  }
+  prototype.send = function interceptedSend(body) {
+    const pending = pendingXhrRequests.get(this);
+    if (pending) {
+      const now = Date.now();
+      pending.body = body;
+      pending.startTime = now;
+      pending.timestamp = now;
+      attachXhrCompletion(this, emit);
+    }
+    try {
+      return originalSend.call(this, body);
+    } catch (error) {
+      emitXhrLog(this, emit, error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  };
+  return () => {
+    stopXMLHttpRequest();
+  };
+}
+function teardownAxios(axiosInstance) {
+  const registration = axiosRegistrations.get(axiosInstance);
+  if (!registration) {
+    return;
+  }
+  registration.refCount -= 1;
+  if (registration.refCount > 0) {
+    return;
+  }
+  if (typeof registration.requestId === 'number') {
+    axiosInstance.interceptors.request.eject?.(registration.requestId);
+  }
+  if (typeof registration.responseId === 'number') {
+    axiosInstance.interceptors.response.eject?.(registration.responseId);
+  }
+  axiosRegistrations.delete(axiosInstance);
+}
+function setupAxios(axiosInstance, emit) {
+  const existing = axiosRegistrations.get(axiosInstance);
+  if (existing) {
+    existing.refCount += 1;
+    return () => {
+      teardownAxios(axiosInstance);
+    };
+  }
+  const requestId = axiosInstance.interceptors.request.use(config => {
+    if (_urlRewriterRegistry.urlRewriter.get() && config.url) {
+      const fullUrl = config.baseURL ? `${config.baseURL}${config.url}` : config.url;
+      const rewritten = rewriteUrl(fullUrl);
+      if (rewritten !== fullUrl) {
+        if (config.baseURL && rewritten.startsWith(config.baseURL)) {
+          config.url = rewritten.slice(config.baseURL.length);
+        } else {
+          config.baseURL = '';
+          config.url = rewritten;
+        }
+      }
+    }
+    pendingAxiosRequests.set(config, {
+      startTime: Date.now(),
+      timestamp: Date.now()
+    });
+    return config;
+  }, error => Promise.reject(error));
+  const responseId = axiosInstance.interceptors.response.use(response => {
+    const pending = pendingAxiosRequests.get(response.config);
+    if (pending) {
+      emit({
+        timestamp: pending.timestamp,
+        duration: Date.now() - pending.startTime,
+        request: {
+          url: `${response.config.baseURL || ''}${response.config.url}`,
+          method: (response.config.method || 'GET').toUpperCase(),
+          headers: response.config.headers,
+          body: response.config.data || response.config.params
+        },
+        response: {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+          data: response.data,
+          success: response.data && typeof response.data === 'object' ? response.data.success !== false : response.status >= 200 && response.status < 300
+        }
+      });
+      pendingAxiosRequests.delete(response.config);
+    }
+    return response;
+  }, error => {
+    if (error.config) {
+      const pending = pendingAxiosRequests.get(error.config);
+      emit({
+        timestamp: pending ? pending.timestamp : Date.now(),
+        duration: pending ? Date.now() - pending.startTime : undefined,
+        request: {
+          url: `${error.config.baseURL || ''}${error.config.url}`,
+          method: (error.config.method || 'GET').toUpperCase(),
+          headers: error.config.headers,
+          body: error.config.data || error.config.params
+        },
+        error: error.message
+      });
+      pendingAxiosRequests.delete(error.config);
+    }
+    return Promise.reject(error);
+  });
+  axiosRegistrations.set(axiosInstance, {
+    refCount: 1,
+    requestId: typeof requestId === 'number' ? requestId : undefined,
+    responseId: typeof responseId === 'number' ? responseId : undefined
+  });
+  return () => {
+    teardownAxios(axiosInstance);
+  };
+}
+function resetInterceptors() {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+  fetchRefCount = 0;
+  xhrRefCount = 1;
+  stopXMLHttpRequest();
+}
+//# sourceMappingURL=networkInterceptor.js.map