@happy-ts/fetch-t 1.9.1 → 1.10.0

package/dist/main.mjs

@@ -1,316 +1,513 @@
-import { Err, Ok } from 'happy-rusty';
-
+import { Err, Ok } from "happy-rusty";
+//#region src/fetch/constants.ts
+/**
+* Error name for aborted fetch requests.
+*
+* This matches the standard `AbortError` name used by the Fetch API when a request
+* is cancelled via `AbortController.abort()`.
+*
+* @since 1.0.0
+* @example
+* ```typescript
+* import { fetchT, ABORT_ERROR } from '@happy-ts/fetch-t';
+*
+* const task = fetchT('https://api.example.com/data', { abortable: true });
+* task.abort();
+*
+* const result = await task.result;
+* result.inspectErr((err) => {
+*     if (err.name === ABORT_ERROR) {
+*         console.log('Request was aborted');
+*     }
+* });
+* ```
+*/
 const ABORT_ERROR = "AbortError";
+/**
+* Error name for timed out fetch requests.
+*
+* This is set on the `Error.name` property when a request exceeds the specified
+* `timeout` duration and is automatically aborted.
+*
+* @since 1.0.0
+* @example
+* ```typescript
+* import { fetchT, TIMEOUT_ERROR } from '@happy-ts/fetch-t';
+*
+* const result = await fetchT('https://api.example.com/slow-endpoint', {
+*     timeout: 5000, // 5 seconds
+* });
+*
+* result.inspectErr((err) => {
+*     if (err.name === TIMEOUT_ERROR) {
+*         console.log('Request timed out after 5 seconds');
+*     }
+* });
+* ```
+*/
 const TIMEOUT_ERROR = "TimeoutError";
-
-class FetchError extends Error {
-  /**
-   * The error name, always `'FetchError'`.
-   */
-  name = "FetchError";
-  /**
-   * The HTTP status code of the response (e.g., 404, 500).
-   */
-  status;
-  /**
-   * Creates a new FetchError instance.
-   *
-   * @param message - The status text from the HTTP response (e.g., "Not Found").
-   * @param status - The HTTP status code (e.g., 404).
-   */
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
+//#endregion
+//#region src/fetch/defines.ts
+/**
+* Custom error class for HTTP error responses (non-2xx status codes).
+*
+* Thrown when `Response.ok` is `false`. Contains the HTTP status code
+* for programmatic error handling.
+*
+* @since 1.0.0
+* @example
+* ```typescript
+* import { fetchT, FetchError } from '@happy-ts/fetch-t';
+*
+* const result = await fetchT('https://api.example.com/not-found', {
+*     responseType: 'json',
+* });
+*
+* result.inspectErr((err) => {
+*     if (err instanceof FetchError) {
+*         console.log('HTTP Status:', err.status);  // e.g., 404
+*         console.log('Status Text:', err.message); // e.g., "Not Found"
+*
+*         // Handle specific status codes
+*         switch (err.status) {
+*             case 401:
+*                 console.log('Unauthorized - please login');
+*                 break;
+*             case 404:
+*                 console.log('Resource not found');
+*                 break;
+*             case 500:
+*                 console.log('Server error');
+*                 break;
+*         }
+*     }
+* });
+* ```
+*/
+var FetchError = class extends Error {
+	/**
+	* The error name, always `'FetchError'`.
+	*/
+	name = "FetchError";
+	/**
+	* The HTTP status code of the response (e.g., 404, 500).
+	*/
+	status;
+	/**
+	* Creates a new FetchError instance.
+	*
+	* @param message - The status text from the HTTP response (e.g., "Not Found").
+	* @param status - The HTTP status code (e.g., 404).
+	*/
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+	}
+};
+//#endregion
+//#region src/fetch/polyfills.ts
+/**
+* @internal
+* Polyfills for AbortSignal and related APIs.
+*/
+/**
+* Creates an AbortSignal that aborts after the specified timeout.
+* Uses native `AbortSignal.timeout` when available, otherwise falls back to a manual implementation.
+*/
+function signalTimeout(ms) {
+	if (typeof AbortSignal.timeout === "function") return AbortSignal.timeout(ms);
+	const controller = new AbortController();
+	const timeoutError = createTimeoutError();
+	const timerId = setTimeout(() => {
+		controller.abort(timeoutError);
+	}, ms);
+	if (typeof timerId?.unref === "function") timerId.unref();
+	return controller.signal;
 }
