Reqwise React 🚀

Reqwise is a powerful, production-ready React panel that captures, logs, and visualizes HTTP API requests within React applications.

It operates like a mini Postman or Chrome DevTools Network embedded directly in your React app. Developers can inspect requests in real-time, analyze API endpoints, filter by source client (🟢 Custom, 🔵 Axios, 🔴 Reqwise), and send manual test requests—all with a single keyboard shortcut.

Version: 1.3.5 | Status: Production Ready | React: 17+

🎯 Main Use Case

Install, import, use. No setup required.

import { ReqwisePanel, ReqwiseClient } from 'reqwise-react'
import { MyHttpClient } from './clients'
import axios from 'axios'

// Three sources, one panel
const customClient = new MyHttpClient()
const axiosClient = axios.create({ baseURL: 'https://api.example.com' })

export default function App() {
  useEffect(() => {
    ReqwiseClient.get('/users')            // 🔴 Reqwise badge
    axiosClient.get('/posts')              // 🔵 Axios badge
    customClient.get('/comments')          // 🟢 Custom badge
  }, [])

  return (
    <>
      {/* Panel shows all 3 sources with color-coded badges */}
      <ReqwisePanel 
        httpClient={customClient}
        axiosInstance={axiosClient}
      />
      {/* Or use ReqwiseClient alone for zero-config */}
      {/* <ReqwisePanel /> */}
    </>
  )
}

That's it! Press Ctrl+Shift+E to open the panel. See requests, filter by source, inspect details.

✨ Core Features

🔄 HTTP Interception & Logging

• Full HTTP Capture: Automatically logs all request/response payloads (method, URL, headers, body, status, duration)
• Multi-Source Support: Track requests from 3 different sources:
  • 🟢 Custom HTTP Clients - Any HTTP client via httpClient prop
  • 🔵 Axios Instances - Axios interceptor-based tracking
  • 🔴 ReqwiseClient - Built-in production HTTP client
• Request Timing: Precise measurement of round-trip duration for performance analysis
• Error Tracking: Captures network errors, timeouts, and HTTP error responses with stack traces

💾 Smart Persistence

• localStorage Integration: Stores all request history under reqwise_history_v1 key
• In-Memory Mode: Optional in-memory storage without localStorage pollution (for restricted environments)
• Auto-Cleanup: Configurable maxItems limit with oldest-first eviction strategy
• TTL Support: Automatic deletion of entries older than configurable historyTTL (in days)

🛡️ Security & Privacy

• Header Masking: Redact sensitive headers like Authorization, Cookie, X-API-Key
• Field Masking: Obfuscate nested JSON fields like password, token, ssn, cvv
• Smart Ignore Patterns: Skip unwanted URLs with regex/substring matching
• No Data Transmission: All data stays local; no external calls made

🌍 Internationalization (i18n)

• 15 Languages Built-in: English, Turkish, Azerbaijani, Russian, German, French, Spanish, Portuguese, Chinese, Japanese, Arabic, Korean, Italian, Polish, Dutch
• Runtime Switching: Language selector in the panel
• Smart Detection: Auto-detects browser language

⌨️ Keyboard & Hotkey Support

• Customizable Hotkeys: Toggle panel with keyboard shortcut (default: ctrl+shift+e)
• Cross-platform: Works on Windows, Mac, Linux

🎨 UI & UX Enhancements

• 4 Tabbed Interface:
  • Current Tab: Requests from current page
  • History Tab: All captured requests with filtering (method, status, page, source)
  • Send Tab: Mini HTTP client — compose and send test requests
  • Endpoints Tab: Auto-discovered API endpoints with statistics (hit count, methods, params, examples)
• Placement Flexibility: 4 positions (top, right, bottom, left) — sidebars or drawers
• Theme Support: Dark, Light, and System (prefers-color-scheme) themes
• Responsive Sizing: 4 size presets (sm: 320px, md: 420px, lg: 560px, full: 100%)
• Opacity Control: Semi-transparent panels with configurable opacity (0.0–1.0) and backdrop blur
• Request Cards: Compact view (method + URL + status + duration) or detailed view with collapsible sections

🔍 Filtering & Search

• Method Filter: GET, POST, PUT, PATCH, DELETE
• Status Filter: All, Success (2xx), Client Errors (4xx), Server Errors (5xx)
• Page Filter: View requests by page (useful in SPAs)
• Source Filter: Auto-captured vs. manual (Send tab) requests
• Client Source Filter: Filter by 🟢 Custom, 🔵 Axios, or 🔴 Reqwise clients
• URL Search: Text filter by URL patterns

