react-fetch-utils 1.0.0 → 1.1.0

package/Readme.md

@@ -18,11 +18,15 @@ npm install react-fetch-utils
 ```ts
 import {
     FetchPromise,
+    createFetchClient,
     useQueries,
     useRequest,
     statusEnum,
     type CancellablePromise,
+    type FetchClientDefaults,
+    type FetchPromiseError,
     type FetchPromiseParams,
+    type FetchRequestConfig,
     type Status,
 } from "react-fetch-utils";
 ```
@@ -30,11 +34,15 @@ import {
 ## Exports
 
 - `FetchPromise`
+- `createFetchClient`
 - `useQueries`
 - `useRequest`
 - `statusEnum`
 - `CancellablePromise` (type)
+- `FetchClientDefaults` (type)
+- `FetchPromiseError` (type)
 - `FetchPromiseParams` (type)
+- `FetchRequestConfig` (type)
 - `Status` (type)
 
 ## Quick Start
@@ -86,22 +94,49 @@ function FetchPromise<T = unknown>(
 type FetchPromiseParams = {
     url: string;
     method: string;
-    body?: object | null;
+    body?: unknown;
     respType?: "raw" | "json" | null;
+    headers?: HeadersInit | Record<string, string>;
+    timeoutMs?: number;
+    baseUrl?: string;
+    includeContentType?: boolean;
+    parseAs?: "json" | "raw" | "text" | "response";
+    onRequest?: (
+        request: FetchRequestConfig,
+    ) => FetchRequestConfig | void | Promise<FetchRequestConfig | void>;
+    validateStatus?: (status: number, response: Response) => boolean;
+    getAuthToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    allowBodyForGetHead?: boolean;
 };
 ```
 
 Behavior:
 
-- Sends JSON body with `JSON.stringify(params.body)`.
-- Sends headers:
-    - `Accept: application/json` (or `blob` when `respType: "raw"`)
-    - `Content-Type: application/json`
-- Resolves with `response.json()` by default.
-- Resolves with `response.blob()` when `respType: "raw"`.
-- Rejects `401` with `{ reason: "Unauthorized", details: Response }`.
-- Rejects all other failures as `{ reason: "Unknown", details: error }`.
-- Returns a promise with `.cancel()` that aborts the underlying request.
+- Backward compatible with existing `respType: "json" | "raw"`.
+- New parsing modes via `parseAs`:
+    - `json` (default)
+    - `raw` (`Blob`)
+    - `text` (`string`)
+    - `response` (`Response`)
+- Supports request timeout with `timeoutMs` using `AbortController`.
+- Supports base URL joining with `baseUrl`.
+- Supports request customization with `headers`, `onRequest`, `validateStatus`, and `getAuthToken`.
+- `Accept` is set automatically only when caller did not provide it.
+- `Content-Type: application/json` is added only when:
+    - there is a body,
+    - method is `POST`/`PUT`/`PATCH`,
+    - `includeContentType !== false`,
+    - caller did not already provide `Content-Type`.
+- Request body behavior:
+    - `GET`/`HEAD` bodies are not sent by default.
+    - use `allowBodyForGetHead: true` to allow body on `GET`/`HEAD`.
+    - non-JSON bodies (`FormData`, `Blob`, `string`, `URLSearchParams`, etc.) are passed through unchanged.
+    - plain objects/values are JSON-stringified when body is allowed.
+- Error model:
+    - `401` rejects with `{ reason: "Unauthorized", details: Response }`
+    - timeout abort rejects with `{ reason: "Timeout", details: ... }`
+    - other failures reject with `{ reason: "Unknown", details: ... }`
+- Returned promise remains cancellable with `.cancel()` and is safe to call repeatedly.
 
 Example (JSON):
 
@@ -112,9 +147,41 @@ type User = { id: number; name: string };
 
 export function getUser() {
     return FetchPromise<User>({
-        url: "/api/user",
+        url: "/user",
         method: "POST",
+        baseUrl: "https://api.example.com/v1",
         body: { includeDetails: true },
+        timeoutMs: 8000,
+        getAuthToken: () => localStorage.getItem("token"),
+    });
+}
+```
+
+Example (`text` parse mode + custom status validation):
+
+```ts
+import { FetchPromise } from "react-fetch-utils";
+
+export function getHealth() {
+    return FetchPromise<string>({
+        url: "/health",
+        method: "GET",
+        parseAs: "text",
+        validateStatus: status => status >= 200 && status < 500,
+    });
+}
+```
+
+Example (full `Response` mode):
+
+```ts
+import { FetchPromise } from "react-fetch-utils";
+
+export function getRawResponse() {
+    return FetchPromise<Response>({
+        url: "/diagnostics",
+        method: "GET",
+        parseAs: "response",
     });
 }
 ```
@@ -134,6 +201,64 @@ const download = FetchPromise<Blob>({
 download.cancel();
 ```
 
+### `createFetchClient`
+
+Creates a reusable request function with merged defaults so app code does not need a custom API wrapper utility.
+
+Signature:
+
+```ts
+function createFetchClient(
+    defaults?: FetchClientDefaults,
+): <T = unknown>(params: FetchPromiseParams) => CancellablePromise<T>;
+```
+
+Example (replace a custom `APIRequest` utility):
+
+```ts
+import { createFetchClient } from "react-fetch-utils";
+
+export const apiRequest = createFetchClient({
+    baseUrl: "https://api.example.com/v1",
+    timeoutMs: 10000,
+    headers: {
+        "X-App-Client": "web",
+    },
+    getAuthToken: async () => localStorage.getItem("access_token"),
+    validateStatus: status => status >= 200 && status < 300,
+    onRequest: request => {
+        request.headers.set("X-Trace-Id", crypto.randomUUID());
+    },
+});
+
+export const getProfile = () =>
+    apiRequest<{ id: string; name: string }>({
+        url: "/profile",
+        method: "GET",
+        parseAs: "json",
+    });
+
+export const downloadReport = () =>
+    apiRequest<Blob>({
+        url: "/reports/monthly",
+        method: "GET",
+        parseAs: "raw",
+    });
+```
+
+Example (`FormData` upload without forced JSON content-type):
+
+```ts
+const formData = new FormData();
+formData.append("file", file);
+
+apiRequest({
+    url: "/upload",
+    method: "POST",
+    body: formData,
+});
+```
+
 ### `useQueries`
 
 Tracks active cancellable promises and provides list management helpers.
@@ -295,12 +420,44 @@ const request: FetchPromiseParams = {
     url: "/api/items",
     method: "POST",
     body: { page: 1 },
-    respType: "json",
+    headers: { Authorization: "Bearer token" },
+    timeoutMs: 5000,
+    parseAs: "json",
 };
 
 FetchPromise(request);
 ```
 
+### `FetchPromiseError` (type)
+
+```ts
+type FetchPromiseError = {
+    reason: "Unauthorized" | "Timeout" | "Unknown";
+    details: unknown;
+    status?: number;
+    response?: Response;
+    originalError?: unknown;
+};
+```
+
+### `FetchRequestConfig` (type)
+
+```ts
+type FetchRequestConfig = {
+    url: string;
+    init: RequestInit;
+    headers: Headers;
+};
+```
+
+### `FetchClientDefaults` (type)
+
+```ts
+type FetchClientDefaults = Omit<FetchPromiseParams, "url" | "method"> & {
+    method?: string;
+};
+```
+
 ### `Status` (type)
 
 ```ts
@@ -320,6 +477,7 @@ console.log(statusEnum[status]); // "fetching"
 
 - `useRequest` is built on top of `useQueries`.
 - For errors, attach `.catch(...)` where you create and consume `CancellablePromise` requests.
+- `respType` is still supported for backward compatibility; prefer `parseAs` in new code.
 
 ## License
 

package/dist/index.d.mts

@@ -1,9 +1,33 @@
 interface FetchPromiseParams {
     url: string;
     method: string;
-    body?: object | null;
+    body?: unknown;
     respType?: "raw" | "json" | null;
+    headers?: HeadersInit | Record<string, string>;
+    timeoutMs?: number;
+    baseUrl?: string;
+    includeContentType?: boolean;
+    parseAs?: "json" | "raw" | "text" | "response";
+    onRequest?: (request: FetchRequestConfig) => FetchRequestConfig | void | Promise<FetchRequestConfig | void>;
+    validateStatus?: (status: number, response: Response) => boolean;
+    getAuthToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    allowBodyForGetHead?: boolean;
 }
+interface FetchRequestConfig {
+    url: string;
+    init: RequestInit;
+    headers: Headers;
+}
+interface FetchPromiseError {
+    reason: "Unauthorized" | "Timeout" | "Unknown";
+    details: unknown;
+    status?: number;
+    response?: Response;
+    originalError?: unknown;
+}
+type FetchClientDefaults = Omit<FetchPromiseParams, "url" | "method"> & {
+    method?: string;
+};
 interface CancellablePromise<T = unknown> extends Promise<T> {
     cancel: () => void;
 }
@@ -12,6 +36,7 @@ interface CancellablePromise<T = unknown> extends Promise<T> {
  * @returns A promise with a `.cancel()` method that calls `AbortController.abort()`
  */
 declare const FetchPromise: <T = unknown>(params: FetchPromiseParams) => CancellablePromise<T>;
+declare const createFetchClient: (defaults?: FetchClientDefaults) => <T = unknown>(params: FetchPromiseParams) => CancellablePromise<T>;
 
 declare function useQueries(): {
     list: CancellablePromise<unknown>[];
@@ -42,4 +67,4 @@ declare const useRequest: <T = unknown>(fetchPromise: (() => CancellablePromise<
     response: T | null;
 };
 
-export { type CancellablePromise, FetchPromise, type FetchPromiseParams, type Status, statusEnum, useQueries, useRequest };
+export { type CancellablePromise, type FetchClientDefaults, FetchPromise, type FetchPromiseError, type FetchPromiseParams, type FetchRequestConfig, type Status, createFetchClient, statusEnum, useQueries, useRequest };

package/dist/index.d.ts

@@ -1,9 +1,33 @@
 interface FetchPromiseParams {
     url: string;
     method: string;
-    body?: object | null;
+    body?: unknown;
     respType?: "raw" | "json" | null;
+    headers?: HeadersInit | Record<string, string>;
+    timeoutMs?: number;
+    baseUrl?: string;
+    includeContentType?: boolean;
+    parseAs?: "json" | "raw" | "text" | "response";
+    onRequest?: (request: FetchRequestConfig) => FetchRequestConfig | void | Promise<FetchRequestConfig | void>;
+    validateStatus?: (status: number, response: Response) => boolean;
+    getAuthToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    allowBodyForGetHead?: boolean;
 }
+interface FetchRequestConfig {
+    url: string;
+    init: RequestInit;
+    headers: Headers;
+}
+interface FetchPromiseError {
+    reason: "Unauthorized" | "Timeout" | "Unknown";
+    details: unknown;
+    status?: number;
+    response?: Response;
+    originalError?: unknown;
+}
+type FetchClientDefaults = Omit<FetchPromiseParams, "url" | "method"> & {
+    method?: string;
+};
 interface CancellablePromise<T = unknown> extends Promise<T> {
     cancel: () => void;
 }
@@ -12,6 +36,7 @@ interface CancellablePromise<T = unknown> extends Promise<T> {
  * @returns A promise with a `.cancel()` method that calls `AbortController.abort()`
  */
 declare const FetchPromise: <T = unknown>(params: FetchPromiseParams) => CancellablePromise<T>;
+declare const createFetchClient: (defaults?: FetchClientDefaults) => <T = unknown>(params: FetchPromiseParams) => CancellablePromise<T>;
 
 declare function useQueries(): {
     list: CancellablePromise<unknown>[];
@@ -42,4 +67,4 @@ declare const useRequest: <T = unknown>(fetchPromise: (() => CancellablePromise<
     response: T | null;
 };
 
-export { type CancellablePromise, FetchPromise, type FetchPromiseParams, type Status, statusEnum, useQueries, useRequest };
+export { type CancellablePromise, type FetchClientDefaults, FetchPromise, type FetchPromiseError, type FetchPromiseParams, type FetchRequestConfig, type Status, createFetchClient, statusEnum, useQueries, useRequest };

package/dist/index.js

@@ -1,8 +1,25 @@
 "use strict";
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -21,6 +38,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   FetchPromise: () => FetchPromise_default,
+  createFetchClient: () => createFetchClient,
   statusEnum: () => statusEnum,
   useQueries: () => useQueries,
   useRequest: () => useRequest
@@ -28,39 +46,221 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/FetchPromise.ts
+var METHODS_WITH_DEFAULT_BODY = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var METHODS_WITHOUT_BODY = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var isBodyInitLike = (value) => {
+  if (typeof value === "string") return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && value instanceof FormData) return true;
+  if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) return true;
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) return true;
+  if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) return true;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value)) return true;
+  return false;
+};
+var mapParseMode = (parseAs, respType) => {
+  if (parseAs) return parseAs;
+  if (respType === "raw") return "raw";
+  return "json";
+};
+var mergeHeaders = (defaults, overrides) => {
+  const headers = new Headers(defaults != null ? defaults : {});
+  if (overrides) {
+    new Headers(overrides).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+};
+var resolveUrl = (url, baseUrl) => {
+  if (!baseUrl) return url;
+  if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(url) || url.startsWith("//")) {
+    return url;
+  }
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const normalizedPath = url.startsWith("/") ? url : `/${url}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+var parseJsonSafely = async (response) => {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const text = await response.text();
+  if (!text.trim()) {
+    return void 0;
+  }
+  return JSON.parse(text);
+};
+var normalizeErrorDetails = (error) => {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return error;
+};
 var FetchPromise = (params) => {
   const controller = new AbortController();
   const signal = controller.signal;
+  let timeoutId;
+  let timedOut = false;
+  let cancelled = false;
   const promise = new Promise(async function(resolve, reject) {
-    const headers = {
-      Accept: params.respType === "raw" ? "blob" : "application/json",
-      "Content-Type": "application/json"
-    };
-    await fetch(params.url, {
-      method: params.method,
-      signal,
-      headers,
-      body: JSON.stringify(params.body)
-    }).then((response) => {
+    try {
+      const method = params.method.toUpperCase();
+      const parseAs = mapParseMode(params.parseAs, params.respType);
+      const headers = mergeHeaders(void 0, params.headers);
+      if (!headers.has("Accept")) {
+        if (parseAs === "raw") {
+          headers.set("Accept", "blob");
+        } else if (parseAs === "json") {
+          headers.set("Accept", "application/json");
+        } else {
+          headers.set("Accept", "*/*");
+        }
+      }
+      if (!headers.has("Authorization") && params.getAuthToken) {
+        const token = await params.getAuthToken();
+        if (token) {
+          headers.set("Authorization", `Bearer ${token}`);
+        }
+      }
+      const hasBodyValue = params.body !== void 0 && params.body !== null;
+      const allowsBody = !METHODS_WITHOUT_BODY.has(method) || params.allowBodyForGetHead === true;
+      const shouldSendBody = hasBodyValue && allowsBody;
+      let body;
+      let isJsonBody = false;
+      if (shouldSendBody) {
+        if (isBodyInitLike(params.body)) {
+          body = params.body;
+        } else {
+          body = JSON.stringify(params.body);
+          isJsonBody = true;
+        }
+      }
+      if (shouldSendBody && isJsonBody && params.includeContentType !== false && !headers.has("Content-Type") && METHODS_WITH_DEFAULT_BODY.has(method)) {
+        headers.set("Content-Type", "application/json");
+      }
+      const requestConfig = {
+        url: resolveUrl(params.url, params.baseUrl),
+        init: {
+          method,
+          signal,
+          headers,
+          body
+        },
+        headers
+      };
+      if (params.onRequest) {
+        const maybeUpdatedConfig = await params.onRequest(requestConfig);
+        if (maybeUpdatedConfig) {
+          requestConfig.url = maybeUpdatedConfig.url;
+          requestConfig.init = maybeUpdatedConfig.init;
+          requestConfig.headers = maybeUpdatedConfig.headers;
+        }
+      }
+      if (typeof params.timeoutMs === "number" && params.timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, params.timeoutMs);
+      }
+      const response = await fetch(requestConfig.url, __spreadProps(__spreadValues({}, requestConfig.init), {
+        signal,
+        headers: requestConfig.headers
+      }));
       if (response.status === 401) {
-        reject({ reason: "Unauthorized", details: response });
+        reject({ reason: "Unauthorized", details: response, status: 401, response });
+        return;
       }
-      if (!response.ok) {
-        throw new Error(response.statusText);
+      const isValid = params.validateStatus ? params.validateStatus(response.status, response) : response.ok;
+      if (!isValid) {
+        reject({
+          reason: "Unknown",
+          details: {
+            status: response.status,
+            statusText: response.statusText,
+            response
+          },
+          status: response.status,
+          response
+        });
+        return;
       }
-      if (params.respType === "raw") {
-        return response.blob();
+      if (parseAs === "response") {
+        resolve(response);
+        return;
       }
-      return response.json();
-    }).then((data) => {
-      if (data !== void 0) resolve(data);
-    }).catch((error) => {
-      reject({ reason: "Unknown", details: error });
-    });
+      if (parseAs === "raw") {
+        resolve(await response.blob());
+        return;
+      }
+      if (parseAs === "text") {
+        resolve(await response.text());
+        return;
+      }
+      resolve(await parseJsonSafely(response));
+    } catch (error) {
+      if (timedOut && (error == null ? void 0 : error.name) === "AbortError") {
+        reject({
+          reason: "Timeout",
+          details: {
+            timeoutMs: params.timeoutMs,
+            abortError: normalizeErrorDetails(error)
+          },
+          originalError: error
+        });
+        return;
+      }
+      reject({
+        reason: "Unknown",
+        details: normalizeErrorDetails(error),
+        originalError: error
+      });
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
   });
-  promise.cancel = () => controller.abort();
+  promise.cancel = () => {
+    if (cancelled) return;
+    cancelled = true;
+    controller.abort();
+  };
   return promise;
 };
+var createFetchClient = (defaults = {}) => {
+  return (params) => {
+    var _a, _b, _c, _d;
+    const runDefaultOnRequest = defaults.onRequest;
+    const runParamOnRequest = params.onRequest;
+    return FetchPromise(__spreadProps(__spreadValues(__spreadValues({}, defaults), params), {
+      method: (_b = (_a = params.method) != null ? _a : defaults.method) != null ? _b : "GET",
+      headers: mergeHeaders(defaults.headers, params.headers),
+      onRequest: async (request) => {
+        let nextRequest = request;
+        if (runDefaultOnRequest) {
+          const maybeDefaultUpdated = await runDefaultOnRequest(nextRequest);
+          if (maybeDefaultUpdated) {
+            nextRequest = maybeDefaultUpdated;
+          }
+        }
+        if (runParamOnRequest) {
+          const maybeParamUpdated = await runParamOnRequest(nextRequest);
+          if (maybeParamUpdated) {
+            nextRequest = maybeParamUpdated;
+          }
+        }
+        return nextRequest;
+      },
+      validateStatus: (_c = params.validateStatus) != null ? _c : defaults.validateStatus,
+      getAuthToken: (_d = params.getAuthToken) != null ? _d : defaults.getAuthToken
+    }));
+  };
+};
 var FetchPromise_default = FetchPromise;
 
 // src/useQueries.ts
@@ -121,6 +321,7 @@ var useRequest = (fetchPromise, disableCache = false) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FetchPromise,
+  createFetchClient,
   statusEnum,
   useQueries,
   useRequest

package/dist/index.mjs

@@ -1,37 +1,239 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
 // src/FetchPromise.ts
+var METHODS_WITH_DEFAULT_BODY = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var METHODS_WITHOUT_BODY = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var isBodyInitLike = (value) => {
+  if (typeof value === "string") return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && value instanceof FormData) return true;
+  if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) return true;
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) return true;
+  if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) return true;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value)) return true;
+  return false;
+};
+var mapParseMode = (parseAs, respType) => {
+  if (parseAs) return parseAs;
+  if (respType === "raw") return "raw";
+  return "json";
+};
+var mergeHeaders = (defaults, overrides) => {
+  const headers = new Headers(defaults != null ? defaults : {});
+  if (overrides) {
+    new Headers(overrides).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+};
+var resolveUrl = (url, baseUrl) => {
+  if (!baseUrl) return url;
+  if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(url) || url.startsWith("//")) {
+    return url;
+  }
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const normalizedPath = url.startsWith("/") ? url : `/${url}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+var parseJsonSafely = async (response) => {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const text = await response.text();
+  if (!text.trim()) {
+    return void 0;
+  }
+  return JSON.parse(text);
+};
+var normalizeErrorDetails = (error) => {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return error;
+};
 var FetchPromise = (params) => {
   const controller = new AbortController();
   const signal = controller.signal;
+  let timeoutId;
+  let timedOut = false;
+  let cancelled = false;
   const promise = new Promise(async function(resolve, reject) {
-    const headers = {
-      Accept: params.respType === "raw" ? "blob" : "application/json",
-      "Content-Type": "application/json"
-    };
-    await fetch(params.url, {
-      method: params.method,
-      signal,
-      headers,
-      body: JSON.stringify(params.body)
-    }).then((response) => {
+    try {
+      const method = params.method.toUpperCase();
+      const parseAs = mapParseMode(params.parseAs, params.respType);
+      const headers = mergeHeaders(void 0, params.headers);
+      if (!headers.has("Accept")) {
+        if (parseAs === "raw") {
+          headers.set("Accept", "blob");
+        } else if (parseAs === "json") {
+          headers.set("Accept", "application/json");
+        } else {
+          headers.set("Accept", "*/*");
+        }
+      }
+      if (!headers.has("Authorization") && params.getAuthToken) {
+        const token = await params.getAuthToken();
+        if (token) {
+          headers.set("Authorization", `Bearer ${token}`);
+        }
+      }
+      const hasBodyValue = params.body !== void 0 && params.body !== null;
+      const allowsBody = !METHODS_WITHOUT_BODY.has(method) || params.allowBodyForGetHead === true;
+      const shouldSendBody = hasBodyValue && allowsBody;
+      let body;
+      let isJsonBody = false;
+      if (shouldSendBody) {
+        if (isBodyInitLike(params.body)) {
+          body = params.body;
+        } else {
+          body = JSON.stringify(params.body);
+          isJsonBody = true;
+        }
+      }
+      if (shouldSendBody && isJsonBody && params.includeContentType !== false && !headers.has("Content-Type") && METHODS_WITH_DEFAULT_BODY.has(method)) {
+        headers.set("Content-Type", "application/json");
+      }
+      const requestConfig = {
+        url: resolveUrl(params.url, params.baseUrl),
+        init: {
+          method,
+          signal,
+          headers,
+          body
+        },
+        headers
+      };
+      if (params.onRequest) {
+        const maybeUpdatedConfig = await params.onRequest(requestConfig);
+        if (maybeUpdatedConfig) {
+          requestConfig.url = maybeUpdatedConfig.url;
+          requestConfig.init = maybeUpdatedConfig.init;
+          requestConfig.headers = maybeUpdatedConfig.headers;
+        }
+      }
+      if (typeof params.timeoutMs === "number" && params.timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, params.timeoutMs);
+      }
+      const response = await fetch(requestConfig.url, __spreadProps(__spreadValues({}, requestConfig.init), {
+        signal,
+        headers: requestConfig.headers
+      }));
       if (response.status === 401) {
-        reject({ reason: "Unauthorized", details: response });
+        reject({ reason: "Unauthorized", details: response, status: 401, response });
+        return;
       }
-      if (!response.ok) {
-        throw new Error(response.statusText);
+      const isValid = params.validateStatus ? params.validateStatus(response.status, response) : response.ok;
+      if (!isValid) {
+        reject({
+          reason: "Unknown",
+          details: {
+            status: response.status,
+            statusText: response.statusText,
+            response
+          },
+          status: response.status,
+          response
+        });
+        return;
       }
-      if (params.respType === "raw") {
-        return response.blob();
+      if (parseAs === "response") {
+        resolve(response);
+        return;
       }
-      return response.json();
-    }).then((data) => {
-      if (data !== void 0) resolve(data);
-    }).catch((error) => {
-      reject({ reason: "Unknown", details: error });
-    });
+      if (parseAs === "raw") {
+        resolve(await response.blob());
+        return;
+      }
+      if (parseAs === "text") {
+        resolve(await response.text());
+        return;
+      }
+      resolve(await parseJsonSafely(response));
+    } catch (error) {
+      if (timedOut && (error == null ? void 0 : error.name) === "AbortError") {
+        reject({
+          reason: "Timeout",
+          details: {
+            timeoutMs: params.timeoutMs,
+            abortError: normalizeErrorDetails(error)
+          },
+          originalError: error
+        });
+        return;
+      }
+      reject({
+        reason: "Unknown",
+        details: normalizeErrorDetails(error),
+        originalError: error
+      });
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
   });
-  promise.cancel = () => controller.abort();
+  promise.cancel = () => {
+    if (cancelled) return;
+    cancelled = true;
+    controller.abort();
+  };
   return promise;
 };
+var createFetchClient = (defaults = {}) => {
+  return (params) => {
+    var _a, _b, _c, _d;
+    const runDefaultOnRequest = defaults.onRequest;
+    const runParamOnRequest = params.onRequest;
+    return FetchPromise(__spreadProps(__spreadValues(__spreadValues({}, defaults), params), {
+      method: (_b = (_a = params.method) != null ? _a : defaults.method) != null ? _b : "GET",
+      headers: mergeHeaders(defaults.headers, params.headers),
+      onRequest: async (request) => {
+        let nextRequest = request;
+        if (runDefaultOnRequest) {
+          const maybeDefaultUpdated = await runDefaultOnRequest(nextRequest);
+          if (maybeDefaultUpdated) {
+            nextRequest = maybeDefaultUpdated;
+          }
+        }
+        if (runParamOnRequest) {
+          const maybeParamUpdated = await runParamOnRequest(nextRequest);
+          if (maybeParamUpdated) {
+            nextRequest = maybeParamUpdated;
+          }
+        }
+        return nextRequest;
+      },
+      validateStatus: (_c = params.validateStatus) != null ? _c : defaults.validateStatus,
+      getAuthToken: (_d = params.getAuthToken) != null ? _d : defaults.getAuthToken
+    }));
+  };
+};
 var FetchPromise_default = FetchPromise;
 
 // src/useQueries.ts
@@ -91,6 +293,7 @@ var useRequest = (fetchPromise, disableCache = false) => {
 };
 export {
   FetchPromise_default as FetchPromise,
+  createFetchClient,
   statusEnum,
   useQueries,
   useRequest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-fetch-utils",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Lightweight React hooks and utilities for fetch requests with cancellation support",
   "main": "./dist/index.js",
   "scripts": {