-
+/**
+* Creates an AbortSignal that aborts when any of the provided signals abort.
+* Uses native `AbortSignal.any` when available, otherwise falls back to a manual implementation.
+*
+* The polyfill properly cleans up event listeners on all signals when one fires,
+* preventing memory leaks from long-lived signals.
+*/
+function signalAny(signals) {
+	if (typeof AbortSignal.any === "function") return AbortSignal.any(signals);
+	const controller = new AbortController();
+	for (const signal of signals) if (signal.aborted) {
+		controller.abort(signal.reason);
+		return controller.signal;
+	}
+	const onAbort = (event) => {
+		controller.abort(event.target.reason);
+	};
+	const cleanup = () => {
+		for (const signal of signals) signal.removeEventListener("abort", onAbort);
+	};
+	for (const signal of signals) signal.addEventListener("abort", onAbort);
+	controller.signal.addEventListener("abort", cleanup);
+	return controller.signal;
+}
+/**
+* Creates a DOMException with TimeoutError name.
+* Falls back to a plain Error in environments where DOMException constructor is unavailable.
+*/
+function createTimeoutError() {
+	const message = "The operation timed out.";
+	try {
+		return new DOMException(message, TIMEOUT_ERROR);
+	} catch {
+		const error = new Error(message);
+		error.name = TIMEOUT_ERROR;
+		return error;
+	}
+}
+//#endregion
+//#region src/fetch/fetch.ts
+/**
+* Enhanced fetch function that wraps the native Fetch API with additional capabilities.
+*
+* Features:
+* - **Abortable requests**: Set `abortable: true` to get a `FetchTask` with `abort()` method.
+* - **Type-safe responses**: Use `responseType` to automatically parse responses as text, JSON, ArrayBuffer, Blob, bytes, or stream.
+* - **Timeout support**: Set `timeout` in milliseconds to auto-abort long-running requests.
+* - **Progress tracking**: Use `onProgress` callback to track download progress (requires Content-Length header).
+* - **Chunk streaming**: Use `onChunk` callback to receive raw data chunks as they arrive.
+* - **Retry support**: Use `retry` to automatically retry failed requests with configurable delay and conditions.
+* - **Result type error handling**: Returns `Result<T, Error>` instead of throwing exceptions for runtime errors.
+*
+* **Note**: Invalid parameters throw synchronously (fail-fast) rather than returning rejected Promises.
+* This differs from native `fetch` behavior and helps catch programming errors during development.
+*
+* @typeParam T - The expected type of the response data.
+* @param url - The resource to fetch. Can be a URL object or a string representing a URL.
+* @param init - Additional options for the fetch operation, extending standard `RequestInit` with custom properties.
+* @returns A `FetchTask<T>` if `abortable: true`, otherwise a `FetchResult<T>` (which is `AsyncIOResult<T>`).
+* @throws {TypeError} If `url` is invalid or a relative URL in non-browser environment.
+* @throws {TypeError} If `responseType` is not a valid response type.
+* @throws {TypeError} If `timeout` is not a number.
+* @throws {Error} If `timeout` is not greater than 0.
+* @throws {TypeError} If `onProgress` or `onChunk` is provided but not a function.
+* @throws {TypeError} If `retry.retries` is not an integer.
+* @throws {Error} If `retry.retries` is negative.
+* @throws {TypeError} If `retry.delay` is not a number or function.
+* @throws {Error} If `retry.delay` is a negative number.
+* @throws {TypeError} If `retry.when` is not an array or function.
+* @throws {TypeError} If `retry.onRetry` is provided but not a function.
+* @since 1.0.0
+* @example
+* // Basic GET request - returns Response object wrapped in Result
+* const result = await fetchT('https://api.example.com/data');
+* result
+*     .inspect((res) => console.log('Status:', res.status))
+*     .inspectErr((err) => console.error('Error:', err));
+*
+* @example
+* // GET JSON with type safety
+* interface User {
+*     id: number;
+*     name: string;
+* }
+* const result = await fetchT<User>('https://api.example.com/user/1', {
+*     responseType: 'json',
+* });
+* result.inspect((user) => console.log(user.name));
+*
+* @example
+* // POST request with JSON body
+* const result = await fetchT<User>('https://api.example.com/users', {
+*     method: 'POST',
+*     headers: { 'Content-Type': 'application/json' },
+*     body: JSON.stringify({ name: 'John' }),
+*     responseType: 'json',
+* });
+*
+* @example
+* // Abortable request with timeout
+* const task = fetchT('https://api.example.com/data', {
+*     abortable: true,
+*     timeout: 5000, // 5 seconds
+* });
+*
+* // Cancel the request if needed
+* task.abort('User cancelled');
+*
+* // Check if aborted
+* console.log('Aborted:', task.aborted);
+*
+* // Wait for result
+* const result = await task.result;
+*
+* @example
+* // Track download progress
+* const result = await fetchT('https://example.com/large-file.zip', {
+*     responseType: 'blob',
+*     onProgress: (progressResult) => {
+*         progressResult
+*             .inspect(({ completedByteLength, totalByteLength }) => {
+*                 const percent = ((completedByteLength / totalByteLength) * 100).toFixed(1);
+*                 console.log(`Progress: ${percent}%`);
+*             })
+*             .inspectErr((err) => console.warn('Progress unavailable:', err.message));
+*     },
+* });
+*
+* @example
+* // Stream data chunks
+* const chunks: Uint8Array[] = [];
+* const result = await fetchT('https://example.com/stream', {
+*     onChunk: (chunk) => chunks.push(chunk),
+* });
+*
+* @example
+* // Retry with exponential backoff
+* const result = await fetchT('https://api.example.com/data', {
+*     retry: {
+*         retries: 3,
+*         delay: (attempt) => Math.min(1000 * Math.pow(2, attempt - 1), 10000),
+*         when: [500, 502, 503, 504],
+*         onRetry: (error, attempt) => console.log(`Retry ${attempt}: ${error.message}`),
+*     },
+*     responseType: 'json',
+* });
+*/
 function fetchT(url, init) {
-  const parsedUrl = validateUrl(url);
-  const fetchInit = init ?? {};
-  const {
-    retries,
-    delay: retryDelay,
-    when: retryWhen,
-    onRetry
-  } = validateOptions(fetchInit);
-  const {
-    // default not abortable
-    abortable = false,
-    responseType,
-    timeout,
-    onProgress,
-    onChunk,
-    ...rest
-  } = fetchInit;
-  const userSignal = rest.signal;
-  let userController;
-  if (abortable) {
-    userController = new AbortController();
-  }
-  const shouldRetry = (error, attempt) => {
-    if (error.name === ABORT_ERROR) {
-      return false;
-    }
-    if (!retryWhen) {
-      return !(error instanceof FetchError);
-    }
-    if (Array.isArray(retryWhen)) {
-      return error instanceof FetchError && retryWhen.includes(error.status);
-    }
-    return retryWhen(error, attempt);
-  };
-  const getRetryDelay = (attempt) => {
-    return typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
-  };
-  const configureSignal = () => {
-    const signals = [];
-    if (userSignal) {
-      signals.push(userSignal);
-    }
-    if (userController) {
-      signals.push(userController.signal);
-    }
-    if (typeof timeout === "number") {
-      signals.push(AbortSignal.timeout(timeout));
-    }
-    if (signals.length > 0) {
-      rest.signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
-    }
-  };
-  const doFetch = async () => {
-    configureSignal();
-    try {
-      const response = await fetch(parsedUrl, rest);
-      if (!response.ok) {
-        response.body?.cancel().catch(() => {
-        });
-        return Err(new FetchError(response.statusText, response.status));
-      }
-      return await processResponse(response);
-    } catch (err) {
-      return Err(
-        err instanceof Error ? err : wrapAbortReason(err)
-      );
-    }
-  };
-  const setupProgressCallbacks = async (response) => {
-    let totalByteLength;
-    let completedByteLength = 0;
-    if (onProgress) {
-      const contentLength = response.headers.get("content-length");
-      if (contentLength == null) {
-        try {
-          onProgress(Err(new Error("No content-length in response headers")));
-        } catch {
-        }
-      } else {
-        totalByteLength = Number.parseInt(contentLength, 10);
-      }
-    }
-    const body = response.clone().body;
-    try {
-      for await (const chunk of body) {
-        if (onChunk) {
-          try {
-            onChunk(chunk);
-          } catch {
-          }
-        }
-        if (onProgress && totalByteLength != null) {
-          completedByteLength += chunk.byteLength;
-          try {
-            onProgress(Ok({
-              totalByteLength,
-              completedByteLength
-            }));
-          } catch {
-          }
-        }
-      }
-    } catch {
-    }
-  };
-  const processResponse = async (response) => {
-    if (response.body && (onProgress || onChunk)) {
-      setupProgressCallbacks(response);
-    }
-    switch (responseType) {
-      case "json": {
-        if (response.body == null) {
-          return Ok(null);
-        }
-        try {
-          return Ok(await response.json());
-        } catch {
-          return Err(new Error("Response is invalid json while responseType is json"));
-        }
-      }
-      case "text": {
-        return Ok(await response.text());
-      }
-      case "bytes": {
-        if (typeof response.bytes === "function") {
-          return Ok(await response.bytes());
-        }
-        return Ok(new Uint8Array(await response.arrayBuffer()));
-      }
-      case "arraybuffer": {
-        return Ok(await response.arrayBuffer());
-      }
-      case "blob": {
-        return Ok(await response.blob());
-      }
-      case "stream": {
-        return Ok(response.body);
-      }
-      default: {
-        return Ok(response);
-      }
-    }
-  };
-  const fetchWithRetry = async () => {
-    let lastError;
-    let attempt = 0;
-    do {
-      if (attempt > 0) {
-        if (userController?.signal.aborted) {
-          return Err(userController.signal.reason);
-        }
-        const delayMs = getRetryDelay(attempt);
-        if (delayMs > 0) {
-          await delay(delayMs);
-          if (userController?.signal.aborted) {
-            return Err(userController.signal.reason);
-          }
-        }
-        try {
-          onRetry?.(lastError, attempt);
-        } catch {
-        }
-      }
-      const result2 = await doFetch();
-      if (result2.isOk()) {
-        return result2;
-      }
-      lastError = result2.unwrapErr();
-      attempt++;
-    } while (attempt <= retries && shouldRetry(lastError, attempt));
-    return Err(lastError);
-  };
-  const result = fetchWithRetry();
-  if (abortable && userController) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      abort(reason) {
-        if (reason instanceof Error) {
-          userController.abort(reason);
-        } else if (reason != null) {
-          userController.abort(wrapAbortReason(reason));
-        } else {
-          userController.abort();
-        }
-      },
-      get aborted() {
-        return userController.signal.aborted;
-      },
-      get result() {
-        return result;
-      }
-    };
-  }
-  return result;
+	const parsedUrl = validateUrl(url);
+	const fetchInit = init ?? {};
+	const { retries, delay: retryDelay, when: retryWhen, onRetry } = validateOptions(fetchInit);
+	const { abortable = false, responseType, timeout, onProgress, onChunk, ...rest } = fetchInit;
+	const userSignal = rest.signal;
+	let userController;
+	if (abortable) userController = new AbortController();
+	/**
+	* Determines if the error should trigger a retry.
+	* By default, only network errors (not FetchError) trigger retries.
+	*/
+	const shouldRetry = (error, attempt) => {
+		if (error.name === "AbortError") return false;
+		if (!retryWhen) return !(error instanceof FetchError);
+		if (Array.isArray(retryWhen)) return error instanceof FetchError && retryWhen.includes(error.status);
+		return retryWhen(error, attempt);
+	};
+	/**
+	* Calculates the delay before the next retry attempt.
+	*/
+	const getRetryDelay = (attempt) => {
+		return typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+	};
+	/**
+	* Configures the abort signal for a fetch attempt.
+	*
+	* Combines multiple signals:
+	* - User's external signal (from init.signal)
+	* - Internal abort controller signal (for abortable requests)
+	* - Timeout signal (creates a new one each call for per-attempt timeout)
+	*
+	* Must be called before each fetch attempt to ensure fresh timeout signal on retries.
+	*/
+	const configureSignal = () => {
+		const signals = [];
+		if (userSignal) signals.push(userSignal);
+		if (userController) signals.push(userController.signal);
+		if (typeof timeout === "number") signals.push(signalTimeout(timeout));
+		if (signals.length > 0) rest.signal = signals.length === 1 ? signals[0] : signalAny(signals);
+	};
+	/**
+	* Performs a single fetch attempt with optional timeout.
+	*/
+	const doFetch = async () => {
+		configureSignal();
+		try {
+			const response = await fetch(parsedUrl, rest);
+			if (!response.ok) {
+				response.body?.cancel().catch(() => {});
+				return Err(new FetchError(response.statusText, response.status));
+			}
+			return await processResponse(response);
+		} catch (err) {
+			return Err(err instanceof Error ? err : wrapAbortReason(err));
+		}
+	};
+	/**
+	* Sets up progress tracking and chunk callbacks using a cloned response.
+	* The original response is returned unchanged for further processing.
+	*/
+	const setupProgressCallbacks = async (response) => {
+		let totalByteLength;
+		let completedByteLength = 0;
+		if (onProgress) {
+			const contentLength = response.headers.get("content-length");
+			if (contentLength == null) try {
+				onProgress(Err(/* @__PURE__ */ new Error("No content-length in response headers")));
+			} catch {}
+			else totalByteLength = Number.parseInt(contentLength, 10);
+		}
+		const body = response.clone().body;
+		try {
+			for await (const chunk of body) {
+				if (onChunk) try {
+					onChunk(chunk);
+				} catch {}
+				if (onProgress && totalByteLength != null) {
+					completedByteLength += chunk.byteLength;
+					try {
+						onProgress(Ok({
+							totalByteLength,
+							completedByteLength
+						}));
+					} catch {}
+				}
+			}
+		} catch {}
+	};
+	/**
+	* Processes the response based on responseType and callbacks.
+	*/
+	const processResponse = async (response) => {
+		if (response.body && (onProgress || onChunk)) setupProgressCallbacks(response);
+		switch (responseType) {
+			case "json":
+				if (response.body == null) return Ok(null);
+				try {
+					return Ok(await response.json());
+				} catch {
+					return Err(/* @__PURE__ */ new Error("Response is invalid json while responseType is json"));
+				}
+			case "text": return Ok(await response.text());
+			case "bytes":
+				if (typeof response.bytes === "function") return Ok(await response.bytes());
+				return Ok(new Uint8Array(await response.arrayBuffer()));
+			case "arraybuffer": return Ok(await response.arrayBuffer());
+			case "blob": return Ok(await response.blob());
+			case "stream": return Ok(response.body);
+			default: return Ok(response);
+		}
+	};
+	/**
+	* Performs fetch with retry logic.
+	*/
+	const fetchWithRetry = async () => {
+		let lastError;
+		let attempt = 0;
+		do {
+			if (attempt > 0) {
+				if (userController?.signal.aborted) return Err(userController.signal.reason);
+				const delayMs = getRetryDelay(attempt);
+				if (delayMs > 0) {
+					await delay(delayMs);
+					if (userController?.signal.aborted) return Err(userController.signal.reason);
+				}
+				try {
+					onRetry?.(lastError, attempt);
+				} catch {}
+			}
+			const result = await doFetch();
+			if (result.isOk()) return result;
+			lastError = result.unwrapErr();
+			attempt++;
+		} while (attempt <= retries && shouldRetry(lastError, attempt));
+		return Err(lastError);
+	};
+	const result = fetchWithRetry();
+	if (abortable && userController) return {
+		abort(reason) {
+			if (reason instanceof Error) userController.abort(reason);
+			else if (reason != null) userController.abort(wrapAbortReason(reason));
+			else userController.abort();
+		},
+		get aborted() {
+			return userController.signal.aborted;
+		},
+		get result() {
+			return result;
+		}
+	};
+	return result;
 }