📊 Endpoint Intelligence

• Auto-Discovery: Learns all API endpoints from captured requests
• Statistics: Per-endpoint hit count, HTTP methods, parameter types
• Example Collection: Stores real-world parameter examples

📤 Advanced Features

• Callback Hooks:
  • onRequest(entry) — fires when request starts
  • onResponse(entry) — fires on successful response
  • onError(entry) — fires on HTTP error
• Request Grouping: Group by URL, method, status, or page
• Highlight Mode: Highlight error or slow requests

📦 Installation

npm install reqwise-react axios
# or
pnpm add reqwise-react axios

Note: Axios is optional but recommended for auto-capture. You can use Reqwise without it via manual recording.

📖 ReqwiseClient Guide

ReqwiseClient is the built-in, production-ready HTTP client. It comes pre-configured for logging.

import { ReqwiseClient } from 'reqwise-react'

// All methods automatically logged
ReqwiseClient.get(url, config?)
ReqwiseClient.post(url, data?, config?)
ReqwiseClient.put(url, data?, config?)
ReqwiseClient.patch(url, data?, config?)
ReqwiseClient.delete(url, config?)

// Returns: Promise<{data, status}>
const res = await ReqwiseClient.get('/users')
console.log(res.data, res.status)

Requests appear in the panel with a 🔴 Reqwise badge.

🚀 Quick Start

Zero Config (Fastest)

import { ReqwisePanel, ReqwiseClient } from 'reqwise-react'

export default function App() {
  useEffect(() => {
    ReqwiseClient.get('/users')  // Logged automatically
  }, [])

  return <ReqwisePanel />
}

With Custom HTTP Client

import { ReqwisePanel } from 'reqwise-react'
import { MyHttpClient } from './clients'

const client = new MyHttpClient()

export default function App() {
  return <ReqwisePanel httpClient={client} />
  // client.get('/users') → 🟢 Custom badge
}

With Axios Instance

import { ReqwisePanel } from 'reqwise-react'
import axios from 'axios'

const api = axios.create({ baseURL: 'https://api.example.com' })

export default function App() {
  return <ReqwisePanel axiosInstance={api} />
  // api.get('/users') → 🔵 Axios badge
}

All Three Together

import { ReqwisePanel, ReqwiseClient } from 'reqwise-react'
import axios from 'axios'
import { CustomClient } from './clients'

export default function App() {
  const axiosApi = axios.create()
  const customApi = new CustomClient()

  return (
    <ReqwisePanel 
      httpClient={customApi}        // 🟢 Custom
      axiosInstance={axiosApi}      // 🔵 Axios
      // ReqwiseClient built-in      // 🔴 Reqwise
    />
  )
}

Advanced Configuration

import { ReqwisePanel, ReqwiseClient } from 'reqwise-react'

export default function App() {
  return (
    <ReqwisePanel
      enabled={process.env.NODE_ENV === 'development'}
      placement="right"
      theme="dark"
      show="detailed"
      size="lg"
      defaultOpen={false}
      maxItems={500}
      persistHistory={true}
      hotkey="ctrl+shift+e"
      langs={['en', 'tr']}
      defaultLang="en"
      ignore={['/health', '/ping']}
      maskHeaders={['Authorization', 'X-API-Key']}
      maskFields={['password', 'token', 'secret']}
      groupBy="url"
      highlight="error"
      onRequest={(e) => {
        console.log(`Request: ${e.method} ${e.url}`)
        console.log(`Source: ${e.clientSource}`)  // custom, axios, or reqwise
      }}
      onResponse={(e) => {
        console.log(`Response: ${e.status} (${e.duration}ms)`)
        console.log(`Source: ${e.clientSource}`)
      }}
      onError={(e) => {
        console.error(`Error: ${e.status} ${e.url}`)
        console.error(`Source: ${e.clientSource}`)
      }}
    />
  )
}

Props API

Core Configuration

