react-native-vconsole 0.3.0 → 0.4.0

package/src/core/xhrProxy.ts

@@ -2,7 +2,8 @@ import type { NetworkEntry } from '../types';
 
 type NetworkListener = (entries: NetworkEntry[]) => void;
 type InstallXhrProxyOptions = {
-  filterHosts?: string[];
+  excludeHosts?: string[];
+  excludeIp?: boolean;
 };
 
 const MAX_NETWORK_COUNT = 500;
@@ -14,6 +15,7 @@ let isInstalled = false;
 let networkId = 1;
 let OriginalXHR: typeof XMLHttpRequest | undefined;
 let ignoredHosts = new Set<string>();
+let ignoredIpHost = false;
 
 function normalizeHosts(hosts?: string[]): Set<string> {
   return new Set(
@@ -42,12 +44,102 @@ function getHostFromUrl(rawUrl: string): string | undefined {
   }
 }
 
+function getHostnameFromUrl(rawUrl: string): string | undefined {
+  if (!rawUrl) {
+    return undefined;
+  }
+
+  const isAbsoluteHttp = /^https?:\/\//i.test(rawUrl);
+  const isProtocolRelative = /^\/\//.test(rawUrl);
+  if (!isAbsoluteHttp && !isProtocolRelative) {
+    return undefined;
+  }
+
+  const normalizedUrl = isProtocolRelative ? `https:${rawUrl}` : rawUrl;
+  try {
+    return new URL(normalizedUrl).hostname.toLowerCase();
+  } catch {
+    const authority = normalizedUrl.match(/^https?:\/\/([^/?#]+)/i)?.[1];
+    if (!authority) {
+      return undefined;
+    }
+    if (authority.startsWith('[')) {
+      const endIndex = authority.indexOf(']');
+      return endIndex > 1
+        ? authority.slice(1, endIndex).toLowerCase()
+        : undefined;
+    }
+    return authority.split(':')[0]?.toLowerCase();
+  }
+}
+
+function isIpv4Address(hostname: string): boolean {
+  const segments = hostname.split('.');
+  if (segments.length !== 4) {
+    return false;
+  }
+  return segments.every((part) => {
+    if (!/^\d{1,3}$/.test(part)) {
+      return false;
+    }
+    const value = Number(part);
+    return value >= 0 && value <= 255;
+  });
+}
+
+function isIpv6Address(hostname: string): boolean {
+  return hostname.includes(':') && /^[0-9a-f:.]+$/i.test(hostname);
+}
+
+function isIpAddressHostname(hostname: string): boolean {
+  return isIpv4Address(hostname) || isIpv6Address(hostname);
+}
+
 function shouldSkipNetworkCapture(rawUrl: string): boolean {
   const host = getHostFromUrl(rawUrl);
-  if (!host) {
+  if (host && ignoredHosts.has(host)) {
+    return true;
+  }
+  if (!ignoredIpHost) {
+    return false;
+  }
+  const hostname = getHostnameFromUrl(rawUrl);
+  if (!hostname) {
+    return false;
+  }
+  return isIpAddressHostname(hostname);
+}
+
+function getErrorMessage(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return error.message || error.name;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  return undefined;
+}
+
+function isInvalidHttpUrl(rawUrl: string): boolean {
+  if (!rawUrl) {
+    return true;
+  }
+  if (/^https?:\/\//i.test(rawUrl) || /^\/\//.test(rawUrl)) {
     return false;
   }
-  return ignoredHosts.has(host);
+  if (rawUrl.startsWith('/')) {
+    return false;
+  }
+  const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(rawUrl);
+  return hasScheme || !rawUrl.includes('/');
+}
+
+function markNetworkError(entry: NetworkEntry, reason: string) {
+  entry.status = entry.status ?? 0;
+  entry.isError = true;
+  entry.errorReason = reason;
+  entry.responseHeaders = {};
+  entry.responseData = undefined;
 }
 
 function notify() {
@@ -170,10 +262,14 @@ function parseResponseData(
   return xhr.response ?? '';
 }
 
-function parseHeaders(rawHeaders: string): Record<string, string> {
+function parseHeaders(rawHeaders?: string | null): Record<string, string> {
   const result: Record<string, string> = {};
+  if (!rawHeaders) {
+    return result;
+  }
+
   rawHeaders
-    .split('\r\n')
+    .split(/\r?\n/)
     .filter(Boolean)
     .forEach((line) => {
       const splitIndex = line.indexOf(':');
@@ -187,7 +283,8 @@ function parseHeaders(rawHeaders: string): Record<string, string> {
 }
 
 export function installXhrProxy(options?: InstallXhrProxyOptions) {
-  ignoredHosts = normalizeHosts(options?.filterHosts);
+  ignoredHosts = normalizeHosts(options?.excludeHosts);
+  ignoredIpHost = options?.excludeIp === true;
 
   if (isInstalled || typeof XMLHttpRequest === 'undefined') {
     return;
@@ -259,9 +356,26 @@ export function installXhrProxy(options?: InstallXhrProxyOptions) {
 
         const finishedAt = Date.now();
         current.status = this.status;
-        current.finishedAt = finishedAt;
-        current.durationMs = finishedAt - current.startedAt;
-        current.responseHeaders = parseHeaders(this.getAllResponseHeaders());
+        current.finishedAt = current.finishedAt ?? finishedAt;
+        current.durationMs =
+          current.durationMs ?? finishedAt - current.startedAt;
+        if (current.isError) {
+          notify();
+          return;
+        }
+        try {
+          current.responseHeaders = parseHeaders(this.getAllResponseHeaders());
+        } catch {
+          current.responseHeaders = {};
+        }
+        if (this.status === 0) {
+          const reason = isInvalidHttpUrl(this._url)
+            ? `Invalid URL: ${this._url}`
+            : 'Network request failed';
+          markNetworkError(current, reason);
+          notify();
+          return;
+        }
         try {
           const parsedData = parseResponseData(this, current.responseHeaders);
           if (isPromiseLike(parsedData)) {
@@ -285,7 +399,62 @@ export function installXhrProxy(options?: InstallXhrProxyOptions) {
         notify();
       });
 
-      return super.send(body as never);
+      this.addEventListener('timeout', () => {
+        const current = entries.find((item) => item.id === this._entryId);
+        if (!current) {
+          return;
+        }
+        current.finishedAt = current.finishedAt ?? Date.now();
+        current.durationMs =
+          current.durationMs ?? current.finishedAt - current.startedAt;
+        markNetworkError(
+          current,
+          this.timeout > 0
+            ? `Request timeout (${this.timeout}ms)`
+            : 'Request timeout'
+        );
+        notify();
+      });
+
+      this.addEventListener('error', () => {
+        const current = entries.find((item) => item.id === this._entryId);
+        if (!current) {
+          return;
+        }
+        current.finishedAt = current.finishedAt ?? Date.now();
+        current.durationMs =
+          current.durationMs ?? current.finishedAt - current.startedAt;
+        const reason = isInvalidHttpUrl(this._url)
+          ? `Invalid URL: ${this._url}`
+          : 'Network request failed';
+        markNetworkError(current, reason);
+        notify();
+      });
+
+      this.addEventListener('abort', () => {
+        const current = entries.find((item) => item.id === this._entryId);
+        if (!current) {
+          return;
+        }
+        current.finishedAt = current.finishedAt ?? Date.now();
+        current.durationMs =
+          current.durationMs ?? current.finishedAt - current.startedAt;
+        markNetworkError(current, 'Request aborted');
+        notify();
+      });
+
+      try {
+        return super.send(body as never);
+      } catch (error) {
+        entry.finishedAt = Date.now();
+        entry.durationMs = entry.finishedAt - entry.startedAt;
+        const fallbackReason = isInvalidHttpUrl(this._url)
+          ? `Invalid URL: ${this._url}`
+          : 'Network request failed';
+        markNetworkError(entry, getErrorMessage(error) ?? fallbackReason);
+        notify();
+        throw error;
+      }
     }
   }
 

package/src/index.tsx

@@ -20,10 +20,6 @@ const Vconsole = NativeModules.Vconsole
       }
     );
 
-export function multiply(a: number, b: number): Promise<number> {
-  return Vconsole.multiply(a, b);
-}
-
 export function getSystemInfo(): Promise<SystemInfo> {
   return Vconsole.getSystemInfo();
 }

package/src/types.ts

@@ -17,6 +17,8 @@ export interface NetworkEntry {
   method: string;
   url: string;
   status?: number;
+  isError?: boolean;
+  errorReason?: string;
   startedAt: number;
   finishedAt?: number;
   durationMs?: number;
@@ -31,7 +33,7 @@ export interface SystemInfo {
   model: string;
   osVersion: string;
   networkType: string;
-  isNetworkReachable: boolean;
+  isNetworkReachable: string;
   totalMemory: number;
   availableMemory: number;
 }