@happy-ts/fetch-t 1.9.1 → 1.10.0

package/dist/main.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.mjs","sources":["../src/fetch/constants.ts","../src/fetch/defines.ts","../src/fetch/fetch.ts"],"sourcesContent":["/**\n * Error name for aborted fetch requests.\n *\n * This matches the standard `AbortError` name used by the Fetch API when a request\n * is cancelled via `AbortController.abort()`.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, ABORT_ERROR } from '@happy-ts/fetch-t';\n *\n * const task = fetchT('https://api.example.com/data', { abortable: true });\n * task.abort();\n *\n * const result = await task.result;\n * result.inspectErr((err) => {\n *     if (err.name === ABORT_ERROR) {\n *         console.log('Request was aborted');\n *     }\n * });\n * ```\n */\nexport const ABORT_ERROR = 'AbortError' as const;\n\n/**\n * Error name for timed out fetch requests.\n *\n * This is set on the `Error.name` property when a request exceeds the specified\n * `timeout` duration and is automatically aborted.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, TIMEOUT_ERROR } from '@happy-ts/fetch-t';\n *\n * const result = await fetchT('https://api.example.com/slow-endpoint', {\n *     timeout: 5000, // 5 seconds\n * });\n *\n * result.inspectErr((err) => {\n *     if (err.name === TIMEOUT_ERROR) {\n *         console.log('Request timed out after 5 seconds');\n *     }\n * });\n * ```\n */\nexport const TIMEOUT_ERROR = 'TimeoutError' as const;\n","import type { AsyncIOResult, IOResult } from 'happy-rusty';\n\n/**\n * Union type of all possible fetchT response data types.\n *\n * Used when `responseType` is a dynamic string value rather than a literal type,\n * as the exact return type cannot be determined at compile time.\n *\n * @since 1.9.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResponseData } from '@happy-ts/fetch-t';\n *\n * // When responseType is dynamic, return type is FetchResponseData\n * const responseType = getResponseType(); // returns string\n * const result = await fetchT('https://api.example.com/data', { responseType });\n * // result is Result<FetchResponseData, Error>\n * ```\n */\nexport type FetchResponseData =\n    | string\n    | ArrayBuffer\n    | Blob\n    | Uint8Array<ArrayBuffer>\n    | ReadableStream<Uint8Array<ArrayBuffer>>\n    | Response\n    | null;\n\n/**\n * Represents the result of a fetch operation as an async Result type.\n *\n * This is an alias for `AsyncIOResult<T>` from the `happy-rusty` library,\n * providing Rust-like error handling without throwing exceptions.\n *\n * @typeParam T - The type of the data expected in a successful response.\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResult } from '@happy-ts/fetch-t';\n *\n * // FetchResult is a Promise that resolves to Result<T, Error>\n * const result: FetchResult<string> = fetchT('https://api.example.com', {\n *     responseType: 'text',\n * });\n *\n * const res = await result;\n * res\n *     .inspect((text) => console.log('Success:', text))\n *     .inspectErr((err) => console.error('Error:', err));\n * ```\n */\nexport type FetchResult<T> = AsyncIOResult<T>;\n\n/**\n * Represents an abortable fetch operation with control methods.\n *\n * Returned when `abortable: true` is set in the fetch options. Provides\n * the ability to cancel the request and check its abort status.\n *\n * @typeParam T - The type of the data expected in the response.\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchTask } from '@happy-ts/fetch-t';\n *\n * interface User {\n *     id: number;\n *     name: string;\n * }\n *\n * const task: FetchTask<User> = fetchT<User>('https://api.example.com/user/1', {\n *     abortable: true,\n *     responseType: 'json',\n * });\n *\n * // Check if aborted\n * console.log('Is aborted:', task.aborted); // false\n *\n * // Abort with optional reason\n * task.abort('User navigated away');\n *\n * // Access the result (will be an error after abort)\n * const result = await task.result;\n * result.inspectErr((err) => console.log('Aborted:', err.message));\n * ```\n */\nexport interface FetchTask<T> {\n    /**\n     * Aborts the fetch task, optionally with a reason.\n     *\n     * Once aborted, the `result` promise will resolve to an `Err` containing\n     * an `AbortError`. The abort reason can be any value and will be passed\n     * to the underlying `AbortController.abort()`.\n     *\n     * @param reason - An optional value indicating why the task was aborted.\n     *                 This can be an Error, string, or any other value.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    abort(reason?: any): void;\n\n    /**\n     * Indicates whether the fetch task has been aborted.\n     *\n     * Returns `true` if `abort()` was called or if the request timed out.\n     */\n    readonly aborted: boolean;\n\n    /**\n     * The result promise of the fetch task.\n     *\n     * Resolves to `Ok<T>` on success, or `Err<Error>` on failure (including abort).\n     */\n    readonly result: FetchResult<T>;\n}\n\n/**\n * Specifies the expected response type for automatic parsing.\n *\n * - `'text'` - Parse response as string via `Response.text()`\n * - `'json'` - Parse response as JSON via `Response.json()`\n * - `'arraybuffer'` - Parse response as ArrayBuffer via `Response.arrayBuffer()`\n * - `'bytes'` - Parse response as Uint8Array<ArrayBuffer> via `Response.bytes()` (with fallback for older environments)\n * - `'blob'` - Parse response as Blob via `Response.blob()`\n * - `'stream'` - Return the raw `ReadableStream` for streaming processing\n *\n * If not specified, the raw `Response` object is returned.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResponseType } from '@happy-ts/fetch-t';\n *\n * const responseType: FetchResponseType = 'json';\n *\n * const result = await fetchT('https://api.example.com/data', { responseType });\n * ```\n */\nexport type FetchResponseType = 'text' | 'arraybuffer' | 'blob' | 'json' | 'bytes' | 'stream';\n\n/**\n * Represents the download progress of a fetch operation.\n *\n * Passed to the `onProgress` callback when tracking download progress.\n * Note: Progress tracking requires the server to send a `Content-Length` header.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchProgress } from '@happy-ts/fetch-t';\n *\n * await fetchT('https://example.com/file.zip', {\n *     responseType: 'blob',\n *     onProgress: (result) => {\n *         result.inspect((progress: FetchProgress) => {\n *             const percent = (progress.completedByteLength / progress.totalByteLength) * 100;\n *             console.log(`Downloaded: ${percent.toFixed(1)}%`);\n *         });\n *     },\n * });\n * ```\n */\nexport interface FetchProgress {\n    /**\n     * The total number of bytes to be received (from Content-Length header).\n     */\n    totalByteLength: number;\n\n    /**\n     * The number of bytes received so far.\n     */\n    completedByteLength: number;\n}\n\n/**\n * Options for configuring retry behavior.\n *\n * @since 1.8.0\n */\nexport interface FetchRetryOptions {\n    /**\n     * Number of times to retry the request on failure.\n     *\n     * By default, only network errors trigger retries. HTTP errors (4xx, 5xx)\n     * require explicit configuration via `when`.\n     *\n     * @default 0 (no retries)\n     */\n    retries?: number;\n\n    /**\n     * Delay between retry attempts in milliseconds.\n     *\n     * Can be a static number or a function for custom strategies like exponential backoff.\n     * The function receives the current attempt number (1-indexed).\n     *\n     * @default 0 (immediate retry)\n     */\n    delay?: number | ((attempt: number) => number);\n\n    /**\n     * Conditions under which to retry the request.\n     *\n     * Can be an array of HTTP status codes or a custom function.\n     * By default, only network errors (not FetchError) trigger retries.\n     */\n    when?: number[] | ((error: Error, attempt: number) => boolean);\n\n    /**\n     * Callback invoked before each retry attempt.\n     *\n     * Useful for logging, metrics, or adjusting request parameters.\n     */\n    onRetry?: (error: Error, attempt: number) => void;\n}\n\n/**\n * Extended fetch options that add additional capabilities to the standard `RequestInit`.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchInit } from '@happy-ts/fetch-t';\n *\n * const options: FetchInit = {\n *     // Standard RequestInit options\n *     method: 'POST',\n *     headers: { 'Content-Type': 'application/json' },\n *     body: JSON.stringify({ key: 'value' }),\n *\n *     // Extended options\n *     abortable: true,           // Return FetchTask for manual abort control\n *     responseType: 'json',      // Auto-parse response as JSON\n *     timeout: 10000,            // Abort after 10 seconds\n *     onProgress: (result) => {  // Track download progress\n *         result.inspect(({ completedByteLength, totalByteLength }) => {\n *             console.log(`${completedByteLength}/${totalByteLength}`);\n *         });\n *     },\n *     onChunk: (chunk) => {      // Receive raw data chunks\n *         console.log('Received chunk:', chunk.byteLength, 'bytes');\n *     },\n * };\n *\n * const task = fetchT('https://api.example.com/upload', options);\n * ```\n */\nexport interface FetchInit extends RequestInit {\n    /**\n     * When `true`, returns a `FetchTask` instead of `FetchResult`.\n     *\n     * The `FetchTask` provides `abort()` method and `aborted` status.\n     *\n     * @default false\n     */\n    abortable?: boolean;\n\n    /**\n     * Specifies how the response body should be parsed.\n     *\n     * - `'text'` - Returns `string`\n     * - `'json'` - Returns parsed JSON (type `T`)\n     * - `'arraybuffer'` - Returns `ArrayBuffer`\n     * - `'bytes'` - Returns `Uint8Array<ArrayBuffer>` (with fallback for older environments)\n     * - `'blob'` - Returns `Blob`\n     * - `'stream'` - Returns `ReadableStream<Uint8Array<ArrayBuffer>>`\n     * - `undefined` - Returns raw `Response` object\n     *\n     * When using a dynamic string value (not a literal type), the return type\n     * will be `FetchResponseData` (union of all possible types).\n     */\n    responseType?: FetchResponseType;\n\n    /**\n     * Maximum time in milliseconds to wait for the request to complete.\n     *\n     * If exceeded, the request is automatically aborted with a `TimeoutError`.\n     * Must be a positive number.\n     */\n    timeout?: number;\n\n    /**\n     * Retry options.\n     *\n     * Can be a number (shorthand for retries count) or an options object.\n     *\n     * @example\n     * ```typescript\n     * // Retry up to 3 times on network errors\n     * const result = await fetchT('https://api.example.com/data', {\n     *     retry: 3,\n     * });\n     *\n     * // Detailed configuration\n     * const result = await fetchT('https://api.example.com/data', {\n     *     retry: {\n     *         retries: 3,\n     *         delay: 1000,\n     *         when: [500, 502],\n     *         onRetry: (error, attempt) => console.log(error),\n     *     },\n     * });\n     * ```\n     */\n    retry?: number | FetchRetryOptions;\n\n    /**\n     * Callback invoked during download to report progress.\n     *\n     * Receives an `IOResult<FetchProgress>`:\n     * - `Ok(FetchProgress)` - Progress update with byte counts\n     * - `Err(Error)` - If `Content-Length` header is missing (called once)\n     *\n     * **Note**: This feature uses `response.clone()` internally. The cloned stream shares\n     * the same underlying data source (via `tee()`), so it does NOT double memory usage.\n     * However, if the two streams consume data at different speeds, chunks may be buffered\n     * temporarily until both streams have read them.\n     *\n     * @param progressResult - The progress result, either success with progress data or error.\n     */\n    onProgress?: (progressResult: IOResult<FetchProgress>) => void;\n\n    /**\n     * Callback invoked when a chunk of data is received.\n     *\n     * Useful for streaming or processing data as it arrives.\n     * Each chunk is a `Uint8Array<ArrayBuffer>` containing the raw bytes.\n     *\n     * **Note**: This feature uses `response.clone()` internally. The cloned stream shares\n     * the same underlying data source (via `tee()`), so it does NOT double memory usage.\n     * However, if the two streams consume data at different speeds, chunks may be buffered\n     * temporarily until both streams have read them.\n     *\n     * @param chunk - The raw data chunk received from the response stream.\n     */\n    onChunk?: (chunk: Uint8Array<ArrayBuffer>) => void;\n}\n\n/**\n * Custom error class for HTTP error responses (non-2xx status codes).\n *\n * Thrown when `Response.ok` is `false`. Contains the HTTP status code\n * for programmatic error handling.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, FetchError } from '@happy-ts/fetch-t';\n *\n * const result = await fetchT('https://api.example.com/not-found', {\n *     responseType: 'json',\n * });\n *\n * result.inspectErr((err) => {\n *     if (err instanceof FetchError) {\n *         console.log('HTTP Status:', err.status);  // e.g., 404\n *         console.log('Status Text:', err.message); // e.g., \"Not Found\"\n *\n *         // Handle specific status codes\n *         switch (err.status) {\n *             case 401:\n *                 console.log('Unauthorized - please login');\n *                 break;\n *             case 404:\n *                 console.log('Resource not found');\n *                 break;\n *             case 500:\n *                 console.log('Server error');\n *                 break;\n *         }\n *     }\n * });\n * ```\n */\nexport class FetchError extends Error {\n    /**\n     * The error name, always `'FetchError'`.\n     */\n    override name = 'FetchError';\n\n    /**\n     * The HTTP status code of the response (e.g., 404, 500).\n     */\n    status: number;\n\n    /**\n     * Creates a new FetchError instance.\n     *\n     * @param message - The status text from the HTTP response (e.g., \"Not Found\").\n     * @param status - The HTTP status code (e.g., 404).\n     */\n    constructor(message: string, status: number) {\n        super(message);\n        this.status = status;\n    }\n}\n","import { Err, Ok, type AsyncIOResult } from 'happy-rusty';\nimport { ABORT_ERROR } from './constants.ts';\nimport { FetchError, type FetchInit, type FetchResponseData, type FetchResponseType, type FetchResult, type FetchRetryOptions, type FetchTask } from './defines.ts';\n\n// #region Overload Declarations\n\n/**\n * Fetches a resource from the network as a text string and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'text'`.\n * @returns A `FetchTask` representing the abortable operation with a `string` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'text';\n}): FetchTask<string>;\n\n/**\n * Fetches a resource from the network as an ArrayBuffer and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'arraybuffer'`.\n * @returns A `FetchTask` representing the abortable operation with an `ArrayBuffer` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'arraybuffer';\n}): FetchTask<ArrayBuffer>;\n\n/**\n * Fetches a resource from the network as a Blob and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'blob'`.\n * @returns A `FetchTask` representing the abortable operation with a `Blob` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'blob';\n}): FetchTask<Blob>;\n\n/**\n * Fetches a resource from the network and parses it as JSON, returning an abortable `FetchTask`.\n *\n * @typeParam T - The expected type of the parsed JSON data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'json'`.\n * @returns A `FetchTask` representing the abortable operation with a response parsed as type `T`.\n */\nexport function fetchT<T>(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'json';\n}): FetchTask<T | null>;\n\n/**\n * Fetches a resource from the network as a ReadableStream and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'stream'`.\n * @returns A `FetchTask` representing the abortable operation with a `ReadableStream<Uint8Array<ArrayBuffer>>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'stream';\n}): FetchTask<ReadableStream<Uint8Array<ArrayBuffer>> | null>;\n\n/**\n * Fetches a resource from the network as a Uint8Array<ArrayBuffer> and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'bytes'`.\n * @returns A `FetchTask` representing the abortable operation with a `Uint8Array<ArrayBuffer>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'bytes';\n}): FetchTask<Uint8Array<ArrayBuffer>>;\n\n/**\n * Fetches a resource from the network and returns an abortable `FetchTask` with a dynamic response type.\n *\n * Use this overload when `responseType` is a `FetchResponseType` union type.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and a `FetchResponseType`.\n * @returns A `FetchTask` representing the abortable operation with a `FetchResponseData` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: FetchResponseType;\n}): FetchTask<FetchResponseData>;\n\n/**\n * Fetches a resource from the network as a text string.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'text'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `string` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'text';\n}): FetchResult<string>;\n\n/**\n * Fetches a resource from the network as an ArrayBuffer.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'arraybuffer'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with an `ArrayBuffer` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'arraybuffer';\n}): FetchResult<ArrayBuffer>;\n\n/**\n * Fetches a resource from the network as a Blob.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'blob'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Blob` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'blob';\n}): FetchResult<Blob>;\n\n/**\n * Fetches a resource from the network and parses it as JSON.\n *\n * @typeParam T - The expected type of the parsed JSON data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'json'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a response parsed as type `T`.\n */\nexport function fetchT<T>(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'json';\n}): FetchResult<T | null>;\n\n/**\n * Fetches a resource from the network as a ReadableStream.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'stream'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `ReadableStream<Uint8Array<ArrayBuffer>>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'stream';\n}): FetchResult<ReadableStream<Uint8Array<ArrayBuffer>> | null>;\n\n/**\n * Fetches a resource from the network as a Uint8Array<ArrayBuffer>.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'bytes'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Uint8Array<ArrayBuffer>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'bytes';\n}): FetchResult<Uint8Array<ArrayBuffer>>;\n\n/**\n * Fetches a resource from the network with a dynamic response type (non-abortable).\n *\n * Use this overload when `responseType` is a `FetchResponseType` union type.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation with a `FetchResponseType`, and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `FetchResponseData` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: FetchResponseType;\n}): FetchResult<FetchResponseData>;\n\n/**\n * Fetches a resource from the network and returns an abortable `FetchTask` with a generic `Response`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true`.\n * @returns A `FetchTask` representing the abortable operation with a `Response` object.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n}): FetchTask<Response>;\n\n/**\n * Fetches a resource from the network and returns a `FetchResult` with a generic `Response` object.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Optional additional options for the fetch operation, and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Response` object.\n */\nexport function fetchT(url: string | URL, init?: FetchInit & {\n    abortable?: false;\n}): FetchResult<Response>;\n\n/**\n * Fallback overload for when `FetchInit` is passed as a variable (not an object literal).\n *\n * When TypeScript cannot determine the literal value of `abortable` at compile time\n * (e.g., when passing a `FetchInit` variable), this overload is matched.\n * The return type is a union of `FetchTask` and `FetchResult`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Optional fetch options. When passed as a `FetchInit` variable, the return type is a union.\n * @returns Either a `FetchTask` or `FetchResult` depending on the runtime value of `abortable`.\n */\nexport function fetchT(url: string | URL, init?: FetchInit): FetchTask<FetchResponseData> | FetchResult<FetchResponseData>;\n\n// #endregion\n\n// #region Main Implementation\n\n/**\n * Enhanced fetch function that wraps the native Fetch API with additional capabilities.\n *\n * Features:\n * - **Abortable requests**: Set `abortable: true` to get a `FetchTask` with `abort()` method.\n * - **Type-safe responses**: Use `responseType` to automatically parse responses as text, JSON, ArrayBuffer, Blob, bytes, or stream.\n * - **Timeout support**: Set `timeout` in milliseconds to auto-abort long-running requests.\n * - **Progress tracking**: Use `onProgress` callback to track download progress (requires Content-Length header).\n * - **Chunk streaming**: Use `onChunk` callback to receive raw data chunks as they arrive.\n * - **Retry support**: Use `retry` to automatically retry failed requests with configurable delay and conditions.\n * - **Result type error handling**: Returns `Result<T, Error>` instead of throwing exceptions for runtime errors.\n *\n * **Note**: Invalid parameters throw synchronously (fail-fast) rather than returning rejected Promises.\n * This differs from native `fetch` behavior and helps catch programming errors during development.\n *\n * @typeParam T - The expected type of the response data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, extending standard `RequestInit` with custom properties.\n * @returns A `FetchTask<T>` if `abortable: true`, otherwise a `FetchResult<T>` (which is `AsyncIOResult<T>`).\n * @throws {TypeError} If `url` is invalid or a relative URL in non-browser environment.\n * @throws {TypeError} If `responseType` is not a valid response type.\n * @throws {TypeError} If `timeout` is not a number.\n * @throws {Error} If `timeout` is not greater than 0.\n * @throws {TypeError} If `onProgress` or `onChunk` is provided but not a function.\n * @throws {TypeError} If `retry.retries` is not an integer.\n * @throws {Error} If `retry.retries` is negative.\n * @throws {TypeError} If `retry.delay` is not a number or function.\n * @throws {Error} If `retry.delay` is a negative number.\n * @throws {TypeError} If `retry.when` is not an array or function.\n * @throws {TypeError} If `retry.onRetry` is provided but not a function.\n * @since 1.0.0\n * @example\n * // Basic GET request - returns Response object wrapped in Result\n * const result = await fetchT('https://api.example.com/data');\n * result\n *     .inspect((res) => console.log('Status:', res.status))\n *     .inspectErr((err) => console.error('Error:', err));\n *\n * @example\n * // GET JSON with type safety\n * interface User {\n *     id: number;\n *     name: string;\n * }\n * const result = await fetchT<User>('https://api.example.com/user/1', {\n *     responseType: 'json',\n * });\n * result.inspect((user) => console.log(user.name));\n *\n * @example\n * // POST request with JSON body\n * const result = await fetchT<User>('https://api.example.com/users', {\n *     method: 'POST',\n *     headers: { 'Content-Type': 'application/json' },\n *     body: JSON.stringify({ name: 'John' }),\n *     responseType: 'json',\n * });\n *\n * @example\n * // Abortable request with timeout\n * const task = fetchT('https://api.example.com/data', {\n *     abortable: true,\n *     timeout: 5000, // 5 seconds\n * });\n *\n * // Cancel the request if needed\n * task.abort('User cancelled');\n *\n * // Check if aborted\n * console.log('Aborted:', task.aborted);\n *\n * // Wait for result\n * const result = await task.result;\n *\n * @example\n * // Track download progress\n * const result = await fetchT('https://example.com/large-file.zip', {\n *     responseType: 'blob',\n *     onProgress: (progressResult) => {\n *         progressResult\n *             .inspect(({ completedByteLength, totalByteLength }) => {\n *                 const percent = ((completedByteLength / totalByteLength) * 100).toFixed(1);\n *                 console.log(`Progress: ${percent}%`);\n *             })\n *             .inspectErr((err) => console.warn('Progress unavailable:', err.message));\n *     },\n * });\n *\n * @example\n * // Stream data chunks\n * const chunks: Uint8Array[] = [];\n * const result = await fetchT('https://example.com/stream', {\n *     onChunk: (chunk) => chunks.push(chunk),\n * });\n *\n * @example\n * // Retry with exponential backoff\n * const result = await fetchT('https://api.example.com/data', {\n *     retry: {\n *         retries: 3,\n *         delay: (attempt) => Math.min(1000 * Math.pow(2, attempt - 1), 10000),\n *         when: [500, 502, 503, 504],\n *         onRetry: (error, attempt) => console.log(`Retry ${attempt}: ${error.message}`),\n *     },\n *     responseType: 'json',\n * });\n */\nexport function fetchT(url: string | URL, init?: FetchInit): FetchTask<FetchResponseData> | FetchResult<FetchResponseData> {\n    // Validate and parse URL\n    const parsedUrl = validateUrl(url);\n\n    const fetchInit = init ?? {};\n\n    const {\n        retries,\n        delay: retryDelay,\n        when: retryWhen,\n        onRetry,\n    } = validateOptions(fetchInit);\n\n    const {\n        // default not abortable\n        abortable = false,\n        responseType,\n        timeout,\n        onProgress,\n        onChunk,\n        ...rest\n    } = fetchInit;\n\n    // Preserve user's original signal before modifications (rest.signal will be reassigned in setSignal)\n    const userSignal = rest.signal;\n\n    // User controller for manual abort (stops all retries)\n    let userController: AbortController | undefined;\n    if (abortable) {\n        userController = new AbortController();\n    }\n\n    /**\n     * Determines if the error should trigger a retry.\n     * By default, only network errors (not FetchError) trigger retries.\n     */\n    const shouldRetry = (error: Error, attempt: number): boolean => {\n        // Never retry on user abort\n        if (error.name === ABORT_ERROR) {\n            return false;\n        }\n\n        if (!retryWhen) {\n            // Default: only retry on network errors (not FetchError/HTTP errors)\n            return !(error instanceof FetchError);\n        }\n\n        if (Array.isArray(retryWhen)) {\n            // Retry on specific HTTP status codes\n            return error instanceof FetchError && retryWhen.includes(error.status);\n        }\n\n        // Custom retry condition\n        return retryWhen(error, attempt);\n    };\n\n    /**\n     * Calculates the delay before the next retry attempt.\n     */\n    const getRetryDelay = (attempt: number): number => {\n        return typeof retryDelay === 'function'\n            ? retryDelay(attempt)\n            : retryDelay;\n    };\n\n    /**\n     * Configures the abort signal for a fetch attempt.\n     *\n     * Combines multiple signals:\n     * - User's external signal (from init.signal)\n     * - Internal abort controller signal (for abortable requests)\n     * - Timeout signal (creates a new one each call for per-attempt timeout)\n     *\n     * Must be called before each fetch attempt to ensure fresh timeout signal on retries.\n     */\n    const configureSignal = (): void => {\n        const signals: AbortSignal[] = [];\n\n        // Merge user's signal from init (if provided)\n        if (userSignal) {\n            signals.push(userSignal);\n        }\n\n        if (userController) {\n            signals.push(userController.signal);\n        }\n\n        if (typeof timeout === 'number') {\n            signals.push(AbortSignal.timeout(timeout));\n        }\n\n        // Combine all signals\n        if (signals.length > 0) {\n            rest.signal = signals.length === 1\n                ? signals[0]\n                : AbortSignal.any(signals);\n        }\n    };\n\n    /**\n     * Performs a single fetch attempt with optional timeout.\n     */\n    const doFetch = async (): AsyncIOResult<FetchResponseData> => {\n        configureSignal();\n\n        try {\n            const response = await fetch(parsedUrl, rest);\n\n            if (!response.ok) {\n                // Cancel the response body to free resources\n                response.body?.cancel().catch(() => {\n                    // Silently ignore stream cancel errors\n                });\n                return Err(new FetchError(response.statusText, response.status));\n            }\n\n            return await processResponse(response);\n        } catch (err) {\n            return Err(err instanceof Error\n                ? err\n                // Non-Error type, most likely an abort reason\n                : wrapAbortReason(err),\n            );\n        }\n    };\n\n    /**\n     * Sets up progress tracking and chunk callbacks using a cloned response.\n     * The original response is returned unchanged for further processing.\n     */\n    const setupProgressCallbacks = async (response: Response): Promise<void> => {\n        let totalByteLength: number | undefined;\n        let completedByteLength = 0;\n\n        if (onProgress) {\n            const contentLength = response.headers.get('content-length');\n            if (contentLength == null) {\n                try {\n                    onProgress(Err(new Error('No content-length in response headers')));\n                } catch {\n                    // Silently ignore user callback errors\n                }\n            } else {\n                totalByteLength = Number.parseInt(contentLength, 10);\n            }\n        }\n\n        const body = response.clone().body as ReadableStream<Uint8Array<ArrayBuffer>>;\n\n        try {\n            for await (const chunk of body) {\n                if (onChunk) {\n                    try {\n                        onChunk(chunk);\n                    } catch {\n                        // Silently ignore user callback errors\n                    }\n                }\n\n                if (onProgress && totalByteLength != null) {\n                    completedByteLength += chunk.byteLength;\n                    try {\n                        onProgress(Ok({\n                            totalByteLength,\n                            completedByteLength,\n                        }));\n                    } catch {\n                        // Silently ignore user callback errors\n                    }\n                }\n            }\n        } catch {\n            // Silently ignore stream read errors\n        }\n    };\n\n    /**\n     * Processes the response based on responseType and callbacks.\n     */\n    const processResponse = async (response: Response): AsyncIOResult<FetchResponseData> => {\n        // Setup progress/chunk callbacks if needed (uses cloned response internally)\n        if (response.body && (onProgress || onChunk)) {\n            setupProgressCallbacks(response);\n        }\n\n        switch (responseType) {\n            case 'json': {\n                // Align with stream behavior: no body yields Ok(null)\n                if (response.body == null) {\n                    return Ok(null);\n                }\n                try {\n                    return Ok(await response.json());\n                } catch {\n                    return Err(new Error('Response is invalid json while responseType is json'));\n                }\n            }\n            case 'text': {\n                return Ok(await response.text());\n            }\n            case 'bytes': {\n                // Use native bytes() if available, otherwise fallback to arrayBuffer()\n                if (typeof response.bytes === 'function') {\n                    return Ok(await response.bytes());\n                }\n                // Fallback for older environments\n                return Ok(new Uint8Array(await response.arrayBuffer()));\n            }\n            case 'arraybuffer': {\n                return Ok(await response.arrayBuffer());\n            }\n            case 'blob': {\n                return Ok(await response.blob());\n            }\n            case 'stream': {\n                return Ok(response.body);\n            }\n            default: {\n                // default return the original Response object to preserve all metadata\n                return Ok(response);\n            }\n        }\n    };\n\n    /**\n     * Performs fetch with retry logic.\n     */\n    const fetchWithRetry = async (): FetchResult<FetchResponseData> => {\n        let lastError: Error | undefined;\n        let attempt = 0;\n\n        do {\n            // Before retry (not first attempt), wait for delay\n            if (attempt > 0) {\n                // Check if user aborted before delay (e.g., aborted in `when` callback)\n                if (userController?.signal.aborted) {\n                    return Err(userController.signal.reason as Error);\n                }\n\n                const delayMs = getRetryDelay(attempt);\n                // Wait for delay if necessary\n                if (delayMs > 0) {\n                    await delay(delayMs);\n\n                    // Check if user aborted during delay\n                    if (userController?.signal.aborted) {\n                        return Err(userController.signal.reason as Error);\n                    }\n                }\n\n                // Call onRetry right before the actual retry request\n                try {\n                    onRetry?.(lastError as Error, attempt);\n                } catch {\n                    // Silently ignore user callback errors\n                }\n            }\n\n            const result = await doFetch();\n\n            if (result.isOk()) {\n                return result;\n            }\n\n            lastError = result.unwrapErr();\n            attempt++;\n\n            // Check if we should retry\n        } while (attempt <= retries && shouldRetry(lastError, attempt));\n\n        // No more retries or should not retry\n        // lastError is guaranteed to be defined here because:\n        // 1. do...while loop executes at least once\n        // 2. We only reach here if result.isErr()\n        return Err(lastError);\n    };\n\n    const result = fetchWithRetry();\n\n    if (abortable && userController) {\n        return {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            abort(reason?: any): void {\n                if (reason instanceof Error) {\n                    userController.abort(reason);\n                } else if (reason != null) {\n                    userController.abort(wrapAbortReason(reason));\n                } else {\n                    userController.abort();\n                }\n            },\n\n            get aborted(): boolean {\n                return userController.signal.aborted;\n            },\n\n            get result(): FetchResult<FetchResponseData> {\n                return result;\n            },\n        };\n    }\n\n    return result;\n}\n\n// #endregion\n\n// #region Internal Functions\n\n/**\n * Delays execution for the specified number of milliseconds.\n */\nfunction delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Wraps a non-Error abort reason into an Error with ABORT_ERROR name.\n */\nfunction wrapAbortReason(reason: unknown): Error {\n    const error = new Error(typeof reason === 'string' ? reason : String(reason));\n    error.name = ABORT_ERROR;\n    error.cause = reason;\n    return error;\n}\n\n/**\n * Parsed retry options with defaults applied.\n */\ninterface ParsedRetryOptions extends FetchRetryOptions {\n    retries: number;\n    delay: number | ((attempt: number) => number);\n}\n\n/**\n * Validates fetch options and parses retry configuration.\n */\nfunction validateOptions(init: FetchInit): ParsedRetryOptions {\n    const {\n        responseType,\n        timeout,\n        retry: retryOptions = 0,\n        onProgress,\n        onChunk,\n    } = init;\n\n    if (responseType != null) {\n        const validTypes = ['text', 'arraybuffer', 'blob', 'json', 'bytes', 'stream'];\n        if (!validTypes.includes(responseType)) {\n            throw new TypeError(`responseType must be one of ${ validTypes.join(', ') } but received ${ responseType }`);\n        }\n    }\n\n    if (timeout != null) {\n        if (typeof timeout !== 'number') {\n            throw new TypeError(`timeout must be a number but received ${ typeof timeout }`);\n        }\n        if (timeout <= 0) {\n            throw new Error(`timeout must be a number greater than 0 but received ${ timeout }`);\n        }\n    }\n\n    if (onProgress != null) {\n        if (typeof onProgress !== 'function') {\n            throw new TypeError(`onProgress callback must be a function but received ${ typeof onProgress }`);\n        }\n    }\n\n    if (onChunk != null) {\n        if (typeof onChunk !== 'function') {\n            throw new TypeError(`onChunk callback must be a function but received ${ typeof onChunk }`);\n        }\n    }\n\n    // Parse retry options\n    let retries = 0;\n    let delay: number | ((attempt: number) => number) = 0;\n    let when: ((error: Error, attempt: number) => boolean) | number[] | undefined;\n    let onRetry: ((error: Error, attempt: number) => void) | undefined;\n\n    if (typeof retryOptions === 'number') {\n        retries = retryOptions;\n    } else if (retryOptions && typeof retryOptions === 'object') {\n        retries = retryOptions.retries ?? 0;\n        delay = retryOptions.delay ?? 0;\n        when = retryOptions.when;\n        onRetry = retryOptions.onRetry;\n    }\n\n    if (!Number.isInteger(retries)) {\n        throw new TypeError(`Retry count must be an integer but received ${ retries }`);\n    }\n    if (retries < 0) {\n        throw new Error(`Retry count must be non-negative but received ${ retries }`);\n    }\n\n    if (typeof delay === 'number') {\n        if (delay < 0) {\n            throw new Error(`Retry delay must be a non-negative number but received ${ delay }`);\n        }\n    } else {\n        if (typeof delay !== 'function') {\n            throw new TypeError(`Retry delay must be a number or a function but received ${ typeof delay }`);\n        }\n    }\n\n    if (when != null) {\n        if (!Array.isArray(when) && typeof when !== 'function') {\n            throw new TypeError(`Retry when condition must be an array of status codes or a function but received ${ typeof when }`);\n        }\n    }\n\n    if (onRetry != null) {\n        if (typeof onRetry !== 'function') {\n            throw new TypeError(`Retry onRetry callback must be a function but received ${ typeof onRetry }`);\n        }\n    }\n\n    return { retries, delay, when, onRetry };\n}\n\n/**\n * Validates and parses a URL string or URL object.\n * In browser environments, relative URLs are resolved against `location.href`.\n * In non-browser environments (Node/Deno/Bun), only absolute URLs are valid.\n */\nfunction validateUrl(url: string | URL): URL {\n    if (url instanceof URL) {\n        return url;\n    }\n\n    try {\n        // In browser, use location.href as base for relative URLs\n        // In Node/Deno/Bun, location is undefined, so relative URLs will fail\n        const base = typeof location !== 'undefined' ? location.href : undefined;\n        return new URL(url, base);\n    } catch {\n        throw new TypeError(`Invalid URL: ${ url }`);\n    }\n}\n\n// #endregion\n"],"names":["result","delay"],"mappings":"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"}
+{"version":3,"file":"main.mjs","names":[],"sources":["../src/fetch/constants.ts","../src/fetch/defines.ts","../src/fetch/polyfills.ts","../src/fetch/fetch.ts"],"sourcesContent":["/**\n * Error name for aborted fetch requests.\n *\n * This matches the standard `AbortError` name used by the Fetch API when a request\n * is cancelled via `AbortController.abort()`.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, ABORT_ERROR } from '@happy-ts/fetch-t';\n *\n * const task = fetchT('https://api.example.com/data', { abortable: true });\n * task.abort();\n *\n * const result = await task.result;\n * result.inspectErr((err) => {\n *     if (err.name === ABORT_ERROR) {\n *         console.log('Request was aborted');\n *     }\n * });\n * ```\n */\nexport const ABORT_ERROR = 'AbortError' as const;\n\n/**\n * Error name for timed out fetch requests.\n *\n * This is set on the `Error.name` property when a request exceeds the specified\n * `timeout` duration and is automatically aborted.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, TIMEOUT_ERROR } from '@happy-ts/fetch-t';\n *\n * const result = await fetchT('https://api.example.com/slow-endpoint', {\n *     timeout: 5000, // 5 seconds\n * });\n *\n * result.inspectErr((err) => {\n *     if (err.name === TIMEOUT_ERROR) {\n *         console.log('Request timed out after 5 seconds');\n *     }\n * });\n * ```\n */\nexport const TIMEOUT_ERROR = 'TimeoutError' as const;\n","import type { AsyncIOResult, IOResult } from 'happy-rusty';\n\n/**\n * Union type of all possible fetchT response data types.\n *\n * Used when `responseType` is a dynamic string value rather than a literal type,\n * as the exact return type cannot be determined at compile time.\n *\n * @since 1.9.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResponseData } from '@happy-ts/fetch-t';\n *\n * // When responseType is dynamic, return type is FetchResponseData\n * const responseType = getResponseType(); // returns string\n * const result = await fetchT('https://api.example.com/data', { responseType });\n * // result is Result<FetchResponseData, Error>\n * ```\n */\nexport type FetchResponseData =\n    | string\n    | ArrayBuffer\n    | Blob\n    | Uint8Array<ArrayBuffer>\n    | ReadableStream<Uint8Array<ArrayBuffer>>\n    | Response\n    | null;\n\n/**\n * Represents the result of a fetch operation as an async Result type.\n *\n * This is an alias for `AsyncIOResult<T>` from the `happy-rusty` library,\n * providing Rust-like error handling without throwing exceptions.\n *\n * @typeParam T - The type of the data expected in a successful response.\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResult } from '@happy-ts/fetch-t';\n *\n * // FetchResult is a Promise that resolves to Result<T, Error>\n * const result: FetchResult<string> = fetchT('https://api.example.com', {\n *     responseType: 'text',\n * });\n *\n * const res = await result;\n * res\n *     .inspect((text) => console.log('Success:', text))\n *     .inspectErr((err) => console.error('Error:', err));\n * ```\n */\nexport type FetchResult<T> = AsyncIOResult<T>;\n\n/**\n * Represents an abortable fetch operation with control methods.\n *\n * Returned when `abortable: true` is set in the fetch options. Provides\n * the ability to cancel the request and check its abort status.\n *\n * @typeParam T - The type of the data expected in the response.\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchTask } from '@happy-ts/fetch-t';\n *\n * interface User {\n *     id: number;\n *     name: string;\n * }\n *\n * const task: FetchTask<User> = fetchT<User>('https://api.example.com/user/1', {\n *     abortable: true,\n *     responseType: 'json',\n * });\n *\n * // Check if aborted\n * console.log('Is aborted:', task.aborted); // false\n *\n * // Abort with optional reason\n * task.abort('User navigated away');\n *\n * // Access the result (will be an error after abort)\n * const result = await task.result;\n * result.inspectErr((err) => console.log('Aborted:', err.message));\n * ```\n */\nexport interface FetchTask<T> {\n    /**\n     * Aborts the fetch task, optionally with a reason.\n     *\n     * Once aborted, the `result` promise will resolve to an `Err` containing\n     * an `AbortError`. The abort reason can be any value and will be passed\n     * to the underlying `AbortController.abort()`.\n     *\n     * @param reason - An optional value indicating why the task was aborted.\n     *                 This can be an Error, string, or any other value.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    abort(reason?: any): void;\n\n    /**\n     * Indicates whether the fetch task has been aborted.\n     *\n     * Returns `true` if `abort()` was called or if the request timed out.\n     */\n    readonly aborted: boolean;\n\n    /**\n     * The result promise of the fetch task.\n     *\n     * Resolves to `Ok<T>` on success, or `Err<Error>` on failure (including abort).\n     */\n    readonly result: FetchResult<T>;\n}\n\n/**\n * Specifies the expected response type for automatic parsing.\n *\n * - `'text'` - Parse response as string via `Response.text()`\n * - `'json'` - Parse response as JSON via `Response.json()`\n * - `'arraybuffer'` - Parse response as ArrayBuffer via `Response.arrayBuffer()`\n * - `'bytes'` - Parse response as Uint8Array<ArrayBuffer> via `Response.bytes()` (with fallback for older environments)\n * - `'blob'` - Parse response as Blob via `Response.blob()`\n * - `'stream'` - Return the raw `ReadableStream` for streaming processing\n *\n * If not specified, the raw `Response` object is returned.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchResponseType } from '@happy-ts/fetch-t';\n *\n * const responseType: FetchResponseType = 'json';\n *\n * const result = await fetchT('https://api.example.com/data', { responseType });\n * ```\n */\nexport type FetchResponseType = 'text' | 'arraybuffer' | 'blob' | 'json' | 'bytes' | 'stream';\n\n/**\n * Represents the download progress of a fetch operation.\n *\n * Passed to the `onProgress` callback when tracking download progress.\n * Note: Progress tracking requires the server to send a `Content-Length` header.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchProgress } from '@happy-ts/fetch-t';\n *\n * await fetchT('https://example.com/file.zip', {\n *     responseType: 'blob',\n *     onProgress: (result) => {\n *         result.inspect((progress: FetchProgress) => {\n *             const percent = (progress.completedByteLength / progress.totalByteLength) * 100;\n *             console.log(`Downloaded: ${percent.toFixed(1)}%`);\n *         });\n *     },\n * });\n * ```\n */\nexport interface FetchProgress {\n    /**\n     * The total number of bytes to be received (from Content-Length header).\n     */\n    totalByteLength: number;\n\n    /**\n     * The number of bytes received so far.\n     */\n    completedByteLength: number;\n}\n\n/**\n * Options for configuring retry behavior.\n *\n * @since 1.8.0\n */\nexport interface FetchRetryOptions {\n    /**\n     * Number of times to retry the request on failure.\n     *\n     * By default, only network errors trigger retries. HTTP errors (4xx, 5xx)\n     * require explicit configuration via `when`.\n     *\n     * @defaultValue 0 (no retries)\n     */\n    retries?: number;\n\n    /**\n     * Delay between retry attempts in milliseconds.\n     *\n     * Can be a static number or a function for custom strategies like exponential backoff.\n     * The function receives the current attempt number (1-indexed).\n     *\n     * @defaultValue 0 (immediate retry)\n     */\n    delay?: number | ((attempt: number) => number);\n\n    /**\n     * Conditions under which to retry the request.\n     *\n     * Can be an array of HTTP status codes or a custom function.\n     * By default, only network errors (not FetchError) trigger retries.\n     */\n    when?: number[] | ((error: Error, attempt: number) => boolean);\n\n    /**\n     * Callback invoked before each retry attempt.\n     *\n     * Useful for logging, metrics, or adjusting request parameters.\n     */\n    onRetry?: (error: Error, attempt: number) => void;\n}\n\n/**\n * Extended fetch options that add additional capabilities to the standard `RequestInit`.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, type FetchInit } from '@happy-ts/fetch-t';\n *\n * const options: FetchInit = {\n *     // Standard RequestInit options\n *     method: 'POST',\n *     headers: { 'Content-Type': 'application/json' },\n *     body: JSON.stringify({ key: 'value' }),\n *\n *     // Extended options\n *     abortable: true,           // Return FetchTask for manual abort control\n *     responseType: 'json',      // Auto-parse response as JSON\n *     timeout: 10000,            // Abort after 10 seconds\n *     onProgress: (result) => {  // Track download progress\n *         result.inspect(({ completedByteLength, totalByteLength }) => {\n *             console.log(`${completedByteLength}/${totalByteLength}`);\n *         });\n *     },\n *     onChunk: (chunk) => {      // Receive raw data chunks\n *         console.log('Received chunk:', chunk.byteLength, 'bytes');\n *     },\n * };\n *\n * const task = fetchT('https://api.example.com/upload', options);\n * ```\n */\nexport interface FetchInit extends RequestInit {\n    /**\n     * When `true`, returns a `FetchTask` instead of `FetchResult`.\n     *\n     * The `FetchTask` provides `abort()` method and `aborted` status.\n     *\n     * @defaultValue false\n     */\n    abortable?: boolean;\n\n    /**\n     * Specifies how the response body should be parsed.\n     *\n     * - `'text'` - Returns `string`\n     * - `'json'` - Returns parsed JSON (type `T`)\n     * - `'arraybuffer'` - Returns `ArrayBuffer`\n     * - `'bytes'` - Returns `Uint8Array<ArrayBuffer>` (with fallback for older environments)\n     * - `'blob'` - Returns `Blob`\n     * - `'stream'` - Returns `ReadableStream<Uint8Array<ArrayBuffer>>`\n     * - `undefined` - Returns raw `Response` object\n     *\n     * When using a dynamic string value (not a literal type), the return type\n     * will be `FetchResponseData` (union of all possible types).\n     */\n    responseType?: FetchResponseType;\n\n    /**\n     * Maximum time in milliseconds to wait for the request to complete.\n     *\n     * If exceeded, the request is automatically aborted with a `TimeoutError`.\n     * Must be a positive number.\n     */\n    timeout?: number;\n\n    /**\n     * Retry options.\n     *\n     * Can be a number (shorthand for retries count) or an options object.\n     *\n     * @example\n     * ```typescript\n     * // Retry up to 3 times on network errors\n     * const result = await fetchT('https://api.example.com/data', {\n     *     retry: 3,\n     * });\n     *\n     * // Detailed configuration\n     * const result = await fetchT('https://api.example.com/data', {\n     *     retry: {\n     *         retries: 3,\n     *         delay: 1000,\n     *         when: [500, 502],\n     *         onRetry: (error, attempt) => console.log(error),\n     *     },\n     * });\n     * ```\n     */\n    retry?: number | FetchRetryOptions;\n\n    /**\n     * Callback invoked during download to report progress.\n     *\n     * Receives an `IOResult<FetchProgress>`:\n     * - `Ok(FetchProgress)` - Progress update with byte counts\n     * - `Err(Error)` - If `Content-Length` header is missing (called once)\n     *\n     * **Note**: This feature uses `response.clone()` internally. The cloned stream shares\n     * the same underlying data source (via `tee()`), so it does NOT double memory usage.\n     * However, if the two streams consume data at different speeds, chunks may be buffered\n     * temporarily until both streams have read them.\n     *\n     * @param progressResult - The progress result, either success with progress data or error.\n     */\n    onProgress?: (progressResult: IOResult<FetchProgress>) => void;\n\n    /**\n     * Callback invoked when a chunk of data is received.\n     *\n     * Useful for streaming or processing data as it arrives.\n     * Each chunk is a `Uint8Array<ArrayBuffer>` containing the raw bytes.\n     *\n     * **Note**: This feature uses `response.clone()` internally. The cloned stream shares\n     * the same underlying data source (via `tee()`), so it does NOT double memory usage.\n     * However, if the two streams consume data at different speeds, chunks may be buffered\n     * temporarily until both streams have read them.\n     *\n     * @param chunk - The raw data chunk received from the response stream.\n     */\n    onChunk?: (chunk: Uint8Array<ArrayBuffer>) => void;\n}\n\n/**\n * Custom error class for HTTP error responses (non-2xx status codes).\n *\n * Thrown when `Response.ok` is `false`. Contains the HTTP status code\n * for programmatic error handling.\n *\n * @since 1.0.0\n * @example\n * ```typescript\n * import { fetchT, FetchError } from '@happy-ts/fetch-t';\n *\n * const result = await fetchT('https://api.example.com/not-found', {\n *     responseType: 'json',\n * });\n *\n * result.inspectErr((err) => {\n *     if (err instanceof FetchError) {\n *         console.log('HTTP Status:', err.status);  // e.g., 404\n *         console.log('Status Text:', err.message); // e.g., \"Not Found\"\n *\n *         // Handle specific status codes\n *         switch (err.status) {\n *             case 401:\n *                 console.log('Unauthorized - please login');\n *                 break;\n *             case 404:\n *                 console.log('Resource not found');\n *                 break;\n *             case 500:\n *                 console.log('Server error');\n *                 break;\n *         }\n *     }\n * });\n * ```\n */\nexport class FetchError extends Error {\n    /**\n     * The error name, always `'FetchError'`.\n     */\n    override name = 'FetchError';\n\n    /**\n     * The HTTP status code of the response (e.g., 404, 500).\n     */\n    status: number;\n\n    /**\n     * Creates a new FetchError instance.\n     *\n     * @param message - The status text from the HTTP response (e.g., \"Not Found\").\n     * @param status - The HTTP status code (e.g., 404).\n     */\n    constructor(message: string, status: number) {\n        super(message);\n        this.status = status;\n    }\n}\n","/**\n * @internal\n * Polyfills for AbortSignal and related APIs.\n */\n\nimport { TIMEOUT_ERROR } from './constants.ts';\n\n/**\n * Creates an AbortSignal that aborts after the specified timeout.\n * Uses native `AbortSignal.timeout` when available, otherwise falls back to a manual implementation.\n */\nexport function signalTimeout(ms: number): AbortSignal {\n    if (typeof AbortSignal.timeout === 'function') {\n        return AbortSignal.timeout(ms);\n    }\n\n    // Polyfill for environments without AbortSignal.timeout (Node < 17.3)\n    const controller = new AbortController();\n    const timeoutError = createTimeoutError();\n\n    const timerId = setTimeout(() => {\n        controller.abort(timeoutError);\n    }, ms);\n\n    // Prevent the timer from keeping the Node.js event loop alive\n    if (typeof timerId?.unref === 'function') {\n        timerId.unref();\n    }\n\n    return controller.signal;\n}\n\n/**\n * Creates an AbortSignal that aborts when any of the provided signals abort.\n * Uses native `AbortSignal.any` when available, otherwise falls back to a manual implementation.\n *\n * The polyfill properly cleans up event listeners on all signals when one fires,\n * preventing memory leaks from long-lived signals.\n */\nexport function signalAny(signals: AbortSignal[]): AbortSignal {\n    if (typeof AbortSignal.any === 'function') {\n        return AbortSignal.any(signals);\n    }\n\n    // Polyfill for environments without AbortSignal.any (Node < 20.3)\n    const controller = new AbortController();\n\n    // Fast path: if any signal is already aborted, abort immediately\n    for (const signal of signals) {\n        if (signal.aborted) {\n            controller.abort(signal.reason);\n            return controller.signal;\n        }\n    }\n\n    // Single shared handler — uses event.target to identify the source signal.\n    // Note: cleanup is NOT called here explicitly. Instead, controller.abort() synchronously\n    // dispatches the abort event on controller.signal, which triggers the cleanup listener below.\n    // Chain: onAbort() → controller.abort() → controller.signal 'abort' event → cleanup()\n    const onAbort = (event: Event): void => {\n        const source = event.target as AbortSignal;\n        controller.abort(source.reason);\n    };\n\n    // Remove listeners from all input signals to prevent memory leaks on long-lived signals\n    const cleanup = (): void => {\n        for (const signal of signals) {\n            signal.removeEventListener('abort', onAbort);\n        }\n    };\n\n    for (const signal of signals) {\n        signal.addEventListener('abort', onAbort);\n    }\n\n    // Cleanup is driven by controller.signal's abort event, which fires synchronously\n    // inside controller.abort(). This guarantees cleanup runs exactly once regardless\n    // of which input signal triggered the abort.\n    controller.signal.addEventListener('abort', cleanup);\n\n    return controller.signal;\n}\n\n// #region Internal Functions\n\n/**\n * Creates a DOMException with TimeoutError name.\n * Falls back to a plain Error in environments where DOMException constructor is unavailable.\n */\nfunction createTimeoutError(): Error {\n    const message = 'The operation timed out.';\n    try {\n        return new DOMException(message, TIMEOUT_ERROR);\n    } catch {\n        // Fallback for environments without DOMException constructor (e.g., old Web Workers)\n        const error = new Error(message);\n        error.name = TIMEOUT_ERROR;\n        return error;\n    }\n}\n\n// #endregion\n","import { Err, Ok, type AsyncIOResult } from 'happy-rusty';\nimport { ABORT_ERROR } from './constants.ts';\nimport { FetchError, type FetchInit, type FetchResponseData, type FetchResponseType, type FetchResult, type FetchRetryOptions, type FetchTask } from './defines.ts';\nimport { signalAny, signalTimeout } from './polyfills.ts';\n\n// #region Overload Declarations\n\n/**\n * Fetches a resource from the network as a text string and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'text'`.\n * @returns A `FetchTask` representing the abortable operation with a `string` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'text';\n}): FetchTask<string>;\n\n/**\n * Fetches a resource from the network as an ArrayBuffer and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'arraybuffer'`.\n * @returns A `FetchTask` representing the abortable operation with an `ArrayBuffer` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'arraybuffer';\n}): FetchTask<ArrayBuffer>;\n\n/**\n * Fetches a resource from the network as a Blob and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'blob'`.\n * @returns A `FetchTask` representing the abortable operation with a `Blob` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'blob';\n}): FetchTask<Blob>;\n\n/**\n * Fetches a resource from the network and parses it as JSON, returning an abortable `FetchTask`.\n *\n * @typeParam T - The expected type of the parsed JSON data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'json'`.\n * @returns A `FetchTask` representing the abortable operation with a response parsed as type `T`.\n */\nexport function fetchT<T>(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'json';\n}): FetchTask<T | null>;\n\n/**\n * Fetches a resource from the network as a ReadableStream and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'stream'`.\n * @returns A `FetchTask` representing the abortable operation with a `ReadableStream<Uint8Array<ArrayBuffer>>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'stream';\n}): FetchTask<ReadableStream<Uint8Array<ArrayBuffer>> | null>;\n\n/**\n * Fetches a resource from the network as a Uint8Array<ArrayBuffer> and returns an abortable `FetchTask`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and `responseType: 'bytes'`.\n * @returns A `FetchTask` representing the abortable operation with a `Uint8Array<ArrayBuffer>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: 'bytes';\n}): FetchTask<Uint8Array<ArrayBuffer>>;\n\n/**\n * Fetches a resource from the network and returns an abortable `FetchTask` with a dynamic response type.\n *\n * Use this overload when `responseType` is a `FetchResponseType` union type.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true` and a `FetchResponseType`.\n * @returns A `FetchTask` representing the abortable operation with a `FetchResponseData` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n    responseType: FetchResponseType;\n}): FetchTask<FetchResponseData>;\n\n/**\n * Fetches a resource from the network as a text string.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'text'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `string` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'text';\n}): FetchResult<string>;\n\n/**\n * Fetches a resource from the network as an ArrayBuffer.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'arraybuffer'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with an `ArrayBuffer` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'arraybuffer';\n}): FetchResult<ArrayBuffer>;\n\n/**\n * Fetches a resource from the network as a Blob.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'blob'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Blob` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'blob';\n}): FetchResult<Blob>;\n\n/**\n * Fetches a resource from the network and parses it as JSON.\n *\n * @typeParam T - The expected type of the parsed JSON data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'json'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a response parsed as type `T`.\n */\nexport function fetchT<T>(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'json';\n}): FetchResult<T | null>;\n\n/**\n * Fetches a resource from the network as a ReadableStream.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'stream'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `ReadableStream<Uint8Array<ArrayBuffer>>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'stream';\n}): FetchResult<ReadableStream<Uint8Array<ArrayBuffer>> | null>;\n\n/**\n * Fetches a resource from the network as a Uint8Array<ArrayBuffer>.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `responseType: 'bytes'` and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Uint8Array<ArrayBuffer>` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: 'bytes';\n}): FetchResult<Uint8Array<ArrayBuffer>>;\n\n/**\n * Fetches a resource from the network with a dynamic response type (non-abortable).\n *\n * Use this overload when `responseType` is a `FetchResponseType` union type.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation with a `FetchResponseType`, and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `FetchResponseData` response.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable?: false;\n    responseType: FetchResponseType;\n}): FetchResult<FetchResponseData>;\n\n/**\n * Fetches a resource from the network and returns an abortable `FetchTask` with a generic `Response`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, must include `abortable: true`.\n * @returns A `FetchTask` representing the abortable operation with a `Response` object.\n */\nexport function fetchT(url: string | URL, init: FetchInit & {\n    abortable: true;\n}): FetchTask<Response>;\n\n/**\n * Fetches a resource from the network and returns a `FetchResult` with a generic `Response` object.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Optional additional options for the fetch operation, and `abortable` must be `false` or omitted.\n * @returns A `FetchResult` representing the operation with a `Response` object.\n */\nexport function fetchT(url: string | URL, init?: FetchInit & {\n    abortable?: false;\n}): FetchResult<Response>;\n\n/**\n * Fallback overload for when `FetchInit` is passed as a variable (not an object literal).\n *\n * When TypeScript cannot determine the literal value of `abortable` at compile time\n * (e.g., when passing a `FetchInit` variable), this overload is matched.\n * The return type is a union of `FetchTask` and `FetchResult`.\n *\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Optional fetch options. When passed as a `FetchInit` variable, the return type is a union.\n * @returns Either a `FetchTask` or `FetchResult` depending on the runtime value of `abortable`.\n */\nexport function fetchT(url: string | URL, init?: FetchInit): FetchTask<FetchResponseData> | FetchResult<FetchResponseData>;\n\n// #endregion\n\n// #region Main Implementation\n\n/**\n * Enhanced fetch function that wraps the native Fetch API with additional capabilities.\n *\n * Features:\n * - **Abortable requests**: Set `abortable: true` to get a `FetchTask` with `abort()` method.\n * - **Type-safe responses**: Use `responseType` to automatically parse responses as text, JSON, ArrayBuffer, Blob, bytes, or stream.\n * - **Timeout support**: Set `timeout` in milliseconds to auto-abort long-running requests.\n * - **Progress tracking**: Use `onProgress` callback to track download progress (requires Content-Length header).\n * - **Chunk streaming**: Use `onChunk` callback to receive raw data chunks as they arrive.\n * - **Retry support**: Use `retry` to automatically retry failed requests with configurable delay and conditions.\n * - **Result type error handling**: Returns `Result<T, Error>` instead of throwing exceptions for runtime errors.\n *\n * **Note**: Invalid parameters throw synchronously (fail-fast) rather than returning rejected Promises.\n * This differs from native `fetch` behavior and helps catch programming errors during development.\n *\n * @typeParam T - The expected type of the response data.\n * @param url - The resource to fetch. Can be a URL object or a string representing a URL.\n * @param init - Additional options for the fetch operation, extending standard `RequestInit` with custom properties.\n * @returns A `FetchTask<T>` if `abortable: true`, otherwise a `FetchResult<T>` (which is `AsyncIOResult<T>`).\n * @throws {TypeError} If `url` is invalid or a relative URL in non-browser environment.\n * @throws {TypeError} If `responseType` is not a valid response type.\n * @throws {TypeError} If `timeout` is not a number.\n * @throws {Error} If `timeout` is not greater than 0.\n * @throws {TypeError} If `onProgress` or `onChunk` is provided but not a function.\n * @throws {TypeError} If `retry.retries` is not an integer.\n * @throws {Error} If `retry.retries` is negative.\n * @throws {TypeError} If `retry.delay` is not a number or function.\n * @throws {Error} If `retry.delay` is a negative number.\n * @throws {TypeError} If `retry.when` is not an array or function.\n * @throws {TypeError} If `retry.onRetry` is provided but not a function.\n * @since 1.0.0\n * @example\n * // Basic GET request - returns Response object wrapped in Result\n * const result = await fetchT('https://api.example.com/data');\n * result\n *     .inspect((res) => console.log('Status:', res.status))\n *     .inspectErr((err) => console.error('Error:', err));\n *\n * @example\n * // GET JSON with type safety\n * interface User {\n *     id: number;\n *     name: string;\n * }\n * const result = await fetchT<User>('https://api.example.com/user/1', {\n *     responseType: 'json',\n * });\n * result.inspect((user) => console.log(user.name));\n *\n * @example\n * // POST request with JSON body\n * const result = await fetchT<User>('https://api.example.com/users', {\n *     method: 'POST',\n *     headers: { 'Content-Type': 'application/json' },\n *     body: JSON.stringify({ name: 'John' }),\n *     responseType: 'json',\n * });\n *\n * @example\n * // Abortable request with timeout\n * const task = fetchT('https://api.example.com/data', {\n *     abortable: true,\n *     timeout: 5000, // 5 seconds\n * });\n *\n * // Cancel the request if needed\n * task.abort('User cancelled');\n *\n * // Check if aborted\n * console.log('Aborted:', task.aborted);\n *\n * // Wait for result\n * const result = await task.result;\n *\n * @example\n * // Track download progress\n * const result = await fetchT('https://example.com/large-file.zip', {\n *     responseType: 'blob',\n *     onProgress: (progressResult) => {\n *         progressResult\n *             .inspect(({ completedByteLength, totalByteLength }) => {\n *                 const percent = ((completedByteLength / totalByteLength) * 100).toFixed(1);\n *                 console.log(`Progress: ${percent}%`);\n *             })\n *             .inspectErr((err) => console.warn('Progress unavailable:', err.message));\n *     },\n * });\n *\n * @example\n * // Stream data chunks\n * const chunks: Uint8Array[] = [];\n * const result = await fetchT('https://example.com/stream', {\n *     onChunk: (chunk) => chunks.push(chunk),\n * });\n *\n * @example\n * // Retry with exponential backoff\n * const result = await fetchT('https://api.example.com/data', {\n *     retry: {\n *         retries: 3,\n *         delay: (attempt) => Math.min(1000 * Math.pow(2, attempt - 1), 10000),\n *         when: [500, 502, 503, 504],\n *         onRetry: (error, attempt) => console.log(`Retry ${attempt}: ${error.message}`),\n *     },\n *     responseType: 'json',\n * });\n */\nexport function fetchT(url: string | URL, init?: FetchInit): FetchTask<FetchResponseData> | FetchResult<FetchResponseData> {\n    // Validate and parse URL\n    const parsedUrl = validateUrl(url);\n\n    const fetchInit = init ?? {};\n\n    const {\n        retries,\n        delay: retryDelay,\n        when: retryWhen,\n        onRetry,\n    } = validateOptions(fetchInit);\n\n    const {\n        // default not abortable\n        abortable = false,\n        responseType,\n        timeout,\n        onProgress,\n        onChunk,\n        ...rest\n    } = fetchInit;\n\n    // Preserve user's original signal before modifications (rest.signal will be reassigned in setSignal)\n    const userSignal = rest.signal;\n\n    // User controller for manual abort (stops all retries)\n    let userController: AbortController | undefined;\n    if (abortable) {\n        userController = new AbortController();\n    }\n\n    /**\n     * Determines if the error should trigger a retry.\n     * By default, only network errors (not FetchError) trigger retries.\n     */\n    const shouldRetry = (error: Error, attempt: number): boolean => {\n        // Never retry on user abort\n        if (error.name === ABORT_ERROR) {\n            return false;\n        }\n\n        if (!retryWhen) {\n            // Default: only retry on network errors (not FetchError/HTTP errors)\n            return !(error instanceof FetchError);\n        }\n\n        if (Array.isArray(retryWhen)) {\n            // Retry on specific HTTP status codes\n            return error instanceof FetchError && retryWhen.includes(error.status);\n        }\n\n        // Custom retry condition\n        return retryWhen(error, attempt);\n    };\n\n    /**\n     * Calculates the delay before the next retry attempt.\n     */\n    const getRetryDelay = (attempt: number): number => {\n        return typeof retryDelay === 'function'\n            ? retryDelay(attempt)\n            : retryDelay;\n    };\n\n    /**\n     * Configures the abort signal for a fetch attempt.\n     *\n     * Combines multiple signals:\n     * - User's external signal (from init.signal)\n     * - Internal abort controller signal (for abortable requests)\n     * - Timeout signal (creates a new one each call for per-attempt timeout)\n     *\n     * Must be called before each fetch attempt to ensure fresh timeout signal on retries.\n     */\n    const configureSignal = (): void => {\n        const signals: AbortSignal[] = [];\n\n        // Merge user's signal from init (if provided)\n        if (userSignal) {\n            signals.push(userSignal);\n        }\n\n        if (userController) {\n            signals.push(userController.signal);\n        }\n\n        if (typeof timeout === 'number') {\n            signals.push(signalTimeout(timeout));\n        }\n\n        // Combine all signals\n        if (signals.length > 0) {\n            rest.signal = signals.length === 1\n                ? signals[0]\n                : signalAny(signals);\n        }\n    };\n\n    /**\n     * Performs a single fetch attempt with optional timeout.\n     */\n    const doFetch = async (): AsyncIOResult<FetchResponseData> => {\n        configureSignal();\n\n        try {\n            const response = await fetch(parsedUrl, rest);\n\n            if (!response.ok) {\n                // Cancel the response body to free resources\n                response.body?.cancel().catch(() => {\n                    // Silently ignore stream cancel errors\n                });\n                return Err(new FetchError(response.statusText, response.status));\n            }\n\n            return await processResponse(response);\n        } catch (err) {\n            return Err(err instanceof Error\n                ? err\n                // Non-Error type, most likely an abort reason\n                : wrapAbortReason(err),\n            );\n        }\n    };\n\n    /**\n     * Sets up progress tracking and chunk callbacks using a cloned response.\n     * The original response is returned unchanged for further processing.\n     */\n    const setupProgressCallbacks = async (response: Response): Promise<void> => {\n        let totalByteLength: number | undefined;\n        let completedByteLength = 0;\n\n        if (onProgress) {\n            const contentLength = response.headers.get('content-length');\n            if (contentLength == null) {\n                try {\n                    onProgress(Err(new Error('No content-length in response headers')));\n                } catch {\n                    // Silently ignore user callback errors\n                }\n            } else {\n                totalByteLength = Number.parseInt(contentLength, 10);\n            }\n        }\n\n        const body = response.clone().body as ReadableStream<Uint8Array<ArrayBuffer>>;\n\n        try {\n            for await (const chunk of body) {\n                if (onChunk) {\n                    try {\n                        onChunk(chunk);\n                    } catch {\n                        // Silently ignore user callback errors\n                    }\n                }\n\n                if (onProgress && totalByteLength != null) {\n                    completedByteLength += chunk.byteLength;\n                    try {\n                        onProgress(Ok({\n                            totalByteLength,\n                            completedByteLength,\n                        }));\n                    } catch {\n                        // Silently ignore user callback errors\n                    }\n                }\n            }\n        } catch {\n            // Silently ignore stream read errors\n        }\n    };\n\n    /**\n     * Processes the response based on responseType and callbacks.\n     */\n    const processResponse = async (response: Response): AsyncIOResult<FetchResponseData> => {\n        // Setup progress/chunk callbacks if needed (uses cloned response internally)\n        if (response.body && (onProgress || onChunk)) {\n            setupProgressCallbacks(response);\n        }\n\n        switch (responseType) {\n            case 'json': {\n                // Align with stream behavior: no body yields Ok(null)\n                if (response.body == null) {\n                    return Ok(null);\n                }\n                try {\n                    return Ok(await response.json());\n                } catch {\n                    return Err(new Error('Response is invalid json while responseType is json'));\n                }\n            }\n            case 'text': {\n                return Ok(await response.text());\n            }\n            case 'bytes': {\n                // Use native bytes() if available, otherwise fallback to arrayBuffer()\n                if (typeof response.bytes === 'function') {\n                    return Ok(await response.bytes());\n                }\n                // Fallback for older environments\n                return Ok(new Uint8Array(await response.arrayBuffer()));\n            }\n            case 'arraybuffer': {\n                return Ok(await response.arrayBuffer());\n            }\n            case 'blob': {\n                return Ok(await response.blob());\n            }\n            case 'stream': {\n                return Ok(response.body);\n            }\n            default: {\n                // default return the original Response object to preserve all metadata\n                return Ok(response);\n            }\n        }\n    };\n\n    /**\n     * Performs fetch with retry logic.\n     */\n    const fetchWithRetry = async (): FetchResult<FetchResponseData> => {\n        let lastError: Error | undefined;\n        let attempt = 0;\n\n        do {\n            // Before retry (not first attempt), wait for delay\n            if (attempt > 0) {\n                // Check if user aborted before delay (e.g., aborted in `when` callback)\n                if (userController?.signal.aborted) {\n                    return Err(userController.signal.reason as Error);\n                }\n\n                const delayMs = getRetryDelay(attempt);\n                // Wait for delay if necessary\n                if (delayMs > 0) {\n                    await delay(delayMs);\n\n                    // Check if user aborted during delay\n                    if (userController?.signal.aborted) {\n                        return Err(userController.signal.reason as Error);\n                    }\n                }\n\n                // Call onRetry right before the actual retry request\n                try {\n                    onRetry?.(lastError as Error, attempt);\n                } catch {\n                    // Silently ignore user callback errors\n                }\n            }\n\n            const result = await doFetch();\n\n            if (result.isOk()) {\n                return result;\n            }\n\n            lastError = result.unwrapErr();\n            attempt++;\n\n            // Check if we should retry\n        } while (attempt <= retries && shouldRetry(lastError, attempt));\n\n        // No more retries or should not retry\n        // lastError is guaranteed to be defined here because:\n        // 1. do...while loop executes at least once\n        // 2. We only reach here if result.isErr()\n        return Err(lastError);\n    };\n\n    const result = fetchWithRetry();\n\n    if (abortable && userController) {\n        return {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            abort(reason?: any): void {\n                if (reason instanceof Error) {\n                    userController.abort(reason);\n                } else if (reason != null) {\n                    userController.abort(wrapAbortReason(reason));\n                } else {\n                    userController.abort();\n                }\n            },\n\n            get aborted(): boolean {\n                return userController.signal.aborted;\n            },\n\n            get result(): FetchResult<FetchResponseData> {\n                return result;\n            },\n        };\n    }\n\n    return result;\n}\n\n// #endregion\n\n// #region Internal Functions\n\n/**\n * Delays execution for the specified number of milliseconds.\n */\nfunction delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Wraps a non-Error abort reason into an Error with ABORT_ERROR name.\n */\nfunction wrapAbortReason(reason: unknown): Error {\n    const error = new Error(typeof reason === 'string' ? reason : String(reason));\n    error.name = ABORT_ERROR;\n    error.cause = reason;\n    return error;\n}\n\n/**\n * Parsed retry options with defaults applied.\n */\ninterface ParsedRetryOptions extends FetchRetryOptions {\n    retries: number;\n    delay: number | ((attempt: number) => number);\n}\n\n/**\n * Validates fetch options and parses retry configuration.\n */\nfunction validateOptions(init: FetchInit): ParsedRetryOptions {\n    const {\n        responseType,\n        timeout,\n        retry: retryOptions = 0,\n        onProgress,\n        onChunk,\n    } = init;\n\n    if (responseType != null) {\n        const validTypes = ['text', 'arraybuffer', 'blob', 'json', 'bytes', 'stream'];\n        if (!validTypes.includes(responseType)) {\n            throw new TypeError(`responseType must be one of ${ validTypes.join(', ') } but received ${ responseType }`);\n        }\n    }\n\n    if (timeout != null) {\n        if (typeof timeout !== 'number') {\n            throw new TypeError(`timeout must be a number but received ${ typeof timeout }`);\n        }\n        if (timeout <= 0) {\n            throw new Error(`timeout must be a number greater than 0 but received ${ timeout }`);\n        }\n    }\n\n    if (onProgress != null) {\n        if (typeof onProgress !== 'function') {\n            throw new TypeError(`onProgress callback must be a function but received ${ typeof onProgress }`);\n        }\n    }\n\n    if (onChunk != null) {\n        if (typeof onChunk !== 'function') {\n            throw new TypeError(`onChunk callback must be a function but received ${ typeof onChunk }`);\n        }\n    }\n\n    // Parse retry options\n    let retries = 0;\n    let delay: number | ((attempt: number) => number) = 0;\n    let when: ((error: Error, attempt: number) => boolean) | number[] | undefined;\n    let onRetry: ((error: Error, attempt: number) => void) | undefined;\n\n    if (typeof retryOptions === 'number') {\n        retries = retryOptions;\n    } else if (retryOptions && typeof retryOptions === 'object') {\n        retries = retryOptions.retries ?? 0;\n        delay = retryOptions.delay ?? 0;\n        when = retryOptions.when;\n        onRetry = retryOptions.onRetry;\n    }\n\n    if (!Number.isInteger(retries)) {\n        throw new TypeError(`Retry count must be an integer but received ${ retries }`);\n    }\n    if (retries < 0) {\n        throw new Error(`Retry count must be non-negative but received ${ retries }`);\n    }\n\n    if (typeof delay === 'number') {\n        if (delay < 0) {\n            throw new Error(`Retry delay must be a non-negative number but received ${ delay }`);\n        }\n    } else {\n        if (typeof delay !== 'function') {\n            throw new TypeError(`Retry delay must be a number or a function but received ${ typeof delay }`);\n        }\n    }\n\n    if (when != null) {\n        if (!Array.isArray(when) && typeof when !== 'function') {\n            throw new TypeError(`Retry when condition must be an array of status codes or a function but received ${ typeof when }`);\n        }\n    }\n\n    if (onRetry != null) {\n        if (typeof onRetry !== 'function') {\n            throw new TypeError(`Retry onRetry callback must be a function but received ${ typeof onRetry }`);\n        }\n    }\n\n    return { retries, delay, when, onRetry };\n}\n\n/**\n * Validates and parses a URL string or URL object.\n * In browser environments, relative URLs are resolved against `location.href`.\n * In non-browser environments (Node/Deno/Bun), only absolute URLs are valid.\n */\nfunction validateUrl(url: string | URL): URL {\n    if (url instanceof URL) {\n        return url;\n    }\n\n    try {\n        // In browser, use location.href as base for relative URLs\n        // In Node/Deno/Bun, location is undefined, so relative URLs will fail\n        const base = typeof location !== 'undefined' ? location.href : undefined;\n        return new URL(url, base);\n    } catch {\n        throw new TypeError(`Invalid URL: ${ url }`);\n    }\n}\n\n// #endregion\n"],"mappings":"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"}