| Prop | Type | Default | Description | |------|------|---------|-------------| | httpClient | HttpClient | - | Custom HTTP client to monitor (for multi-source tracking) | | axiosInstance | AxiosInstance | - | Axios instance to monitor (backward compatible) | | enableCustomClient | boolean | true | Enable/disable custom client tracking | | enableAxiosInstance | boolean | true | Enable/disable Axios instance tracking | | enableReqwiseClient | boolean | true | Enable/disable ReqwiseClient tracking | | enabled | boolean | true | Enable/disable panel | | placement | 'left' | 'right' | 'top' | 'bottom' | 'right' | Panel position | | defaultOpen | boolean | false | Open on mount | | theme | 'dark' | 'light' | 'system' | 'system' | Color theme | | hotkey | string | 'ctrl+shift+e' | Keyboard shortcut to toggle |

Display Options

| Prop | Type | Default | Description | |------|------|---------|-------------| | show | 'general' | 'detailed' | 'general' | Request card detail level | | size | 'sm' | 'md' | 'lg' | 'full' | 'md' | Panel size | | opacity | number | 1 | Panel opacity (0-1) |

Data Management

| Prop | Type | Default | Description | |------|------|---------|-------------| | maxItems | number | 500 | Max requests to store | | persistHistory | boolean | true | Save to localStorage | | ignore | string[] | [] | URL patterns to ignore | | maskHeaders | string[] | [] | Headers to mask | | maskFields | string[] | [] | JSON fields to mask |

Grouping & Highlighting

| Prop | Type | Default | Description | |------|------|---------|-------------| | groupBy | 'url' | 'method' | 'status' | 'page' | - | Group requests by | | highlight | 'error' | 'slow' | 'error' | Highlight type |

Localization

| Prop | Type | Default | Description | |------|------|---------|-------------| | langs | string[] | ['en'] | Supported languages | | defaultLang | string | 'en' | Initial language |

Callbacks

| Prop | Type | Description | |------|------|-------------| | onRequest | (entry) => void | Called when request starts | | onResponse | (entry) => void | Called on successful response | | onError | (entry) => void | Called on HTTP error |

🚀 Architecture Flow

Reqwise intercepts all three HTTP sources transparently:

React Application
    ↓
┌─ ReqwiseClient.get()      [🔴 Reqwise source]
├─ axiosInstance.post()     [🔵 Axios source]
└─ customClient.put()       [🟢 Custom source]
    ↓
[Capture metadata: method, URL, headers, body]
    ↓
[Mark with clientSource: 'reqwise' | 'axios' | 'custom']
    ↓
HTTP Request → Backend API
    ↓
Response received
    ↓
[Record: status, headers, body, duration]
    ↓
[Dispatch reqwise:update event with clientSource]
    ↓
[ReqwisePanel re-renders with badges]
    ↓
[Save to localStorage with source indicator]
    ↓
Application receives response

Data Lifecycle

1. Request Started → captured metadata (method, URL, headers, body)
2. HTTP Executed → Axios sends actual request
3. Response Received → status, headers, body captured
4. Callbacks Fired → onRequest → storage → onResponse/onError
5. UI Updated → panel detects new entry via custom event
6. Persistence → localStorage.setItem('reqwise_history_v1', ...)

💻 TypeScript Data Models

ReqwiseEntry

interface ReqwiseEntry {
  id: string                           // Unique ID (auto-generated)
  source: "auto" | "manual"            // auto: captured, manual: Send tab
  clientSource?: "custom" | "axios" | "reqwise"  // HTTP client source
  page: string                         // window.location.href at capture time
  timestamp: string                    // ISO 8601 timestamp
  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"
  url: string                          // Full URL or relative path
  params?: Record<string, unknown>     // Query parameters
  requestHeaders?: Record<string, string>
  requestBody?: unknown                // JSON or FormData
  status?: number                      // HTTP status (200, 404, 500, etc.)
  statusText?: string                  // Status text ("OK", "Not Found", etc.)
  responseHeaders?: Record<string, string>
  responseBody?: unknown               // Response JSON/text
  duration?: number                    // Round-trip time in milliseconds
  error?: { message: string; stack?: string }
}

ReqwiseConfig

interface ReqwiseConfig {
  // Multi-Source Clients
  httpClient?: HttpClient                          // Custom HTTP client (🟢 Custom)
  axiosInstance?: unknown                          // Axios instance (🔵 Axios)
  enableCustomClient?: boolean                     // default: true
  enableAxiosInstance?: boolean                    // default: true
  enableReqwiseClient?: boolean                    // default: true

