@scirexs/fetchy 0.6.1 → 0.7.0

package/esm/main.js

@@ -1 +1 @@
-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)}
+export{M as Fetchy,o as fetchy,B as fy,O as HTTPStatusError,s as sfetchy};const d="GET",y="HEAD",h="POST",b="PUT",_="PATCH",g="DELETE",T="Accept",E="Content-Type",w="application/json",a={a:15,b:0,c:3,d:30,e:3,f:!0,g:!1,h:[500,502,503,504,408,429],i:["retry-after","ratelimit-reset","x-ratelimit-reset"],j:!1},v=[h,_,"CONNECT"],N=["text","json","bytes","blob","arrayBuffer","formData"];class O extends Error{status;response;constructor(e){super(`${e.status} ${e.url}`),this.name="HTTPStatusError",this.status=e.status,this.response=e}}class M{url;base;body;timeout;retry;bearer;jitter;native;cache;credentials;headers;integrity;keepalive;method;mode;redirect;referrer;referrerPolicy;signal;constructor(e){Object.assign(this,e)}fetch(e,n){return o(e,i(this,n))}get(e,n){return o(e,i(this,n,d))}head(e,n){return o(e,i(this,n,y))}post(e,n){return o(e,i(this,n,h))}put(e,n){return o(e,i(this,n,b))}patch(e,n){return o(e,i(this,n,_))}delete(e,n){return o(e,i(this,n,g))}safe(e,n){return s(e,i(this,n))}sget(e,n){return s(e,i(this,n,d))}shead(e,n){return s(e,i(this,n,y))}spost(e,n){return s(e,i(this,n,h))}sput(e,n){return s(e,i(this,n,b))}spatch(e,n){return s(e,i(this,n,_))}sdelete(e,n){return s(e,i(this,n,g))}}function B(t){return new M(t)}function s(t,e){try{return j(t,e,!0)}catch{return null}}function o(t,e){return j(t,e)}function j(t,e,n=!1){const r=L(F(t,e)),u=p(t,e),f=z(u,t,e);return Z(r,u,f,n)}function i(t,e,n){return{...t,...e,method:n}}function I(t){return typeof t=="string"}function U(t){return typeof t=="number"}function R(t){return typeof t=="boolean"}function P(t){return t instanceof ReadableStream}function l(t){return t instanceof Request}function k(t){return!!(t&&typeof t=="object"&&Object.getPrototypeOf(t)===Object.prototype)}function m(t,e){return(e??-1)>=0?e:t}function F(t,e){return l(t)||(t||(t=e?.url??""),l(t))?t:new Request(URL.parse(t,e?.base)??"")}function L(t,e){if(!P(e?.body))return t;const n=[d,y].includes(t.method)?h:t.method;return new Request(t,{method:n,body:e.body})}function p(t,e){const{method:n,body:r,timeout:u,retry:f,bearer:c,native:it,jitter:at,headers:ut,signal:ct,...D}=e??{};return{headers:J(e,l(t)?t.headers:null),method:n?n.toUpperCase():l(t)?t.method:r==null?d:h,...q(r),...D}}function q(t){return P(t)?null:{body:S(t)?JSON.stringify(t):t}}function S(t){return!!(U(t)||R(t)||Array.isArray(t)||k(t))}function J(t,e){const n=new Headers(t?.headers);if(H(T,n,e)&&n.set(T,`${w}, text/plain`),H(E,n,e)){const r=$(t?.body);r&&n.set(E,r)}return t?.bearer&&n.set("Authorization",`Bearer ${t.bearer}`),n}function H(t,e,n){return!e.has(t)&&!n?.has(t)}function $(t){return S(t)?w:G(t)?"":"application/octet-stream"}function G(t){return t==null||I(t)||t instanceof FormData||t instanceof URLSearchParams||!!(t instanceof Blob&&t.type)}function W(t,e){return R(e)?{...a,e:1}:{e:Math.max(m(a.e,e?.maxAttempts),1),c:Math.max(m(a.c,e?.interval),.01),d:Math.max(m(a.d,e?.maxInterval),1),f:e?.retryOnTimeout??a.f,g:e?.idempotentOnly?v.includes(t.method??""):!1,h:e?.statusCodes??a.h,i:e?.respectHeaders??a.i}}function z(t,e,n){return{...W(t,n?.retry),a:m(a.a,n?.timeout),b:m(a.b,n?.jitter),j:n?.native??a.j,k:x(l(e)?e.signal:null,n?.signal)}}function x(t,e){if(!(!t&&!e))return t&&e?AbortSignal.any([t,e]):t||(e??void 0)}function Y(t){return t.a<=0?t.k:x(AbortSignal.timeout(t.a*1e3),t.k)}async function A(t,e=!1){if(t<=0)return;const n=Math.trunc((e?Math.random():1)*t*1e3);await new Promise(r=>setTimeout(r,n))}function K(t){return t>=400||t<100}async function C(t,e,n){if(e.g||t>=e.e-1)return!1;if(n instanceof Response){if(e.j||!e.h.includes(n.status))return!1;const r=Q(t,e,n.headers);return r>e.d?!1:(await A(r),!0)}else return n instanceof Error&&n.name=="TimeoutError"&&e.f}function Q(t,e,n){return e.i.some(r=>n.has(r))?V(e,n)??e.c:Math.min(e.c*2**t,e.d)}function V(t,e){for(const n of t.i){const r=X(e.get(n)?.trim());if(!Number.isNaN(r))return Math.max(r,t.c)}}function X(t){if(!t)return NaN;const e=Number.parseInt(t,10);return Number.isNaN(e)?Math.ceil((new Date(t).getTime()-Date.now())/1e3):e}function Z(t,e,n,r=!1){const u=nt(t,e,n,r);return tt(u,r)}function tt(t,e){return Object.assign(t,Object.fromEntries([...e?N.map(n=>[n,()=>t.then(r=>r[n]()).catch(()=>null)]):N.map(n=>[n,()=>t.then(r=>r[n]())])]))}function et(t){let e;return async n=>{n&&await e?.body?.cancel();const r=e??t;return n||(e=e?e.clone():t.clone()),r}}async function nt(t,e,n,r){const u=et(t);for(let f=0;f<n.e;f++)try{const c=await rt(await u(),e,n);if(await C(f,n,c))continue;if(K(c.status)&&!n.j)throw new O(c);return c}catch(c){if(await C(f,n,c))continue;if(r)return null;throw c}finally{await u(!0)}throw new Error}async function rt(t,e,n){return await A(n.b,!0),await fetch(t,{...e,signal:Y(n)})}