+/**
+* Delays execution for the specified number of milliseconds.
+*/
 function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+* Wraps a non-Error abort reason into an Error with ABORT_ERROR name.
+*/
 function wrapAbortReason(reason) {
-  const error = new Error(typeof reason === "string" ? reason : String(reason));
-  error.name = ABORT_ERROR;
-  error.cause = reason;
-  return error;
+	const error = new Error(typeof reason === "string" ? reason : String(reason));
+	error.name = ABORT_ERROR;
+	error.cause = reason;
+	return error;
 }
+/**
+* Validates fetch options and parses retry configuration.
+*/
 function validateOptions(init) {
-  const {
-    responseType,
-    timeout,
-    retry: retryOptions = 0,
-    onProgress,
-    onChunk
-  } = init;
-  if (responseType != null) {
-    const validTypes = ["text", "arraybuffer", "blob", "json", "bytes", "stream"];
-    if (!validTypes.includes(responseType)) {
-      throw new TypeError(`responseType must be one of ${validTypes.join(", ")} but received ${responseType}`);
-    }
-  }
-  if (timeout != null) {
-    if (typeof timeout !== "number") {
-      throw new TypeError(`timeout must be a number but received ${typeof timeout}`);
-    }
-    if (timeout <= 0) {
-      throw new Error(`timeout must be a number greater than 0 but received ${timeout}`);
-    }
-  }
-  if (onProgress != null) {
-    if (typeof onProgress !== "function") {
-      throw new TypeError(`onProgress callback must be a function but received ${typeof onProgress}`);
-    }
-  }
-  if (onChunk != null) {
-    if (typeof onChunk !== "function") {
-      throw new TypeError(`onChunk callback must be a function but received ${typeof onChunk}`);
-    }
-  }
-  let retries = 0;
-  let delay2 = 0;
-  let when;
-  let onRetry;
-  if (typeof retryOptions === "number") {
-    retries = retryOptions;
-  } else if (retryOptions && typeof retryOptions === "object") {
-    retries = retryOptions.retries ?? 0;
-    delay2 = retryOptions.delay ?? 0;
-    when = retryOptions.when;
-    onRetry = retryOptions.onRetry;
-  }
-  if (!Number.isInteger(retries)) {
-    throw new TypeError(`Retry count must be an integer but received ${retries}`);
-  }
-  if (retries < 0) {
-    throw new Error(`Retry count must be non-negative but received ${retries}`);
-  }
-  if (typeof delay2 === "number") {
-    if (delay2 < 0) {
-      throw new Error(`Retry delay must be a non-negative number but received ${delay2}`);
-    }
-  } else {
-    if (typeof delay2 !== "function") {
-      throw new TypeError(`Retry delay must be a number or a function but received ${typeof delay2}`);
-    }
-  }
-  if (when != null) {
-    if (!Array.isArray(when) && typeof when !== "function") {
-      throw new TypeError(`Retry when condition must be an array of status codes or a function but received ${typeof when}`);
-    }
-  }
-  if (onRetry != null) {
-    if (typeof onRetry !== "function") {
-      throw new TypeError(`Retry onRetry callback must be a function but received ${typeof onRetry}`);
-    }
-  }
-  return { retries, delay: delay2, when, onRetry };
+	const { responseType, timeout, retry: retryOptions = 0, onProgress, onChunk } = init;
+	if (responseType != null) {
+		const validTypes = [
+			"text",
+			"arraybuffer",
+			"blob",
+			"json",
+			"bytes",
+			"stream"
+		];
+		if (!validTypes.includes(responseType)) throw new TypeError(`responseType must be one of ${validTypes.join(", ")} but received ${responseType}`);
+	}
+	if (timeout != null) {
+		if (typeof timeout !== "number") throw new TypeError(`timeout must be a number but received ${typeof timeout}`);
+		if (timeout <= 0) throw new Error(`timeout must be a number greater than 0 but received ${timeout}`);
+	}
+	if (onProgress != null) {
+		if (typeof onProgress !== "function") throw new TypeError(`onProgress callback must be a function but received ${typeof onProgress}`);
+	}
+	if (onChunk != null) {
+		if (typeof onChunk !== "function") throw new TypeError(`onChunk callback must be a function but received ${typeof onChunk}`);
+	}
+	let retries = 0;
+	let delay = 0;
+	let when;
+	let onRetry;
+	if (typeof retryOptions === "number") retries = retryOptions;
+	else if (retryOptions && typeof retryOptions === "object") {
+		retries = retryOptions.retries ?? 0;
+		delay = retryOptions.delay ?? 0;
+		when = retryOptions.when;
+		onRetry = retryOptions.onRetry;
+	}
+	if (!Number.isInteger(retries)) throw new TypeError(`Retry count must be an integer but received ${retries}`);
+	if (retries < 0) throw new Error(`Retry count must be non-negative but received ${retries}`);
+	if (typeof delay === "number") {
+		if (delay < 0) throw new Error(`Retry delay must be a non-negative number but received ${delay}`);
+	} else if (typeof delay !== "function") throw new TypeError(`Retry delay must be a number or a function but received ${typeof delay}`);
+	if (when != null) {
+		if (!Array.isArray(when) && typeof when !== "function") throw new TypeError(`Retry when condition must be an array of status codes or a function but received ${typeof when}`);
+	}
+	if (onRetry != null) {
+		if (typeof onRetry !== "function") throw new TypeError(`Retry onRetry callback must be a function but received ${typeof onRetry}`);
+	}
+	return {
+		retries,
+		delay,
+		when,
+		onRetry
+	};
 }
+/**
+* Validates and parses a URL string or URL object.
+* In browser environments, relative URLs are resolved against `location.href`.
+* In non-browser environments (Node/Deno/Bun), only absolute URLs are valid.
+*/
 function validateUrl(url) {
-  if (url instanceof URL) {
-    return url;
-  }
-  try {
-    const base = typeof location !== "undefined" ? location.href : void 0;
-    return new URL(url, base);
-  } catch {
-    throw new TypeError(`Invalid URL: ${url}`);
-  }
+	if (url instanceof URL) return url;
+	try {
+		return new URL(url, typeof location !== "undefined" ? location.href : void 0);
+	} catch {
+		throw new TypeError(`Invalid URL: ${url}`);
+	}
 }
-
+//#endregion
 export { ABORT_ERROR, FetchError, TIMEOUT_ERROR, fetchT };
-//# sourceMappingURL=main.mjs.map
+
+//# sourceMappingURL=main.mjs.map