  // UI & Display
  theme?: "light" | "dark" | "system"              // default: "system"
  placement?: "top" | "right" | "bottom" | "left"  // default: "right"
  defaultOpen?: boolean                            // default: false
  show?: "general" | "detailed"                    // default: "general"
  size?: "sm" | "md" | "lg" | "full"              // default: "md"
  opacity?: number                                 // 0.0-1.0, default: 1.0

  // Control
  enabled?: boolean                                // default: true
  hotkey?: string                                  // default: "ctrl+shift+e"

  // Storage
  persistHistory?: boolean                         // default: true
  maxItems?: number                                // default: 200
  historyTTL?: number                             // TTL in days, default: undefined (no expiry)

  // Filtering
  ignore?: string[]                                // default: []
  maskHeaders?: string[]                           // default: []
  maskFields?: string[]                            // default: []

  // i18n
  langs?: SupportedLang[]                         // default: ["en"]
  defaultLang?: SupportedLang                     // Auto-detected from browser

  // Callbacks (all entries include clientSource)
  onRequest?: (entry: Partial<ReqwiseEntry>) => void
  onResponse?: (entry: ReqwiseEntry) => void
  onError?: (entry: ReqwiseEntry) => void

  // UX
  groupBy?: "url" | "method" | "status" | "page"
  highlight?: "error" | "slow" | "none"           // default: "error"
}

🎯 Use Cases

1. Development Debugging

<ReqwisePanel show="detailed" defaultOpen={true} />
// Use ReqwiseClient, Axios, or custom clients

2. API Documentation

<ReqwisePanel
  placement="right"
  size="lg"
  groupBy="url"
/>
// Auto-discovers endpoints from actual traffic

3. Performance Monitoring

<ReqwisePanel
  highlight="slow"
  onResponse={(e) => {
    if (e.duration && e.duration > 1000) {
      console.warn(`Slow ${e.clientSource}:`, e.url, `${e.duration}ms`)
    }
  }}
/>

4. Error Tracking & Analytics

<ReqwisePanel
  onError={(e) => {
    // Send to error tracking service
    errorTracker.captureException({
      status: e.status,
      url: e.url,
      source: e.clientSource,
      error: e.error?.message,
    })
  }}
/>

🔒 Security & Privacy

1. No Network Calls: Reqwise never sends data anywhere
2. Masking Works Offline: Sensitive data redacted before storage
3. Development-Only: Disable in production
4. localStorage Isolation: Uses dedicated key reqwise_history_v1
5. GDPR Friendly: TTL support for auto-deletion

🚀 Performance

• Bundle Size: ~8KB gzipped (React wrapper only)
• Runtime Overhead: <2ms per request
• Memory Usage: ~100KB for 200 entries
• No Memory Leaks: Proper cleanup on unmount

🌐 Browser Support

• Chrome/Edge 90+
• Firefox 88+
• Safari 14+
• All modern React versions (17+)

📝 TypeScript Support

Full TypeScript support with type definitions included:

import { ReqwisePanel, ReqwiseClient } from 'reqwise-react'
import type { ReqwiseEntry, ReqwiseConfig, ClientSource, HttpClient } from 'reqwise-core'
import axios from 'axios'

const api = axios.create()

const handleResponse = (entry: ReqwiseEntry) => {
  // entry.clientSource is 'custom' | 'axios' | 'reqwise'
  console.log(`${entry.clientSource}: ${entry.status} in ${entry.duration}ms`)
}

const handleError = (entry: ReqwiseEntry) => {
  const source: ClientSource = entry.clientSource || 'reqwise'
  console.error(`Error from ${source}:`, entry.error?.message)
}

export function App() {
  return (
    <ReqwisePanel
      onResponse={handleResponse}
      onError={handleError}
    />
  )
}

⚙️ Core Modules (via reqwise-core)

client.ts — HTTP Interception Engine

• initClient(config) — Initialize with configuration
• recordPartial(entry) — Record partial entry (request or response)
• wrapAxios(instance) — Setup Axios interceptors
• get/post/put/patch/delete(url, data?, config?) — HTTP methods with fallback to fetch

storage.ts — Persistent & In-Memory Storage

• initStorage(config) — Setup storage backend
• saveEntry(entry) — Save entry to memory and localStorage (if enabled)
• getEntries() — Retrieve all entries (newest first)
• subscribe(callback) — Listen for storage changes
• TTL enforcement — auto-delete entries older than historyTTL days
• Limit enforcement — keep only latest maxItems entries

filter.ts — Security & Pattern Matching