package/esm/mod.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scirexs/fetchy",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A lightweight fetch wrapper.",
   "keywords": [
     "fetch",

package/types/main.d.ts

@@ -1,106 +1,80 @@
-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_$$";
+export { _assignToPromise, _buildOption, _cloneRequestF, _correctNumber, _createRequest, _DEFAULT, _fetchWithJitter, _fetchWithRetry, _findRetryHeader, _getBody, _getContentType, _getHeaders, _getNextInterval, _getOptions, _getRequestInit, _getRetryOption, _handleByNative, _includeStream, _isBool, _isHttpError, _isJSONObject, _isNoHeader, _isNumber, _isPlain, _isRequest, _isStream, _isString, _main, _makeFetchyResponse, _mergeSignals, _METHODS, _NO_IDEM, _parseRetryHeader, _shouldRetry, _wait, _withTimeout, Fetchy, fetchy, fy, HTTPStatusError, sfetchy, };
+import type { FetchyBody, FetchyOptions, FetchyResponse, FetchySafeResponse, RetryOptions } from "./types.js";
 /** 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";
+/** HTTP methods that do not have idempotency. */
+declare const _NO_IDEM: string[];
+/** Additional methods for Promise-like interface. */
+declare const _METHODS: readonly ["text", "json", "bytes", "blob", "arrayBuffer", "formData"];
 /** Internal normalized options used throughout the fetch process. */
 interface Options {
-    timeout: number;
-    delay: number;
-    interval: number;
-    maxInterval: number;
-    maxAttempts: number;
-    retryAfter: boolean;
-    native: boolean;
-    redirect: "follow" | "error" | "manual";
+    ztimeout: number;
+    zjitter: number;
+    zinterval: number;
+    zmaxInterval: number;
+    zmaxAttempts: number;
+    zonTimeout: boolean;
+    znoIdempotent: boolean;
+    zstatusCodes: number[];
+    zrespects: string[];
+    znative: boolean;
+    zsignal?: AbortSignal;
 }
+/** URL argument type for fetchy functions. */
+type InputArg = string | URL | Request | null;
+/** Internal retry-related options extracted from RetryOptions. */
+type InternalRetry = Pick<Options, "zinterval" | "zmaxInterval" | "zmaxAttempts" | "zonTimeout" | "znoIdempotent" | "zstatusCodes" | "zrespects">;
 /**
- * Error thrown when HTTP response has a non-OK status code (4xx, 5xx, ...).
- * Only thrown when throwError.onErrorStatus is set to true.
+ * Error thrown when HTTP response has a non-OK status code (4xx, 5xx).
+ * Only thrown when `native` option is set to false (default behavior).
  *
  * @example
  * ```ts
  * try {
- *   await fetchy("https://api.example.com/data", {
- *     throwError: { onErrorStatus: true }
- *   });
+ *   await fetchy("https://api.example.com/data");
  * } catch (error) {
  *   if (error instanceof HTTPStatusError) {
- *     console.error("HTTP error:", error.message); // e.g., "403 Forbidden: {success:false}"
+ *     console.error(`HTTP ${error.status}:`, error.message);
+ *     console.error("Response:", error.response);
  *   }
  * }
  * ```
  */
 declare class HTTPStatusError extends Error {
-    #private;
     status: number;
-    body: string;
-    constructor(msg: string, status: number, body: string);
-    static fromResponse(resp: Response): Promise<HTTPStatusError>;
-}
-/**
- * Error thrown when a redirect response is received and redirect option is set to "error".
- *
- * @example
- * ```ts
- * try {
- *   await fetchy("https://example.com/redirect", {
- *     redirect: "error"
- *   });
- * } catch (error) {
- *   if (error instanceof RedirectError) {
- *     console.error("Unexpected redirect:", error.message);
- *   }
- * }
- * ```
- */
-declare class RedirectError extends Error {
-    status: number;
-    constructor(msg: string, status: number);
-    static fromResponse(resp: Response): RedirectError;
+    response: Response;
+    constructor(resp: Response);
 }
 /**
  * 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.
  *
- * 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
  * // 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");
- *
- * // 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
+ *   retry: { maxAttempts: 3 }
  * });
+ * const user = await client.get("https://api.example.com/user").json<User>();
+ * const posts = await client.get("https://api.example.com/posts").json<Post[]>();
  *
  * // Safe mode - returns null on error instead of throwing
- * const result = await Fetchy.sjson("https://api.example.com/data");
+ * const result = await client.safe("https://api.example.com/data").json<Data>();
  * if (result !== null) {
  *   // Handle successful response
  * }
  * ```
  */
 declare class Fetchy implements FetchyOptions {
-    /** Request URL. Used if call fetchy with null. */
-    url?: string | URL;
+    /** Request URL. Used when calling methods with null as URL argument. */
+    url?: string | URL | Request;
+    /**
+     * Base URL prepended to the request URL.
+     * Only used when the URL argument is a string or URL (not when it's a Request object).
+     */
+    base?: string | URL;
     /** Request body content. Automatically serializes JSON objects. */
     body?: FetchyBody;
     /** Request timeout in seconds. Default is 15 seconds. */
@@ -109,63 +83,89 @@ declare class Fetchy implements FetchyOptions {
     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;
+    /**
+     * Maximum jitter delay in seconds applied before each request (including retries).
+     * Adds randomness (0 to specified value) to prevent thundering herd.
+     */
+    jitter?: number;
+    /** If true, does not throw error on HTTP error status, behaving like native fetch. */
+    native?: boolean;
+    /** Property of RequestInit. */
+    cache?: RequestCache;
+    /** Property of RequestInit. */
+    credentials?: RequestCredentials;
+    /** Property of RequestInit. */
+    headers?: HeadersInit;
+    /** Property of RequestInit. */
+    integrity?: string;
+    /** Property of RequestInit. */
+    keepalive?: boolean;
+    /** Property of RequestInit. */
+    method?: string;
+    /** Property of RequestInit. */
+    mode?: RequestMode;
+    /** Property of RequestInit. */
+    redirect?: RequestRedirect;
+    /** Property of RequestInit. */
+    referrer?: string;
+    /** Property of RequestInit. */
+    referrerPolicy?: ReferrerPolicy;
+    /** Property of RequestInit. */
+    signal?: AbortSignal | null;
     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>;
+    /** Calls fetchy with instance options. */
+    fetch(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls fetchy as GET request with instance options. */
+    get(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls fetchy as HEAD request with instance options. */
+    head(url?: string | URL | Request | null, options?: FetchyOptions): Promise<Response>;
+    /** Calls fetchy as POST request with instance options. */
+    post(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls fetchy as PUT request with instance options. */
+    put(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls fetchy as PATCH request with instance options. */
+    patch(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls fetchy as DELETE request with instance options. */
+    delete(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+    /** Calls sfetchy with instance options. Returns null on error. */
+    safe(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
+    /** Calls sfetchy as GET request with instance options. Returns null on error. */
+    sget(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
+    /** Calls sfetchy as HEAD request with instance options. Returns null on error. */
+    shead(url?: string | URL | Request | null, options?: FetchyOptions): Promise<Response | null> | null;
+    /** Calls sfetchy as POST request with instance options. Returns null on error. */
+    spost(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
+    /** Calls sfetchy as PUT request with instance options. Returns null on error. */
+    sput(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
+    /** Calls sfetchy as PATCH request with instance options. Returns null on error. */
+    spatch(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
+    /** Calls sfetchy as DELETE request with instance options. Returns null on error. */
+    sdelete(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
 }
+/**
+ * Creates a new Fetchy instance with the specified options.
+ * Shorthand for `new Fetchy(options)`.
+ *
+ * @param options - Configuration options to apply to all requests made with this instance.
+ * @returns A new Fetchy instance.
+ *
+ * @example
+ * ```ts
+ * import { fy } from "@scirexs/fetchy";
+ *
+ * const client = fy({
+ *   bearer: "token123",
+ *   timeout: 10,
+ *   base: "https://api.example.com"
+ * });
+ *
+ * const user = await client.get("/user").json<User>();
+ * const posts = await client.get("/posts").json<Post[]>();
+ * ```
+ */
+declare function fy(options?: FetchyOptions): Fetchy;
 /**
  * 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,
@@ -173,59 +173,46 @@ declare class Fetchy implements FetchyOptions {
  *
  * @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.
+ * @returns Promise that resolves to Response object or null if request fails.
  *
  * @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) {
+ * const response = await sfetchy("https://api.example.com/user");
+ * if (response === null) {
  *   console.log("Request failed, using default data");
  *   // Handle failure case
+ * } else {
+ *   const data = await response.json();
  * }
  *
- * // Explicit type assertion with JSON parsing
- * interface User { id: number; name: string; }
- * const user = await sfetchy<User>("https://api.example.com/user", {}, "json");
+ * // Using convenience methods
+ * const user = await sfetchy("https://api.example.com/user").json<User>();
+ * if (user !== null) {
+ *   // Handle successful response
+ * }
  *
  * // Text response - returns null on any error
- * const text = await sfetchy("https://example.com/page", {}, "text");
+ * const text = await sfetchy("https://example.com/page").text();
  *
  * // Binary data with safe error handling
- * const bytes = await sfetchy("https://example.com/image.png", {}, "bytes");
+ * const bytes = await sfetchy("https://example.com/image.png").bytes();
  * if (bytes !== null) {
  *   // Process binary data
  * }
- *
- * // Raw Response object (no parsing)
- * const response = await sfetchy("https://api.example.com/data");
- * if (response !== null && response.ok) {
- *   // Handle response
- * }
  * ```
  */
-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>;
+declare function sfetchy(url?: string | URL | Request | null, options?: FetchyOptions): FetchySafeResponse | null;
 /**
  * Performs an HTTP request with enhanced features like timeout, retry, and automatic header management.
  * 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, 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".
+ * @returns Promise that resolves to Response object.
+ * @throws {HTTPStatusError} When response status is not OK (4xx, 5xx) and native mode is disabled.
  * @throws {TypeError} When network error occurs (e.g., DNS resolution failure, connection refused).
  * @throws {DOMException} When request is aborted via timeout or AbortSignal.
  *
@@ -233,95 +220,104 @@ declare function sfetchy(url: Input | null, options: FetchyOptions | undefined,
  * ```ts
  * import { fetchy } from "@scirexs/fetchy";
  *
- * // Simple GET request returning Response object
+ * // Simple GET request
  * const response = await fetchy("https://api.example.com/data");
- * if (response.ok) {
- *   const data = await response.json();
- * }
+ * const data = await response.json();
  *
- * // Direct JSON parsing with type assertion
- * interface User { id: number; name: string; }
- * const user = await fetchy<User>("https://api.example.com/user", {}, "json");
+ * // Using convenience methods
+ * const user = await fetchy("https://api.example.com/user").json<User>();
  *
  * // POST request with JSON body and authentication
  * const result = await fetchy("https://api.example.com/create", {
+ *   method: MPOST,
  *   body: { name: "John", age: 30 },
  *   bearer: "your-token-here"
- * }, "json");
+ * }).json();
  *
  * // 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");
+ *     retry: { maxAttempts: 5, interval: 2, maxInterval: 30 }
+ *   }).json();
  * } catch (error) {
  *   if (error instanceof HTTPStatusError) {
- *     console.error(`HTTP ${error.status}: ${error.body}`);
+ *     console.error(`HTTP ${error.status}:`, error.message);
  *   }
  * }
  *
- * // Native error mode - throws native fetch errors without HTTPStatusError
+ * // Native error mode - does not throw HTTPStatusError
  * const response = await fetchy("https://api.example.com/data", {
  *   native: true
  * });
  * ```
  */
-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 fetchy(url?: string | URL | Request | null, options?: FetchyOptions): FetchyResponse;
+/** Main procedure for fetchy and sfetchy. @internal */
+declare function _main(url: InputArg | undefined, options: FetchyOptions | undefined, safe?: undefined): FetchyResponse;
+declare function _main(url: InputArg | undefined, options: FetchyOptions | undefined, safe: true): FetchySafeResponse;
+/** Creates new options object with specified HTTP method and temporal options. @internal */
+declare function _buildOption(options?: FetchyOptions, temp?: FetchyOptions, method?: string): FetchyOptions;
+/** Type guard: checks if value is a string. @internal */
 declare function _isString(v: unknown): v is string;
-/** Checks if a value is a number. */
+/** Type guard: checks if value is a number. @internal */
 declare function _isNumber(v: unknown): v is number;
-/** Checks if a value is a boolean. */
+/** Type guard: checks if value is a boolean. @internal */
 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;
-/** 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. */
-declare function _getRetryOption(prop: keyof RetryOptions, off: number, options?: RetryOptions | false): number;
-declare function _getRetryOption(prop: keyof RetryOptions, off: boolean, options?: RetryOptions | false): boolean;
-/** Converts FetchyOptions to internal Options format with validated values. */
-declare function _getOptions(options?: FetchyOptions): Options;
-/** Converts FetchyOptions to standard RequestInit format. */
-declare function _getRequestInit(url: Input, opts: Options, options?: FetchyOptions): RequestInit;
-/** Converts FetchyBody to standard BodyInit format. */
-declare function _getBody(body: FetchyBody): BodyInit | undefined;
-/** Checks if a value should be treated as JSON object for serialization. */
+/** Type guard: checks if value is a ReadableStream. @internal */
+declare function _isStream(v: unknown): v is ReadableStream;
+/** Type guard: checks if value is a Request. @internal */
+declare function _isRequest(v: unknown): v is Request;
+/** Type guard: checks if value is a plain object (not array, null, or other object types). @internal */
+declare function _isPlain(v: unknown): v is object;
+/** Corrects a number to be non-negative, using default if invalid. @internal */
+declare function _correctNumber(dflt: number, num?: number): number;
+/** Creates Request object from various input types. @internal */
+declare function _createRequest(url?: InputArg, options?: FetchyOptions): Request;
+/** Creates new Request with ReadableStream body if present in options. @internal */
+declare function _includeStream(req: Request, options?: FetchyOptions): Request;
+/** Converts FetchyOptions to standard RequestInit format. @internal */
+declare function _getRequestInit(url?: InputArg, options?: FetchyOptions): RequestInit;
+/** Converts FetchyBody to standard BodyInit format. @internal */
+declare function _getBody(body?: FetchyBody): Record<string, BodyInit> | null;
+/** Checks if value should be treated as JSON for serialization. @internal */
 declare function _isJSONObject(arg?: FetchyBody): boolean;
-/** Constructs request headers with automatic Content-Type and Authorization. */
-declare function _getHeaders(options?: FetchyOptions): Headers;
-/** Determines Content-Type header based on body type. */
-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. */
+/** Constructs request headers with automatic Content-Type and Authorization. @internal */
+declare function _getHeaders(options?: FetchyOptions, reqHeaders?: Headers | null): Headers;
+/** Checks if header is absent in both option headers and request headers. @internal */
+declare function _isNoHeader(name: string, optionHeader: Headers, reqHeaders?: Headers | null): boolean;
+/** Determines Content-Type header based on body type. @internal */
+declare function _getContentType(body?: FetchyBody): string;
+/** Checks if Content-Type should be handled by native fetch. @internal */
+declare function _handleByNative(body?: FetchyBody): boolean;
+/** Extracts retry-related options with defaults. @internal */
+declare function _getRetryOption(init: RequestInit, options?: RetryOptions | false): InternalRetry;
+/** Converts FetchyOptions to internal Options format with validated values. @internal */
+declare function _getOptions(init: RequestInit, url?: InputArg, options?: FetchyOptions): Options;
+/** Merges multiple AbortSignals into one. @internal */
+declare function _mergeSignals(s1?: AbortSignal | null, s2?: AbortSignal | null): AbortSignal | undefined;
+/** Creates timeout signal and merges with existing signal. @internal */
+declare function _withTimeout(opts: Options): AbortSignal | undefined;
+/** Waits for specified seconds with optional randomization. @internal */
 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. */
-declare function _getNextInterval(count: number, opts: Options, resp?: Response): number;
-/** Parses Retry-After header value to seconds. */
-declare function _parseRetryAfter(value: string): number;
-/** Updates URL and method for redirect responses. */
-declare function _handleRedirectResponse(url: Input, init: RequestInit, resp: Response): Input;
-/** Clone input if required. */
-declare function _cloneInput(url: Input, required: boolean): Input;
-/** Executes fetch with retry logic and exponential backoff. */
-declare function _fetchWithRetry(url: Input, init: RequestInit, opts: Options): Promise<Response>;
-/** Executes fetch with initial jitter delay. */
-declare function _fetchWithJitter(url: Input, init: RequestInit, opts: Options): Promise<Response>;
+/** Checks if HTTP status code indicates an error. @internal */
+declare function _isHttpError(stat: number): boolean;
+/** Determines whether to retry based on conditions and waits before next attempt. @internal */
+declare function _shouldRetry(count: number, opts: Options, r: Response | unknown): Promise<boolean>;
+/** Calculates next retry interval using exponential backoff or response headers. @internal */
+declare function _getNextInterval(count: number, opts: Options, headers: Headers): number;
+/** Finds and parses retry timing from response headers. @internal */
+declare function _findRetryHeader(opts: Options, headers: Headers): number | undefined;
+/** Parses retry header value to seconds. @internal */
+declare function _parseRetryHeader(value?: string | null): number;
+/** Fetch with retry and creates promise-like object. @internal */
+declare function _makeFetchyResponse(req: Request, init: RequestInit, opts: Options, safe?: boolean): FetchyResponse | FetchySafeResponse;
+/** Creates promise-like object with convenience parsing methods. @internal */
+declare function _assignToPromise(resp: Promise<Response | null>, safe: boolean): FetchyResponse | FetchySafeResponse;
+/** Creates request cloning function with abort handling. @internal */
+declare function _cloneRequestF(req: Request): (cancel?: boolean) => Promise<Request>;
+/** Executes fetch with retry logic and exponential backoff. @internal */
+declare function _fetchWithRetry(req: Request, init: RequestInit, opts: Options, safe: boolean): Promise<Response | null>;
+/** Executes fetch with initial jitter delay. @internal */
+declare function _fetchWithJitter(req: Request, init: RequestInit, opts: Options): Promise<Response>;
 //# sourceMappingURL=main.d.ts.map