@scirexs/fetchy 0.4.2 → 0.6.1

package/README.md

@@ -4,11 +4,11 @@
 [![JSR](https://img.shields.io/jsr/v/%40scirexs/fetchy)](https://jsr.io/@scirexs/fetchy)
 [![license](https://img.shields.io/github/license/scirexs/fetchy)](https://github.com/scirexs/fetchy/blob/main/LICENSE)
 
-A lightweight, type-safe fetch wrapper with built-in retry logic, timeout handling, and automatic body parsing.
+A lightweight, type-safe fetch wrapper with built-in retry logic, timeout handling, and automatic body parsing. Works in Deno, Node.js, and modern browsers.
 
 ## Features
 
-- **Lightweight** - Zero dependencies, works in Deno, Node.js, and browsers
+- **Lightweight** - Bundle size is ~6KB uncompressed, ~3KB gzipped, zero dependencies
 - **Simple API** - Drop-in replacement for native fetch with enhanced capabilities
 - **Timeout Support** - Configurable request timeouts with automatic cancellation
 - **Retry Logic** - Exponential backoff with Retry-After header support
@@ -16,6 +16,7 @@ A lightweight, type-safe fetch wrapper with built-in retry logic, timeout handli
 - **Bearer Token Helper** - Built-in Authorization header management
 - **Jitter Support** - Prevent thundering herd with randomized delays
 - **Automatic Body Parsing** - Automatic JSON serialization and Content-Type detection
+- **Fluent Interface** - Class-based API with both instance and static methods
 
 ## Installation
 
@@ -30,130 +31,190 @@ deno add jsr:@scirexs/fetchy
 ## Quick Start
 
 ```ts
-import { fetchy, fetchyb } from "@scirexs/fetchy";
+import { fetchy, sfetchy, Fetchy } from "@scirexs/fetchy";
 
-// Simple GET request with timeout
-const response = await fetchy("https://api.example.com/data", {
-  timeout: 10
-});
+// Simple GET request with timeout and retry
+const response = await fetchy("https://api.example.com/data");
 
-// Auto-parsed JSON response
+// Auto-parsed JSON response with safe error handling
 interface User {
   id: number;
   name: string;
 }
 
-const user = await fetchyb<User>("https://api.example.com/user/1", "json");
-console.log(user?.name);
+const user = await sfetchy<User>("https://api.example.com/user/1", { timeout: 10 }, "json");
+console.log(user.name);
+
+// Fluent API with reusable configuration
+const client = new Fetchy({
+  bearer: "token",
+  timeout: 10,
+  retry: { maxAttempts: 5 }
+});
+const data = await client.json<User>("https://api.example.com/user/1");
 ```
 
 ## API Reference
 
-### `fetchy(url, options?)`
+### `fetchy(url, options?, parse?)`
 
-Performs an HTTP request and returns the raw Response object.
+Performs an HTTP request with enhanced features. Throws errors on failure by default.
 
 #### Parameters
 
 - `url`: `string | URL | Request | null` - The request URL
 - `options`: `FetchyOptions` (optional) - Configuration options
+- `parse`: `"json" | "text" | "bytes" | "blob" | "buffer"` (optional) - Response parsing method
 
 #### Returns
 
-`Promise<Response>`; If `onError.onNative` is configured as `false`, returns `Promise<Response | null>`
+- Without `parse`: `Promise<Response>`
+- With `parse="json"`: `Promise<T>`
+- With `parse="text"`: `Promise<string>`
+- With `parse="bytes"`: `Promise<Uint8Array>`
+- With `parse="blob"`: `Promise<Blob>`
+- With `parse="buffer"`: `Promise<ArrayBuffer>`
 
 #### Example
 
 ```ts
-const response = await fetchy("https://api.example.com/data", {
-  method: "POST",
-  body: { key: "value" },
-  timeout: 10,
-  retry: { maxAttempts: 3, interval: 2 },
-  bearer: "your-token-here"
-});
+// Get Response object
+const response = await fetchy("https://api.example.com/data");
 
-if (response?.ok) {
-  const data = await response.json();
-}
+// Direct JSON parsing
+const user = await fetchy<User>("https://api.example.com/user", {}, "json");
+
+// POST with automatic body serialization
+const result = await fetchy("https://api.example.com/create", {
+  body: { name: "John", age: 30 },
+  bearer: "token"
+}, "json");
+
+// Binary data
+const image = await fetchy("https://api.example.com/image.png", {}, "bytes");
 ```
 
-### `fetchyb(url, type?, options?)`
+### `sfetchy(url, options?, parse?)`
 
-Performs an HTTP request and automatically parses the response body.
+Performs an HTTP request with safe error handling. Returns `null` on any failure instead of throwing.
 
 #### Parameters
 
-- `url`: `string | URL | Request | null` - The request URL
-- `type`: `"text" | "json" | "bytes" | "auto"` (default: `"auto"`) - Response parsing type
-- `options`: `FetchyOptions` (optional) - Configuration options
+Same as `fetchy()`.
 
 #### Returns
 
-`Promise<T | string | Uint8Array>`; If `onError.onNative` is configured as `false`, returns `Promise<T | string | Uint8Array | null>`
+Same as `fetchy()` but with `| null` added to each return type.
 
 #### Example
 
 ```ts
-// Automatic type detection from Content-Type header
-const data = await fetchyb("https://api.example.com/data");
+// Returns null instead of throwing
+const data = await sfetchy("https://api.example.com/data", {}, "json");
+if (data === null) {
+  console.log("Request failed gracefully");
+}
 
-// Explicit JSON parsing with type assertion
-interface Product {
-  id: number;
-  name: string;
-  price: number;
+// Safe Response retrieval
+const response = await sfetchy("https://api.example.com/data");
+if (response?.ok) {
+  const json = await response.json();
 }
-const product = await fetchyb<Product>("https://api.example.com/product/1", "json");
+```
 
-// Text content
-const html = await fetchyb("https://example.com", "text");
+### `Fetchy` Class
 
-// Binary data
-const image = await fetchyb("https://example.com/image.png", "bytes");
+A fluent HTTP client class that provides both instance and static methods.
+
+#### Instance Methods
+
+```ts
+const client = new Fetchy(options);
+
+// Parsing methods
+await client.fetch(url?)     // Returns Response
+await client.json<T>(url?)   // Returns T
+await client.text(url?)      // Returns string
+await client.bytes(url?)     // Returns Uint8Array
+await client.blob(url?)      // Returns Blob
+await client.buffer(url?)    // Returns ArrayBuffer
+await client.safe(url?)      // Returns Response | null
+await client.sjson<T>(url?)  // Returns T | null
+await client.stext(url?)     // Returns string | null
+await client.sbytes(url?)    // Returns Uint8Array | null
+await client.sblob(url?)     // Returns Blob | null
+await client.sbuffer(url?)   // Returns ArrayBuffer | null
 ```
 
-## Configuration
+#### Static Methods
 
-### API Options
+```ts
+// Same methods available as static
+await Fetchy.fetch(url, options?)
+await Fetchy.json<T>(url, options?)
+await Fetchy.text(url, options?)
+await Fetchy.bytes(url, options?)
+await Fetchy.blob(url, options?)
+await Fetchy.buffer(url, options?)
+await Fetchy.safe(url, options?)
+await Fetchy.sjson<T>(url, options?)
+await Fetchy.stext(url, options?)
+await Fetchy.sbytes(url, options?)
+await Fetchy.sblob(url, options?)
+await Fetchy.sbuffer(url, options?)
+```
 
-#### `FetchyOptions`
+#### Example
 
 ```ts
-interface FetchyOptions extends RequestInit {
-  // Standard fetch options (method, headers, etc.)
-  method?: string;
-  headers?: HeadersInit;
+// Instance usage - reuse configuration
+const client = new Fetchy({
+  bearer: "token123",
+  timeout: 10,
+  retry: { maxAttempts: 3 }
+});
+
+const user = await client.json<User>("https://api.example.com/user");
+const posts = await client.json<Post[]>("https://api.example.com/posts");
+
+// Static usage - one-off requests
+const data = await Fetchy.json("https://api.example.com/data");
+
+// Safe mode
+const result = await Fetchy.sjson("https://api.example.com/data");
+```
+
+## Configuration
+
+### `FetchyOptions`
+
+```ts
+interface FetchyOptions extends Omit<RequestInit, "body"> {
+  // Request URL (allows null url parameter with this option)
+  url?: string | URL;
   
   // Request body (auto-serializes JSON; ReadableStream is NOT supported)
-  // type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
   body?: JSONValue | FormData | URLSearchParams | Blob | ArrayBuffer | string;
   
-  // Timeout in seconds (default: 15)
-  timeout?: number;  // Set to 0 to disable timeout
+  // Timeout in seconds (default: 15, set to 0 to disable)
+  timeout?: number;
   
-  // Retry configuration
+  // Retry configuration (set to false to disable)
   retry?: {
-    maxAttempts?: number;  // Maximum retry attempts (default: 3)
-    interval?: number;     // Base interval in seconds (default: 3)
-    maxInterval?: number;  // Maximum interval cap in seconds (default: 30)
-    retryAfter?: boolean;  // Respect Retry-After header (default: true)
-  } | false;  // Set to false to disable retry
+    interval?: number;      // Base interval in seconds (default: 3)
+    maxInterval?: number;   // Maximum interval cap (default: 30)
+    maxAttempts?: number;   // Maximum retry attempts (default: 3)
+    retryAfter?: boolean;   // Respect Retry-After header (default: true)
+  } | false;
   
   // Bearer token (automatically adds "Bearer " prefix)
   bearer?: string;
   
-  // Error throwing behavior
-  onError?: {
-    onNative?: boolean;  // Throw on native errors (default: true)
-    onStatus?: boolean;  // Throw on 4xx/5xx status (default: false)
-  } | boolean;  // Set to true to throw on all errors
-  
-  // Initial jitter delay in seconds
+  // Initial jitter delay in seconds before request (default: 0)
   delay?: number;
-
-  // URL for fetch (allows reusing FetchyOptions as preset configuration)
-  url?: string | URL;
+  
+  // Use native fetch error behavior (no HTTPStatusError on 4xx/5xx)
+  native?: true;
 }
 ```
 
@@ -169,10 +230,7 @@ interface FetchyOptions extends RequestInit {
     maxInterval: 30,  // 30 seconds maximum interval
     retryAfter: true  // Respect Retry-After header
   },
-  onError: {
-    onNative: true,   // Throw native errors
-    onStatus: false   // Don't throw on HTTP errors
-  },
+  native: undefined   // Throws HTTPStatusError on non-OK status (4xx, 5xx)
 }
 ```
 
@@ -180,66 +238,111 @@ interface FetchyOptions extends RequestInit {
 
 #### Method
 
-If a body is provided without specifying a method, the method defaults to `"POST"`. When a Request object is passed as the `url` argument, its method is used.
+- If body is provided without method: defaults to `"POST"`
+- If Request object is passed: uses its method
+- Otherwise: defaults to `"GET"`
 
 #### Headers
 
 The following headers are automatically set if not specified:
 
 - **Accept**: `application/json, text/plain`
-- **Content-Type**: Automatically determined based on the body type:
-  - `string`, `URLSearchParams`, `FormData`, `Blob` with type: Not set by this package; [`fetch` will set it automatically](https://fetch.spec.whatwg.org/#concept-bodyinit-extract).
+- **Content-Type**: Automatically determined based on body type:
+  - `string`, `URLSearchParams`, `FormData`, `Blob` with type: Not set (native fetch handles it)
   - `JSONValue`: `application/json`
-  - `Blob` without type: `application/octet-stream`
-  - `ArrayBuffer`: `application/octet-stream` 
-- **Authorization**: Set to `Bearer ${options.bearer}` if `options.bearer` is provided.
+  - `Blob` without type, `ArrayBuffer`: `application/octet-stream`
+- **Authorization**: `Bearer ${options.bearer}` if bearer is provided
 
-**Note 1:** If you pass serialized JSON as the body (i.e., a string), Content-Type will be set to `text/plain;charset=UTF-8`. To ensure Content-Type is set to `application/json`, pass the JSON object directly instead of a serialized string.
-
-**Note 2:** If you pass a body through a Request object, Content-Type will NOT be set automatically by this package.
+**Note:** If you pass a body through a Request object, Content-Type is NOT set automatically by this package.
 
 ## Error Handling
 
-### Timeout
-
-If the timeout duration specified in the `timeout` option is exceeded, the request is aborted using the standard `AbortSignal.timeout()` method. Note that there is no specific error class for timeout errors; they will be thrown as standard `AbortError`s.
-
 ### HTTPStatusError
 
-If `onStatus` is set to `true`, an `HTTPStatusError` will be thrown when the response status is outside the 2xx range. You can access the status and body through this error object. The error message format is: `404 Not Found: (no response body)`.
+Thrown when response status is not OK (4xx, 5xx) unless `native: true` is set.
+
+```ts
+try {
+  await fetchy("https://api.example.com/data");
+} catch (error) {
+  if (error instanceof HTTPStatusError) {
+    console.error(error.status);   // 404
+    console.error(error.body);     // Response body text
+    console.error(error.message);  // "404 Not Found: (no response body)"
+  }
+}
+```
 
 ### RedirectError
 
-If `redirect` is set to `"error"`, a `RedirectError` will be thrown when the response status is in the 3xx range. You can access the status through this error object. The error message format is: `301 Moved Permanently`.
+Thrown when `redirect: "error"` is set and a redirect response (3xx) is received.
+
+```ts
+try {
+  await fetchy("https://example.com/redirect", {
+    redirect: "error"
+  });
+} catch (error) {
+  if (error instanceof RedirectError) {
+    console.error(error.status);   // 301
+    console.error(error.message);  // "301 Moved Permanently"
+  }
+}
+```
+
+### Native Errors
+
+Other errors (network failures, timeout, abort) are thrown as standard errors:
+- `TypeError`: Network error, DNS resolution failure
+- `DOMException`: Timeout or abort via AbortSignal
 
-### Other Errors
+### Safe Error Handling
 
-If the `onNative` option is set to `true`, any other errors that occur will be thrown directly.
+Use `sfetchy()` or `Fetchy.safe()` to return `null` instead of throwing:
+
+```ts
+const data = await sfetchy("https://api.example.com/data", {}, "json");
+if (data === null) {
+  // Handle error gracefully
+}
+```
+
+### Native Mode
+
+Set `native: true` to disable HTTPStatusError and get native fetch behavior:
+
+```ts
+const response = await fetchy("https://api.example.com/data", {
+  native: true
+});
+// Returns Response even for 4xx/5xx status codes
+```
 
 ## Usage Examples
 
 ### Basic Requests
 
 ```ts
-import { fetchy, fetchyb } from "@scirexs/fetchy";
+import { fetchy, sfetchy } from "@scirexs/fetchy";
 
-// GET request
-const data = await fetchyb("https://api.example.com/data", "json");
+// GET with automatic JSON parsing
+const data = await fetchy<User[]>("https://api.example.com/users", {}, "json");
 
 // POST with JSON body
-const result = await fetchyb("https://api.example.com/create", "json", {
+const result = await fetchy("https://api.example.com/create", {
   body: { name: "John", email: "john@example.com" }
-});
+}, "json");
 
 // Custom headers
 const response = await fetchy("https://api.example.com/data", {
-  headers: {
-    "X-Custom-Header": "value"
-  }
+  headers: { "X-Custom-Header": "value" }
 });
 
-// Reuse options as preset configuration (avoids Request object limitations)
-const options = { url: "https://api.example.com/data", retry: false };
+// Reuse options as preset configuration
+const options: FetchyOptions = {
+  url: "https://api.example.com/data",
+  retry: false
+};
 await fetchy(null, options);
 await fetchy(null, options);
 ```
@@ -248,16 +351,14 @@ await fetchy(null, options);
 
 ```ts
 // Bearer token authentication
-const user = await fetchyb<User>("https://api.example.com/me", "json", {
+const user = await fetchy<User>("https://api.example.com/me", {
   bearer: "your-access-token"
-});
+}, "json");
 
 // Custom authorization
-const data = await fetchyb("https://api.example.com/data", "json", {
-  headers: {
-    "Authorization": "Basic " + btoa("user:pass")
-  }
-});
+const data = await fetchy("https://api.example.com/data", {
+  headers: { "Authorization": "Basic " + btoa("user:pass") }
+}, "json");
 ```
 
 ### Timeout and Retry
@@ -269,15 +370,15 @@ const response = await fetchy("https://slow-api.example.com", {
 });
 
 // Retry with exponential backoff
-// Retry intervals: 1s, 3s (3^1), 9s (3^2), 27s (3^3), 60s (capped at maxInterval)
-const data = await fetchyb("https://api.example.com/data", "json", {
+// Intervals: 1s (3^0), 3s (3^1), 9s (3^2), 27s (3^3), capped at maxInterval
+const data = await fetchy("https://api.example.com/data", {
   retry: {
-    maxAttempts: 5,   // Retry up to 5 times
-    interval: 3,      // Base interval for exponential backoff (interval^n)
-    maxInterval: 60,  // Cap at 60 seconds
-    retryAfter: true  // Respect Retry-After header
+    maxAttempts: 5,
+    interval: 3,
+    maxInterval: 60,
+    retryAfter: true
   }
-});
+}, "json");
 
 // Disable retry
 const response = await fetchy("https://api.example.com/data", {
@@ -285,92 +386,125 @@ const response = await fetchy("https://api.example.com/data", {
 });
 ```
 
-### Error Handling
+### Error Handling Patterns
 
 ```ts
-import { fetchy, HTTPStatusError, RedirectError } from "@scirexs/fetchy";
+import { fetchy, sfetchy, HTTPStatusError, RedirectError } from "@scirexs/fetchy";
 
-// Throw on error (default behavior, same as native fetch)
+// Default: throws on error
 try {
-  const response = await fetchy("https://api.example.com/data");
+  const data = await fetchy("https://api.example.com/data", {}, "json");
 } catch (error) {
-  console.error("Request failed:", error);
+  if (error instanceof HTTPStatusError) {
+    console.error(`HTTP ${error.status}: ${error.body}`);
+  }
 }
 
-// Return null on error
+// Safe mode: returns null
+const data = await sfetchy("https://api.example.com/data", {}, "json");
+if (data === null) {
+  console.log("Request failed, using default");
+}
+
+// Native mode: no HTTPStatusError
 const response = await fetchy("https://api.example.com/data", {
-  onError: false,
+  native: true
 });
-if (response === null) {
-  console.log("Request failed");
+if (!response.ok) {
+  console.error("Request failed with status", response.status);
 }
+```
 
-// Throw only on HTTP errors
-try {
-  const response = await fetchy("https://api.example.com/data", {
-    onError: { onNative: false, onStatus: true }
-  });
-} catch (error) {
-  if (error instanceof HTTPStatusError) {
-    console.error("HTTP error:", error.message);  // e.g., "404 Not Found: (no response body)"
-    console.error("Status:", error.status);
-    console.error("Body:", error.body);
-  }
-}
+### Fluent API
 
-// Handle redirects
-try {
-  const response = await fetchy("https://example.com/redirect", {
-    redirect: "error"
-  });
-} catch (error) {
-  if (error instanceof RedirectError) {
-    console.error("Unexpected redirect:", error.message);
-    console.error("Status:", error.status);
-  }
+```ts
+// Create reusable client
+const api = new Fetchy({
+  url: "https://api.example.com",
+  bearer: "token",
+  timeout: 10,
+  retry: { maxAttempts: 3 }
+});
+
+// Instance methods
+const users = await api.json<User[]>("/users");
+const post = await api.json<Post>("/posts/1");
+const text = await api.text("/readme.txt");
+
+// Safe methods
+const data = await api.sjson("/maybe-fails");
+if (data !== null) {
+  // Process data
 }
+
+// Static methods for one-off requests
+const response = await Fetchy.fetch("https://example.com");
+const json = await Fetchy.json("https://api.example.com/data");
 ```
 
 ### Advanced Usage
 
+#### Jitter and Delays
 ```ts
 // Jitter to prevent thundering herd
 const response = await fetchy("https://api.example.com/data", {
-  delay: 2,  // Random delay up to 2 seconds before request
+  delay: 2,  // Random delay up to 2 seconds
   retry: { maxAttempts: 3 }
 });
+```
 
+#### Abort Signals
+```ts
 // Combined abort signals
-const controller1 = new AbortController();
-const controller2 = new AbortController();
+const controller = new AbortController();
 const request = new Request("https://api.example.com/data", {
-  signal: controller1.signal
+  signal: controller.signal
 });
 
-setTimeout(() => controller1.abort(), 5000);  // Abort after 5 seconds
+setTimeout(() => controller.abort(), 5000);
 
 const response = await fetchy(request, {
-  signal: controller2.signal
+  signal: AbortSignal.timeout(10000)
 });
+```
 
+#### Form Data
+```ts
 // Form data upload
 const formData = new FormData();
 formData.append("file", blob);
 formData.append("name", "example");
 
-const response = await fetchy("https://api.example.com/upload", {
+await fetchy("https://api.example.com/upload", {
   body: formData
 });
 
 // URL-encoded form
-const params = new URLSearchParams();
-params.append("key", "value");
-
-const response = await fetchy("https://api.example.com/form", {
+const params = new URLSearchParams({ key: "value" });
+await fetchy("https://api.example.com/form", {
   body: params
 });
 ```
 
+#### Testing Utilities
+
+When writing tests for code that uses `fetchy`, you may need to simulate immediate failures without triggering retry logic. Use the `NO_RETRY_ERROR` constant to bypass all retry attempts:
+```ts
+import { fetchy, NO_RETRY_ERROR } from "@scirexs/fetchy";
+
+const originalFetch = globalThis.fetch;
+globalThis.fetch = () => Promise.reject(new Error(NO_RETRY_ERROR));
+
+try {
+  await fetchy("https://api.example.com/data");
+} catch (error) {
+  // Error is thrown immediately without retries
+  console.error(error);
+} finally {
+  globalThis.fetch = originalFetch;
+}
+```
+
 ### Type-Safe API Responses
 
 ```ts
@@ -386,8 +520,9 @@ interface Todo {
   completed: boolean;
 }
 
-const response = await fetchyb<ApiResponse<Todo>>(
+const response = await fetchy<ApiResponse<Todo>>(
   "https://api.example.com/todos/1",
+  {},
   "json"
 );
 
@@ -398,34 +533,29 @@ if (response.success) {
 
 ## Limitations
 
-### Return Type Inference
+### Content-Type Header with Request Objects
 
-When setting the `onError` property in `FetchyOptions`, the return type will include `null` even if you set it to `true` or `{ onNative: true }`. To prevent this and ensure a non-nullable return type, add `as const` to the `onError` property value:
+When a body is set in a Request object, the Content-Type header is NOT set automatically by this package. Use the `url` property in `FetchyOptions` instead to benefit from automatic header configuration:
 
 ```ts
-interface User {
-  id: number;
-  name: string;
-}
-
-const options = { timeout: 5, onError: true as const };  // Add `as const`
-const response = await fetchy("https://api.example.com/todos/1", "json", options);
-// `response` is User (not User | null)
+// Instead of this:
+const request = new Request("https://api.example.com", { body: jsonData });
+await fetchy(request);
+
+// Do this:
+await fetchy(null, {
+  url: "https://api.example.com",
+  body: jsonData
+});
 ```
 
-### Content-Type Header with Request Objects
-
-When a body is set in a Request object, the Content-Type header is NOT set automatically by this package. Therefore, when using Request objects, you must explicitly set the Content-Type header for any body types other than those automatically handled by the native `fetch` API.
-
-This limitation can be avoided by using the `url` property in `FetchyOptions` instead of Request objects. This approach allows you to benefit from all automatic header configuration features while still maintaining reusable preset configurations. See the "Reuse options as preset configuration" example in the [Basic Requests](#basic-requests) section.
-
 ### ReadableStream as Body
 
 `FetchyOptions` does not accept ReadableStream as a body. If you need to use ReadableStream, create a Request object with the stream and pass it to `fetchy()`.
 
 ### Redirect Error Handling
 
-When `redirect` is set to `"error"`, this package throws a custom `RedirectError` (instead of the native TypeError) to enable proper retry handling for redirect responses.
+When `redirect` is set to `"error"`, this package throws a custom `RedirectError` (instead of native TypeError) to enable proper retry handling for redirect responses.
 
 ## License
 

package/esm/main.js

@@ -1 +1 @@
-export{m as fetchy,A as fetchyb,l as HTTPStatusError,h as RedirectError};const i={timeout:15,delay:0,interval:3,maxInterval:30,maxAttempts:3,retryAfter:!0,onNative:!0,onStatus:!1,redirect:"follow"};class l extends Error{static#t=80;status;body;constructor(e,r,n){super(e),this.name="HTTPStatusError",this.status=r,this.body=n}static async fromResponse(e){const r=await e.text(),n=r.length>this.#t?`${r.slice(0,this.#t)}... (more ${r.length-this.#t} chars)`:r||"(no response body)",a=`${e.status} ${e.statusText}: ${n}`;return new this(a,e.status,r)}}class h extends Error{status;constructor(e,r){super(e),this.name="RedirectError",this.status=r}static fromResponse(e){const r=`${e.status} ${e.statusText}`.trim();return new this(r,e.status)}}async function A(t,e="auto",r){const n=await m(t,r);if(!n||!n.ok)return null;const a=n.headers.get("Content-Type")??"";try{return e==="text"||e==="auto"&&a.startsWith("text/")?await n.text():e==="json"||e==="auto"&&a==="application/json"?await n.json():await n.bytes()}catch(s){if(o("onNative",r?.onError))throw s;return null}}async function m(t,e){try{t||(t=e?.url??new URL(""));const r=v(e),n=T(t,r,e),a=await P(t,n,r);if(!a.ok&&r.onStatus)throw await l.fromResponse(a);return a}catch(r){if(o("onNative",e?.onError))throw r;return null}}function R(t){return typeof t=="string"}function y(t){return typeof t=="number"}function d(t){return typeof t=="boolean"}function N(t){return!!(t&&typeof t=="object"&&Object.prototype.toString.call(t).slice(8,-1)==="Object"&&t.constructor===Object)}function o(t,e){return!!(e===void 0&&i[t]||typeof e=="boolean"&&e||typeof e=="object"&&(e[t]??i[t]))}function f(t,e,r=!1){return e===void 0||e<0?t:r?Math.trunc(e):e}function u(t,e,r){return d(r)?e:r===void 0||r[t]===void 0?i[t]:y(r[t])?f(i[t],r[t],t==="maxAttempts"):r[t]}function v(t){return{timeout:f(i.timeout,t?.timeout),delay:f(i.delay,t?.delay),interval:u("interval",0,t?.retry),maxInterval:u("maxInterval",0,t?.retry),maxAttempts:u("maxAttempts",0,t?.retry),retryAfter:u("retryAfter",!1,t?.retry),onStatus:o("onStatus",t?.onError),redirect:t?.redirect??i.redirect}}function T(t,e,r){const{method:n,body:a,timeout:s,retry:D,bearer:C,onError:H,delay:L,redirect:c,signal:k,...g}=r??{};return{headers:S(r),method:n||(t instanceof Request?t.method:a===void 0?"GET":"POST"),signal:I(t,e.timeout,r?.signal),...c&&{redirect:c==="error"?"manual":c},...a&&{body:E(a)},...g}}function E(t){return w(t)?JSON.stringify(t):t}function w(t){return!!(t===null||y(t)||d(t)||Array.isArray(t)||N(t))}function S(t){const e=new Headers(t?.headers);if(e.has("Accept")||e.append("Accept","application/json, text/plain"),!e.has("Content-Type")){const r=j(t?.body);r&&e.append("Content-Type",r)}return t?.bearer&&e.set("Authorization",`Bearer ${t.bearer}`),e}function j(t){if(!(t===void 0||R(t)||t instanceof FormData||t instanceof URLSearchParams)&&!(t instanceof Blob&&t.type))return w(t)?"application/json":"application/octet-stream"}function I(t,e,r){const n=[];return t instanceof Request&&t.signal&&n.push(t.signal),r&&n.push(r),e>0&&n.push(AbortSignal.timeout(e*1e3+1)),n.length?AbortSignal.any(n):void 0}async function b(t,e=!0){if(t<=0)return;const r=Math.trunc((e?Math.random():1)*t*1e3);await new Promise(n=>setTimeout(n,r))}function O(t){return t.status<400&&t.status>=300}async function x(t,e,r,n){if(t>=r.maxAttempts-1||e.signal?.aborted||n?.ok)return!0;if(n&&O(n)){if(r.redirect==="manual")return!0;if(r.redirect==="error")throw r.maxAttempts=0,h.fromResponse(n)}const a=M(t,r,n);return a>r.maxInterval?!0:(await b(a,!1),!1)}function M(t,e,r){return e.retryAfter&&r?Math.max(B(r.headers.get("Retry-After")?.trim()??""),e.interval):Math.min(Math.pow(Math.max(1,e.interval),t),e.maxInterval)}function B(t){if(!t)return 1/0;const e=Number.parseInt(t,10);if(!Number.isNaN(e))return e;const r=Math.ceil((new Date(t).getTime()-Date.now())/1e3);return Number.isNaN(r)?1/0:r}function $(t,e,r){return r.redirected?(r.status===303&&(e.method="GET"),t instanceof Request?new Request(r.url,t):r.url):t}function q(t,e){return t instanceof Request&&e?t.clone():t}async function P(t,e,r){for(let n=0;n<r.maxAttempts;n++)try{const a=q(t,n<r.maxAttempts-1),s=await _(a,e,r);if(await x(n,e,r,s))return s;t=$(t,e,s);continue}catch(a){if(await x(n,e,r))throw a;continue}return await _(t,e,r)}async function _(t,e,r){return await b(r.delay),await fetch(t,e)}
+export{v as Fetchy,i as fetchy,h as HTTPStatusError,l as NO_RETRY_ERROR,b as RedirectError,s as sfetchy};const l="$$_NO_RETRY_$$",u={timeout:15,delay:0,interval:3,maxInterval:30,maxAttempts:3,retryAfter:!0,native:!1,redirect:"follow"};class h extends Error{static#t=80;status;body;constructor(t,r,n){super(t),this.name="HTTPStatusError",this.status=r,this.body=n}static async fromResponse(t){const r=await t.text(),n=r.length>this.#t?`${r.slice(0,this.#t)}... (more ${r.length-this.#t} chars)`:r||"(no response body)",a=`${t.status} ${t.statusText}: ${n}`;return new this(a,t.status,r)}}class b extends Error{status;constructor(t,r){super(t),this.name="RedirectError",this.status=r}static fromResponse(t){const r=`${t.status} ${t.statusText}`.trim();return new this(r,t.status)}}class v{url;body;timeout;retry;bearer;delay;native;constructor(t){Object.assign(this,t)}async fetch(t){return await i(t??null,this)}async text(t){return await i(t??null,this,"text")}async json(t){return await i(t??null,this,"json")}async bytes(t){return await i(t??null,this,"bytes")}async blob(t){return await i(t??null,this,"blob")}async buffer(t){return await i(t??null,this,"buffer")}async safe(t){return await s(t??null,this)}async stext(t){return await i(t??null,this,"text")}async sjson(t){return await i(t??null,this,"json")}async sbytes(t){return await i(t??null,this,"bytes")}async sblob(t){return await i(t??null,this,"blob")}async sbuffer(t){return await i(t??null,this,"buffer")}static async fetch(t,r){return await i(t,r)}static async text(t,r){return await i(t,r,"text")}static async json(t,r){return await i(t,r,"json")}static async bytes(t,r){return await i(t,r,"bytes")}static async blob(t,r){return await i(t,r,"blob")}static async buffer(t,r){return await i(t,r,"buffer")}static async safe(t,r){return await s(t,r)}static async stext(t,r){return await s(t,r,"text")}static async sjson(t,r){return await s(t,r,"json")}static async sbytes(t,r){return await s(t,r,"bytes")}static async sblob(t,r){return await s(t,r,"blob")}static async sbuffer(t,r){return await s(t,r,"buffer")}}async function s(e,t,r){try{return await m(e,t,r)}catch{return null}}async function i(e,t,r){try{return await m(e,t,r)}catch(n){throw n}}async function m(e,t,r){e||(e=t?.url??"");const n=N(t),a=await F(e,O(e,n,t),n);if(!a.ok&&!n.native)throw await h.fromResponse(a);return r?S(a,r):a}function j(e){return typeof e=="string"}function w(e){return typeof e=="number"}function d(e){return typeof e=="boolean"}function T(e){return!!(e&&typeof e=="object"&&Object.getPrototypeOf(e)===Object.prototype)}function y(e,t,r=!1){return t===void 0||t<0?e:r?Math.trunc(t):t}function f(e,t,r){return d(r)?t:r===void 0||r[e]===void 0?u[e]:w(r[e])?y(u[e],r[e],e==="maxAttempts"):r[e]}function N(e){return{timeout:y(u.timeout,e?.timeout),delay:y(u.delay,e?.delay),interval:f("interval",0,e?.retry),maxInterval:f("maxInterval",0,e?.retry),maxAttempts:f("maxAttempts",0,e?.retry),retryAfter:f("retryAfter",!1,e?.retry),native:e?.native??u.native,redirect:e?.redirect??u.redirect}}function O(e,t,r){const{method:n,body:a,timeout:c,retry:J,bearer:L,native:Y,delay:k,redirect:o,signal:G,...A}=r??{};return{headers:$(r),method:n||(e instanceof Request?e.method:a==null?"GET":"POST"),signal:M(e,t.timeout,r?.signal),...o&&{redirect:o=="error"?"manual":o},...a&&{body:E(a)},...A}}function E(e){return x(e)?JSON.stringify(e):e}function x(e){return!!(e===null||w(e)||d(e)||Array.isArray(e)||T(e))}function $(e){const t=new Headers(e?.headers);if(t.has("Accept")||t.set("Accept","application/json, text/plain"),!t.has("Content-Type")){const r=I(e?.body);r&&t.append("Content-Type",r)}return e?.bearer&&t.set("Authorization",`Bearer ${e.bearer}`),t}function I(e){if(!(e==null||j(e)||e instanceof FormData||e instanceof URLSearchParams)&&!(e instanceof Blob&&e.type))return x(e)?"application/json":"application/octet-stream"}function M(e,t,r){const n=[];return e instanceof Request&&e.signal&&n.push(e.signal),r&&n.push(r),t>0&&n.push(AbortSignal.timeout(t*1e3+1)),n.length?AbortSignal.any(n):void 0}async function S(e,t){switch(t){case"json":return await e.json();case"text":return await e.text();case"bytes":return await e.bytes();case"blob":return await e.blob();case"buffer":return await e.arrayBuffer()}}async function _(e,t=!0){if(e<=0)return;const r=Math.trunc((t?Math.random():1)*e*1e3);await new Promise(n=>setTimeout(n,r))}function B(e){return e.status<400&&e.status>=300}function q(e){return e.status<500&&e.status>=400}async function R(e,t,r,n){if(e>=r.maxAttempts-1||t.signal?.aborted)return!0;if(n){if(n.ok||q(n)||r.native)return!0;if(B(n)){if(r.redirect=="manual")return!0;if(r.redirect=="error")throw r.maxAttempts=0,b.fromResponse(n)}}const a=P(e,r,n);return a>r.maxInterval?!0:(await _(a,!1),!1)}function P(e,t,r){return t.retryAfter&&r?.headers.has("Retry-After")?Math.max(D(r.headers.get("Retry-After")?.trim()??""),t.interval):Math.min(Math.pow(Math.max(1,t.interval),e),t.maxInterval)}function D(e){if(!e)return 1/0;const t=Number.parseInt(e,10);if(!Number.isNaN(t))return t;const r=Math.ceil((new Date(e).getTime()-Date.now())/1e3);return Number.isNaN(r)?1/0:r}function C(e,t,r){return r.redirected?(r.status==303&&(t.method="GET"),e instanceof Request?new Request(r.url,e):r.url):e}function H(e,t){return e instanceof Request&&t?e.clone():e}async function F(e,t,r){for(let n=0;n<r.maxAttempts;n++)try{const a=H(e,n<r.maxAttempts-1),c=await g(a,t,r);if(await R(n,t,r,c))return c;e=C(e,t,c);continue}catch(a){if(a instanceof Error&&a.message==l||await R(n,t,r))throw a;continue}return await g(e,t,r)}async function g(e,t,r){return await _(r.delay),await fetch(e,t)}

package/esm/mod.js

@@ -2,4 +2,4 @@
  * Exports main functions and types for external.
  * @module
  */
-export { fetchy, fetchyb, HTTPStatusError, RedirectError } from "./main.js";
+export { Fetchy, fetchy, HTTPStatusError, NO_RETRY_ERROR, RedirectError, sfetchy } from "./main.js";

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@scirexs/fetchy",
-  "version": "0.4.2",
+  "version": "0.6.1",
   "description": "A lightweight fetch wrapper.",
   "keywords": [
     "fetch",
+    "fetch-wrapper",
+    "fetch-client",
+    "request",
+    "http",
+    "get",
+    "url",
     "typescript"
   ],
   "author": "scirexs",

package/types/main.d.ts

@@ -1,9 +1,14 @@
-export { _cloneInput, _combineSignal, _correctNumber, _DEFAULT, _fetchWithJitter, _fetchWithRetry, _getBody, _getContentType, _getHeaders, _getNextInterval, _getOptions, _getRequestInit, _getRetryOption, _handleRedirectResponse, _isBool, _isJSONObject, _isNumber, _isPlainObject, _isString, _parseRetryAfter, _shouldNotRetry, _shouldRedirect, _throwError, _wait, fetchy, fetchyb, HTTPStatusError, RedirectError, };
-import type { ErrorOptions, FetchyBody, FetchyOptions, RetryOptions } from "./types.js";
+export { _cloneInput, _combineSignal, _correctNumber, _DEFAULT, _fetchWithJitter, _fetchWithRetry, _getBody, _getContentType, _getHeaders, _getNextInterval, _getOptions, _getRequestInit, _getRetryOption, _handleRedirectResponse, _isBool, _isJSONObject, _isNumber, _isPlainObject, _isString, _main, _parseBody, _parseRetryAfter, _shouldCorrectRequest, _shouldNotRetry, _shouldRedirect, _wait, Fetchy, fetchy, HTTPStatusError, NO_RETRY_ERROR, RedirectError, sfetchy, };
+import type { FetchyBody, FetchyOptions, RetryOptions } from "./types.js";
+/** Error message to simulate immediate failures without retry for writing tests. */
+declare const NO_RETRY_ERROR = "$$_NO_RETRY_$$";
 /** Default configuration values for fetchy. */
 declare const _DEFAULT: Options;
 /** Valid input types for fetch requests. */
 type Input = string | URL | Request;
+type FetchyReturn<T> = Response | string | Uint8Array<ArrayBuffer> | Blob | ArrayBuffer | T;
+/** Response body parsing method specification. */
+type ParseMethod = "text" | "json" | "bytes" | "blob" | "buffer";
 /** Internal normalized options used throughout the fetch process. */
 interface Options {
     timeout: number;
@@ -12,18 +17,9 @@ interface Options {
     maxInterval: number;
     maxAttempts: number;
     retryAfter: boolean;
-    onNative?: boolean;
-    onStatus: boolean;
+    native: boolean;
     redirect: "follow" | "error" | "manual";
 }
-/** Infer helper type for response type overload. */
-type ThrowError = FetchyOptions & Partial<{
-    throwError: true;
-}> | FetchyOptions & Partial<{
-    throwError: {
-        onError: true;
-    };
-}>;
 /**
  * Error thrown when HTTP response has a non-OK status code (4xx, 5xx, ...).
  * Only thrown when throwError.onErrorStatus is set to true.
@@ -46,7 +42,7 @@ declare class HTTPStatusError extends Error {
     status: number;
     body: string;
     constructor(msg: string, status: number, body: string);
-    static fromResponse(resp: Response): Promise<InstanceType<typeof this>>;
+    static fromResponse(resp: Response): Promise<HTTPStatusError>;
 }
 /**
  * Error thrown when a redirect response is received and redirect option is set to "error".
@@ -67,82 +63,218 @@ declare class HTTPStatusError extends Error {
 declare class RedirectError extends Error {
     status: number;
     constructor(msg: string, status: number);
-    static fromResponse(resp: Response): InstanceType<typeof this>;
+    static fromResponse(resp: Response): RedirectError;
 }
 /**
- * Performs an HTTP request and automatically parses the response body based on Content-Type or specified type.
- * Returns null if the request fails or response is not OK, unless throwError is configured.
+ * A fluent HTTP client class that provides both instance and static methods for making HTTP requests.
+ * Supports features like timeout, retry with exponential backoff, automatic header management, and response parsing.
  *
- * @param url - The URL to fetch. Can be a string, URL object, or Request object.
- * @param type - The expected response type. "auto" detects type from Content-Type header.
- * @param options - Configuration options for the request.
- * @returns Parsed response body or null on failure.
+ * This class can be used in two ways:
+ * - Instance methods: Create an instance with default options, then call methods with optional URL override
+ * - Static methods: Call methods directly with URL and options
  *
  * @example
  * ```ts
- * import { fetchyb } from "@scirexs/fetchy";
+ * // Instance usage - reuse configuration
+ * const client = new Fetchy({
+ *   bearer: "token123",
+ *   timeout: 10,
+ *   retry: { max: 3 }
+ * });
+ * const user = await client.json<User>("https://api.example.com/user");
+ * const posts = await client.json<Post[]>("https://api.example.com/posts");
  *
- * // Automatic type detection
- * const data = await fetchyb("https://api.example.com/user");
+ * // Static usage - one-off requests
+ * const data = await Fetchy.json("https://api.example.com/data");
+ * const response = await Fetchy.fetch("https://api.example.com/endpoint", {
+ *   body: { key: "value" },
+ *   timeout: 5
+ * });
  *
- * // Explicit JSON parsing with type assertion
+ * // Safe mode - returns null on error instead of throwing
+ * const result = await Fetchy.sjson("https://api.example.com/data");
+ * if (result !== null) {
+ *   // Handle successful response
+ * }
+ * ```
+ */
+declare class Fetchy implements FetchyOptions {
+    /** Request URL. Used if call fetchy with null. */
+    url?: string | URL;
+    /** Request body content. Automatically serializes JSON objects. */
+    body?: FetchyBody;
+    /** Request timeout in seconds. Default is 15 seconds. */
+    timeout?: number;
+    /** Retry configuration. Set to false to disable retry functionality. */
+    retry?: false | RetryOptions;
+    /** Bearer token for Authorization header. Automatically adds "Bearer " prefix. */
+    bearer?: string;
+    /** Initial jitter delay in seconds before sending the request. Adds randomness to prevent thundering herd. */
+    delay?: number;
+    /** If receive response, does not throw error same with native fetch. */
+    native?: true;
+    constructor(options?: FetchyOptions);
+    /** Call fetchy with instance options. */
+    fetch(url?: Input | null): Promise<Response>;
+    /** Call fetchy with instance options and parsing as text. */
+    text(url?: Input | null): Promise<string>;
+    /** Call fetchy with instance options and parsing as json. */
+    json<T>(url?: Input | null): Promise<T>;
+    /** Call fetchy with instance options and parsing as Uint8Array. */
+    bytes(url?: Input | null): Promise<Uint8Array<ArrayBuffer>>;
+    /** Call fetchy with instance options and parsing as Blob. */
+    blob(url?: Input | null): Promise<Blob>;
+    /** Call fetchy with instance options and parsing as ArrayBuffer. */
+    buffer(url?: Input | null): Promise<ArrayBuffer>;
+    /** Call sfetchy with instance options. */
+    safe(url?: Input | null): Promise<Response | null>;
+    /** Call sfetchy with instance options and parsing as text. */
+    stext(url?: Input | null): Promise<string | null>;
+    /** Call sfetchy with instance options and parsing as json. */
+    sjson<T>(url?: Input | null): Promise<T | null>;
+    /** Call sfetchy with instance options and parsing as Uint8Array. */
+    sbytes(url?: Input | null): Promise<Uint8Array<ArrayBuffer> | null>;
+    /** Call sfetchy with instance options and parsing as Blob. */
+    sblob(url?: Input | null): Promise<Blob | null>;
+    /** Call sfetchy with instance options and parsing as ArrayBuffer. */
+    sbuffer(url?: Input | null): Promise<ArrayBuffer | null>;
+    /** Call fetchy. */
+    static fetch(url: Input | null, options?: FetchyOptions): Promise<Response>;
+    /** Call fetchy with parsing as text. */
+    static text(url: Input | null, options?: FetchyOptions): Promise<string>;
+    /** Call fetchy with parsing as json. */
+    static json<T>(url: Input | null, options?: FetchyOptions): Promise<T>;
+    /** Call fetchy with parsing as Uint8Array. */
+    static bytes(url: Input | null, options?: FetchyOptions): Promise<Uint8Array<ArrayBuffer>>;
+    /** Call fetchy with parsing as Blob. */
+    static blob(url: Input | null, options?: FetchyOptions): Promise<Blob>;
+    /** Call fetchy with parsing as ArrayBuffer. */
+    static buffer(url: Input | null, options?: FetchyOptions): Promise<ArrayBuffer>;
+    /** Call sfetchy. */
+    static safe(url: Input | null, options?: FetchyOptions): Promise<Response | null>;
+    /** Call sfetchy with parsing as text. */
+    static stext(url: Input | null, options?: FetchyOptions): Promise<string | null>;
+    /** Call sfetchy with parsing as json. */
+    static sjson<T>(url: Input | null, options?: FetchyOptions): Promise<T | null>;
+    /** Call sfetchy with parsing as Uint8Array. */
+    static sbytes(url: Input | null, options?: FetchyOptions): Promise<Uint8Array<ArrayBuffer> | null>;
+    /** Call sfetchy with parsing as Blob. */
+    static sblob(url: Input | null, options?: FetchyOptions): Promise<Blob | null>;
+    /** Call sfetchy with parsing as ArrayBuffer. */
+    static sbuffer(url: Input | null, options?: FetchyOptions): Promise<ArrayBuffer | null>;
+}
+/**
+ * Performs an HTTP request with safe error handling that returns null on failure.
+ * Automatically parses the response body based on the specified parse method.
+ * Unlike `fetchy`, this function never throws errors - it returns null for any failure.
+ *
+ * This is useful when you want to handle errors gracefully without try-catch blocks,
+ * or when a failed request should be treated as "no data" rather than an error condition.
+ *
+ * @param url - The URL to fetch. Can be a string, URL object, Request object, or null (uses options.url).
+ * @param options - Configuration options for the request (timeout, retry, headers, etc.).
+ * @param parse - Optional response body parsing method. If omitted, returns Response object.
+ *                Supported values: "json", "text", "bytes", "blob", "buffer".
+ * @returns Parsed response body, Response object, or null if request fails or response is not OK.
+ *
+ * @example
+ * ```ts
+ * import { sfetchy } from "@scirexs/fetchy";
+ *
+ * // Returns null instead of throwing on error
+ * const data = await sfetchy("https://api.example.com/user", {}, "json");
+ * if (data === null) {
+ *   console.log("Request failed, using default data");
+ *   // Handle failure case
+ * }
+ *
+ * // Explicit type assertion with JSON parsing
  * interface User { id: number; name: string; }
- * const user = await fetchyb<User>("https://api.example.com/user", "json");
+ * const user = await sfetchy<User>("https://api.example.com/user", {}, "json");
+ *
+ * // Text response - returns null on any error
+ * const text = await sfetchy("https://example.com/page", {}, "text");
  *
- * // Text response
- * const text = await fetchyb("https://example.com/page", "text");
+ * // Binary data with safe error handling
+ * const bytes = await sfetchy("https://example.com/image.png", {}, "bytes");
+ * if (bytes !== null) {
+ *   // Process binary data
+ * }
  *
- * // Binary data
- * const bytes = await fetchyb("https://example.com/image.png", "bytes");
+ * // Raw Response object (no parsing)
+ * const response = await sfetchy("https://api.example.com/data");
+ * if (response !== null && response.ok) {
+ *   // Handle response
+ * }
  * ```
  */
-declare function fetchyb(url: Input | null, type: "text", options?: undefined): Promise<string>;
-declare function fetchyb(url: Input | null, type: "text", options: FetchyOptions & ThrowError): Promise<string>;
-declare function fetchyb(url: Input | null, type: "text", options?: FetchyOptions): Promise<string | null>;
-declare function fetchyb<T>(url: Input | null, type: "json", options?: undefined): Promise<T>;
-declare function fetchyb<T>(url: Input | null, type: "json", options: FetchyOptions & ThrowError): Promise<T>;
-declare function fetchyb<T>(url: Input | null, type: "json", options?: FetchyOptions): Promise<T | null>;
-declare function fetchyb(url: Input | null, type: "bytes", options?: undefined): Promise<Uint8Array>;
-declare function fetchyb(url: Input | null, type: "bytes", options: FetchyOptions & ThrowError): Promise<Uint8Array>;
-declare function fetchyb(url: Input | null, type: "bytes", options?: FetchyOptions): Promise<Uint8Array | null>;
-declare function fetchyb<T>(url: Input | null, type?: "auto", options?: undefined): Promise<T | string | Uint8Array>;
-declare function fetchyb<T>(url: Input | null, type?: "auto", options?: FetchyOptions & ThrowError): Promise<T | string | Uint8Array>;
-declare function fetchyb<T>(url: Input | null, type?: "auto", options?: FetchyOptions): Promise<T | string | Uint8Array | null>;
+declare function sfetchy(url: Input | null, options?: FetchyOptions, parse?: undefined): Promise<Response | null>;
+declare function sfetchy<T>(url: Input | null, options: FetchyOptions | undefined, parse: "json"): Promise<T | null>;
+declare function sfetchy(url: Input | null, options: FetchyOptions | undefined, parse: "text"): Promise<string | null>;
+declare function sfetchy(url: Input | null, options: FetchyOptions | undefined, parse: "bytes"): Promise<Uint8Array<ArrayBuffer> | null>;
+declare function sfetchy(url: Input | null, options: FetchyOptions | undefined, parse: "blob"): Promise<Blob | null>;
+declare function sfetchy(url: Input | null, options: FetchyOptions | undefined, parse: "buffer"): Promise<ArrayBuffer | null>;
 /**
  * Performs an HTTP request with enhanced features like timeout, retry, and automatic header management.
- * Returns the raw Response object or null on failure, unless throwError is configured.
+ * Throws errors on failure unless configured otherwise via the `native` option.
+ * Automatically parses the response body based on the specified parse method.
  *
- * @param url - The URL to fetch. Can be a string, URL object, or Request object.
- * @param options - Configuration options for the request.
- * @returns Response object or null on failure.
+ * @param url - The URL to fetch. Can be a string, URL object, Request object, or null (uses options.url).
+ * @param options - Configuration options for the request (timeout, retry, headers, body, etc.).
+ * @param parse - Optional response body parsing method. If omitted, returns Response object.
+ *                Supported values: "json", "text", "bytes", "blob", "buffer".
+ * @returns Parsed response body or Response object.
+ * @throws {HTTPStatusError} When response status is not OK (4xx, 5xx) - default behavior.
+ * @throws {RedirectError} When redirect is encountered and redirect option is set to "error".
+ * @throws {TypeError} When network error occurs (e.g., DNS resolution failure, connection refused).
+ * @throws {DOMException} When request is aborted via timeout or AbortSignal.
  *
  * @example
  * ```ts
  * import { fetchy } from "@scirexs/fetchy";
  *
- * // Simple GET request
+ * // Simple GET request returning Response object
  * const response = await fetchy("https://api.example.com/data");
- * if (response?.ok) {
+ * if (response.ok) {
  *   const data = await response.json();
  * }
  *
- * // POST request with JSON body
- * const response = await fetchy("https://api.example.com/create", {
+ * // Direct JSON parsing with type assertion
+ * interface User { id: number; name: string; }
+ * const user = await fetchy<User>("https://api.example.com/user", {}, "json");
+ *
+ * // POST request with JSON body and authentication
+ * const result = await fetchy("https://api.example.com/create", {
  *   body: { name: "John", age: 30 },
- *   bearerToken: "your-token"
- * });
+ *   bearer: "your-token-here"
+ * }, "json");
  *
- * // With retry and timeout
+ * // With retry, timeout, and error handling
+ * try {
+ *   const data = await fetchy("https://api.example.com/data", {
+ *     timeout: 10,
+ *     retry: { max: 5, interval: 2, maxInterval: 30 }
+ *   }, "json");
+ * } catch (error) {
+ *   if (error instanceof HTTPStatusError) {
+ *     console.error(`HTTP ${error.status}: ${error.body}`);
+ *   }
+ * }
+ *
+ * // Native error mode - throws native fetch errors without HTTPStatusError
  * const response = await fetchy("https://api.example.com/data", {
- *   timeout: 10,
- *   retry: { max: 5, interval: 2 },
- *   throwError: { onErrorStatus: true }
+ *   native: true
  * });
  * ```
  */
-declare function fetchy(url: Input | null, options?: undefined): Promise<Response>;
-declare function fetchy(url: Input | null, options: FetchyOptions & ThrowError): Promise<Response>;
-declare function fetchy(url: Input | null, options?: FetchyOptions): Promise<Response | null>;
+declare function fetchy(url: Input | null, options?: FetchyOptions, parse?: undefined): Promise<Response>;
+declare function fetchy<T>(url: Input | null, options: FetchyOptions | undefined, parse: "json"): Promise<T>;
+declare function fetchy(url: Input | null, options: FetchyOptions | undefined, parse: "text"): Promise<string>;
+declare function fetchy(url: Input | null, options: FetchyOptions | undefined, parse: "bytes"): Promise<Uint8Array<ArrayBuffer>>;
+declare function fetchy(url: Input | null, options: FetchyOptions | undefined, parse: "blob"): Promise<Blob>;
+declare function fetchy(url: Input | null, options: FetchyOptions | undefined, parse: "buffer"): Promise<ArrayBuffer>;
+/** Main procedure of fetchy and sfetchy. */
+declare function _main<T>(url: Input | null, options?: FetchyOptions, parse?: ParseMethod): Promise<FetchyReturn<T>>;
 /** Checks if a value is a string. */
 declare function _isString(v: unknown): v is string;
 /** Checks if a value is a number. */
@@ -151,8 +283,6 @@ declare function _isNumber(v: unknown): v is number;
 declare function _isBool(v: unknown): v is boolean;
 /** Checks if a value is a plain object (not array, null, or other object types). */
 declare function _isPlainObject(v: unknown): v is object;
-/** Determines whether to throw an error based on configuration. */
-declare function _throwError(prop: keyof ErrorOptions, options?: ErrorOptions | boolean): boolean;
 /** Corrects a number to be non-negative, using default if invalid. */
 declare function _correctNumber(dflt: number, num?: number, integer?: boolean): number;
 /** Gets retry option value from configuration with fallback to default. */
@@ -172,10 +302,14 @@ declare function _getHeaders(options?: FetchyOptions): Headers;
 declare function _getContentType(body?: FetchyBody): string | undefined;
 /** Combine abort signals. */
 declare function _combineSignal(url: Input, timeout: number, signal?: AbortSignal | null): AbortSignal | undefined;
+/** Parse response body. */
+declare function _parseBody<T>(resp: Response, method: ParseMethod): Promise<Exclude<FetchyReturn<T>, Response>>;
 /** Waits for specified seconds with optional randomization. */
 declare function _wait(sec: number, random?: boolean): Promise<void>;
 /** Checks if response is a redirect (3xx status). */
 declare function _shouldRedirect(resp: Response): boolean;
+/** Checks if response is a client error (4xx status). */
+declare function _shouldCorrectRequest(resp: Response): boolean;
 /** Determines if retry should stop based on conditions and waits if continuing. */
 declare function _shouldNotRetry(count: number, init: RequestInit, opts: Options, resp?: Response): Promise<boolean>;
 /** Calculates next retry interval using exponential backoff or Retry-After header. */

package/types/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"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"}

package/types/mod.d.ts

@@ -2,6 +2,6 @@
  * Exports main functions and types for external.
  * @module
  */
-export { fetchy, fetchyb, HTTPStatusError, RedirectError } from "./main.js";
-export type { ErrorOptions, FetchyBody, FetchyOptions, JSONValue, RetryOptions } from "./types.js";
+export { Fetchy, fetchy, HTTPStatusError, NO_RETRY_ERROR, RedirectError, sfetchy } from "./main.js";
+export type { FetchyBody, FetchyOptions, JSONValue, RetryOptions } from "./types.js";
 //# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpG,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/types/types.d.ts

@@ -38,10 +38,10 @@ export interface FetchyOptions extends Omit<RequestInit, "body"> {
     retry?: RetryOptions | false;
     /** Bearer token for Authorization header. Automatically adds "Bearer " prefix. */
     bearer?: string;
-    /** Error throwing behavior configuration. Set to true to throw all errors. */
-    onError?: ErrorOptions | boolean;
     /** Initial jitter delay in seconds before sending the request. Adds randomness to prevent thundering herd. */
     delay?: number;
+    /** If receive response, does not throw error same with native fetch. */
+    native?: true;
 }
 /**
  * Configuration options for retry behavior.
@@ -67,14 +67,4 @@ export interface RetryOptions {
     /** Whether to respect Retry-After header from response. Default is true. */
     retryAfter?: boolean;
 }
-/**
- * Configuration options for error throwing behavior.
- * Allows fine-grained control over which errors should be thrown vs. returned as null.
- */
-export interface ErrorOptions {
-    /** Whether to throw native errors (network errors, parsing errors, etc.). If false, returns null instead. Default is true. */
-    onNative?: boolean;
-    /** Whether to throw HTTPStatusError for non-OK status codes (4xx, 5xx, ...). Default is false. */
-    onStatus?: boolean;
-}
 //# sourceMappingURL=types.d.ts.map

package/types/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEtG;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC;IAC9D,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,mEAAmE;IACnE,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,KAAK,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC;IAC7B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;IACjC,8GAA8G;IAC9G,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,gHAAgH;IAChH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wGAAwG;IACxG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,8HAA8H;IAC9H,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEtG;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC;IAC9D,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,mEAAmE;IACnE,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,KAAK,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC;IAC7B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8GAA8G;IAC9G,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,MAAM,CAAC,EAAE,IAAI,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,gHAAgH;IAChH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wGAAwG;IACxG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB"}