• shouldIgnore(url) — Check if URL matches ignore patterns
• maskHeaders(headers) — Redact sensitive headers with ****
• maskFields(obj) — Recursively redact nested object fields
• Pattern matching — supports regex and substring matching

panel.ts — DOM & Hotkey Management

• mount(config) — Inject panel into document.body
• unmount() — Remove panel and clean up event listeners
• open() / close() / toggle() — Panel state management
• Hotkey listener — parse and bind keyboard shortcut
• Placement handling — position panel relative to viewport
• Theme application — data-theme attribute for CSS scoping

renderer.ts — Tab System & UI Rendering

• renderTabs() — Render and switch between 4 tabs
• renderCurrent() — Show requests from current page
• renderHistory() — Show all requests with filters
• renderSendRequest() — Mini HTTP client form
• renderEndpoints() — API endpoint analytics
• Event listeners — "Send" button, tab switching, form submission

i18n.ts — Translation Catalog

• t(key, lang) — Get translated string
• setLanguage(lang) — Update active language
• getLanguage() — Get current language
• Supported languages: en, tr, az, ru, de, fr, es, pt, zh, ja, ar, ko, it, pl, nl

🔌 API Reference

ReqwisePanel Component

interface ReqwisePanelProps {
  // Multi-source HTTP clients
  httpClient?: HttpClient             // Custom HTTP client (🟢 Custom badge)
  axiosInstance?: AxiosInstance       // Axios instance (🔵 Axios badge)
  enableCustomClient?: boolean        // Enable custom client tracking (default: true)
  enableAxiosInstance?: boolean       // Enable axios tracking (default: true)
  enableReqwiseClient?: boolean       // Enable built-in client tracking (default: true)

  // UI & Display
  enabled?: boolean                   // Enable/disable panel (default: true)
  placement?: Placement               // Panel position (default: "right")
  defaultOpen?: boolean               // Open on mount (default: false)
  theme?: Theme                       // Color theme (default: "system")
  hotkey?: string                     // Keyboard shortcut (default: "ctrl+shift+e")
  show?: "general" | "detailed"       // Request card detail (default: "general")
  size?: "sm" | "md" | "lg" | "full" // Panel size (default: "md")
  opacity?: number                    // Panel opacity 0-1 (default: 1)

  // Data Management
  maxItems?: number                   // Max requests to store (default: 200)
  persistHistory?: boolean            // Save to localStorage (default: true)
  ignore?: string[]                   // URL patterns to ignore (default: [])
  maskHeaders?: string[]              // Headers to mask (default: [])
  maskFields?: string[]               // JSON fields to mask (default: [])

  // UX & Grouping
  groupBy?: "url" | "method" | "status" | "page" // Group requests by
  highlight?: "error" | "slow" | "none"          // Highlight type (default: "error")

  // Localization
  langs?: string[]                    // Supported languages (default: ["en"])
  defaultLang?: string                // Initial language (default: auto-detect)

  // Callbacks (entries include clientSource: 'custom' | 'axios' | 'reqwise')
  onRequest?: (entry: Partial<ReqwiseEntry>) => void
  onResponse?: (entry: ReqwiseEntry) => void
  onError?: (entry: ReqwiseEntry) => void
}

ReqwiseClient API

// Built-in HTTP client (🔴 Reqwise badge)
import { ReqwiseClient } from 'reqwise-react'

ReqwiseClient.get<T>(url: string, config?: RequestConfig): Promise<{data: T, status: number}>
ReqwiseClient.post<T>(url: string, data?: any, config?: RequestConfig): Promise<{data: T, status: number}>
ReqwiseClient.put<T>(url: string, data?: any, config?: RequestConfig): Promise<{data: T, status: number}>
ReqwiseClient.patch<T>(url: string, data?: any, config?: RequestConfig): Promise<{data: T, status: number}>
ReqwiseClient.delete<T>(url: string, config?: RequestConfig): Promise<{data: T, status: number}>

Backward Compatibility

// ReqwiseDevTools is an alias for ReqwisePanel
import { ReqwiseDevTools } from 'reqwise-react'  // Still works
<ReqwiseDevTools axiosInstance={api} />  // Same as <ReqwisePanel axiosInstance={api} />

Storage API Methods

// Available from reqwise-core → storage module
storage.initStorage(config?)
storage.saveEntry(entry)
storage.getEntries() // returns all entries
storage.subscribe(callback) // listen for changes

Panel Control Methods