package/dist/types.d.ts

@@ -116,7 +116,7 @@ export declare interface FetchInit extends RequestInit {
      *
      * The `FetchTask` provides `abort()` method and `aborted` status.
      *
-     * @default false
+     * @defaultValue false
      */
     abortable?: boolean;
     /**
@@ -309,7 +309,7 @@ export declare interface FetchRetryOptions {
      * By default, only network errors trigger retries. HTTP errors (4xx, 5xx)
      * require explicit configuration via `when`.
      *
-     * @default 0 (no retries)
+     * @defaultValue 0 (no retries)
      */
     retries?: number;
     /**
@@ -318,7 +318,7 @@ export declare interface FetchRetryOptions {
      * Can be a static number or a function for custom strategies like exponential backoff.
      * The function receives the current attempt number (1-indexed).
      *
-     * @default 0 (immediate retry)
+     * @defaultValue 0 (immediate retry)
      */
     delay?: number | ((attempt: number) => number);
     /**

package/package.json

@@ -3,7 +3,7 @@
   "description": "Type-safe Fetch API wrapper with abortable requests, timeout support, progress tracking, automatic retry, and Rust-like Result error handling.",
   "author": "jiang115jie@gmail.com",
   "license": "MIT",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "type": "module",
   "main": "dist/main.cjs",
   "module": "dist/main.mjs",
@@ -32,7 +32,6 @@
     "test": "pnpm exec vitest run --coverage",
     "test:watch": "pnpm exec vitest",
     "test:ui": "pnpm exec vitest --ui",
-    "predocs": "pnpm dlx rimraf docs",
     "docs": "pnpm exec typedoc",
     "eg": "node examples/main.ts",
     "prepublishOnly": "pnpm run build"
@@ -55,19 +54,20 @@
     "async"
   ],
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@stylistic/eslint-plugin": "^5.7.0",
-    "@vitest/coverage-v8": "^4.0.17",
-    "eslint": "^9.39.2",
-    "msw": "^2.12.7",
-    "typedoc": "^0.28.16",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.0",
-    "vite": "^7.3.1",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.17"
+    "@eslint/js": "^10.0.1",
+    "@microsoft/api-extractor": "^7.58.7",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@vitest/coverage-v8": "^4.1.7",
+    "eslint": "^10.4.0",
+    "msw": "^2.14.6",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    "unplugin-dts": "^1.0.1",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
   },
   "dependencies": {
-    "happy-rusty": "^1.9.1"
+    "happy-rusty": "^1.9.2"
   }
 }