// Available from reqwise-core → panel module
panel.open()
panel.close()
panel.toggle()
panel.isMounted()
panel.isOpen()

i18n Methods

// Available from reqwise-core → i18n module
i18n.t(key, lang?) // Get translation
i18n.setLanguage(lang) // Set active language
i18n.getLanguage() // Get current language

🌐 Supported Languages

| Code | Language | Code | Language | |------|----------|------|----------| | en | English | tr | Türkçe (Turkish) | | az | Azərbaycanca | ru | Русский (Russian) | | de | Deutsch | fr | Français | | es | Español | pt | Português | | zh | 中文 (Chinese) | ja | 日本語 (Japanese) | | ar | العربية (Arabic) | ko | 한국어 (Korean) | | it | Italiano | pl | Polski | | nl | Nederlands |

📊 Browser & Environment Support

• Node.js: 14+ (for SSR checks, no DOM operations)
• Browsers: Chrome, Firefox, Safari, Edge (all modern versions)
• React: 17+ (ReqwisePanel component)
• HTTP Clients: Axios, custom HTTP clients, ReqwiseClient
• Framework: Works with any React version 17+

🚀 Performance Considerations

• Bundle Size: ~8KB gzipped (React wrapper only; includes ~15KB core)
• Runtime Overhead: <2ms per request (timing measurement)
• Memory Usage: ~100KB for 200 entries (default limit)
• Storage: ~50KB in localStorage for 200 typical entries
• No Memory Leaks: Proper cleanup on component unmount
• Lazy Loading: Core modules load dynamically when needed

📝 Changelog

v1.3.0 (Current)

• NEW: Multi-Source HTTP Client Tracking
  • Track requests from 3 different sources: Custom HTTP Clients, Axios instances, and ReqwiseClient
  • Added httpClient prop for custom HTTP client integration
  • Added clientSource field to track origin of each request
• NEW: Client Source Badges
  • Visual indicators for request source: 🟢 Custom, 🔵 Axios, 🔴 Reqwise
  • Badges displayed on all request cards
• NEW: Source Filtering
  • Filter requests by client source in History tab
  • Combined with existing method, status, and URL filters
• NEW: ReqwisePanel Component
  • Renamed from ReqwiseDevTools (alias kept for backward compatibility)
  • Built-in ReqwiseClient for zero-config HTTP operations
• NEW: Badge & Filter Components
  • RequestBadge component for displaying source indicators
  • SourceFilter component for filtering by client source
• Improved color scheme: Green, Blue, Red badges for visual distinction

v1.2.1

• Fixed npm registry compatibility: replaced workspace:^ with explicit version for reqwise-core dependency

v1.2.0

• Fixed scroll functionality in all tabs with proper flex layout constraints
• Fixed panel sizing for top/bottom placements (100vw width)
• Fixed toggle button positioning for all placement types (left, right, top, bottom)
• Fixed panel transform directions on toggle for top/bottom placements
• Added expand/collapse buttons for request/response content in Current tab
• Fixed full-size panel button positioning (inside panel when open, outside when closed)
• Comprehensive React README documentation with core package structure
• Added Architecture Flow, TypeScript data models, and Core Modules documentation
• Added API Reference and Supported Languages to React README
• Performance Considerations and comprehensive feature documentation

v1.1.4

• Updated React README with comprehensive documentation
• Full API reference aligned with core package
• Architecture flow diagrams
• TypeScript data models documentation
• Supported languages table

v1.1.3

• Improved documentation with comprehensive examples
• Enhanced TypeScript types and interfaces
• Stable callback system (onRequest, onResponse, onError)
• TTL support for automatic history cleanup
• Better error handling and logging

v1.1.2

• Added callback hooks (onRequest, onResponse, onError)
• Introduced TTL (Time-To-Live) for history entries
• Enhanced filtering capabilities
• Improved renderer performance

v1.1.0

• Introduced Endpoints tab with auto-discovery
• Added size and opacity props
• Improved UI responsiveness

v1.0.0

• Initial React component release

📚 Resources

• Reqwise Core — Core package
• GitHub — Source code & issues

📄 License

MIT © Ali Zadeh

🤝 Contributing

Contributions are welcome! Since Reqwise React is a wrapper around reqwise-core, please refer to the main repository for contribution guidelines. Bug reports, feature requests, and pull requests are appreciated.

Reqwise makes debugging HTTP requests in React apps dramatically easier. Enjoy! 🎉