@zap-studio/fetch 0.5.4 → 0.5.6

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## @zap-studio/fetch@0.5.6
+
+### Tree-shakeable root re-exports
+
+The package root now re-exports the full public API, so everything can be imported from `@zap-studio/fetch` directly (`$fetch`, `api`, `createFetch`, `FetchError`, `mergeHeaders`, `GLOBAL_DEFAULTS`, `normalizeRequest`, `resolveRequestUrl`, and all public types). All exports are side-effect free and tree-shakeable; granular subpath imports keep working.
+
+- The `$fetch`/`api`/`createFetch` implementation moved from the entrypoint into its own module, available as the new `./fetch` subpath.
+- Removed the `./internal` and `./methods` subpath exports. Both were implementation details (`fetchInternal`, `createMethod`) and are no longer part of the public API.
+
+## @zap-studio/fetch@0.5.5
+
+### Migrate to ultracite lint/format
+
+Internal formatting and lint cleanup only. No public API or behavior change.
+
 # @zap-studio/fetch
 
 ## 0.5.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Alexandre Trotel
+Copyright (c) 2026 alexandretrotel
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -5,9 +5,25 @@ A small fetch wrapper with [**Standard Schema**](https://standardschema.dev/sche
 ## Installation
 
 ```bash
+nub add @zap-studio/fetch
+# or
 npm install @zap-studio/fetch
+# or
+pnpm add @zap-studio/fetch
 ```
 
+## Runtime Support
+
+| Runtime            | Minimum version                                  |
+| ------------------ | ------------------------------------------------ |
+| Node.js            | 18.0.0 (ships native `fetch`)                    |
+| Bun                | 1.0.0                                            |
+| Deno               | 1.42                                             |
+| Cloudflare Workers | Any current release                              |
+| Browsers           | Latest evergreen (Chrome, Edge, Firefox, Safari) |
+
+The package relies on the global `fetch` API and ships standard ESM only. Deno 1.42 is the first release that can install packages from JSR (`deno add jsr:@zap-studio/fetch`).
+
 ## Quick Example
 
 ```ts
@@ -107,8 +123,7 @@ const created = await api.post("/api/users", UserSchema, {
 });
 ```
 
-In this example, `UserSchema` validates the response from `/api/users`.
-The `json` value is the outgoing request body and is not validated by `UserSchema`.
+In this example, `UserSchema` validates the response from `/api/users`. The `json` value is the outgoing request body and is not validated by `UserSchema`.
 
 These helpers set the HTTP method for you. For raw responses without validation, use `$fetch`.
 
@@ -124,8 +139,7 @@ await api.post("/api/users", UserSchema, {
 });
 ```
 
-The schema argument still validates the response. Validate request bodies separately before
-passing them to `json` if your application needs outgoing payload validation.
+The schema argument still validates the response. Validate request bodies separately before passing them to `json` if your application needs outgoing payload validation.
 
 This sets:
 
@@ -230,7 +244,7 @@ if (result.issues) {
 By default, non-ok responses throw a `FetchError`.
 
 ```ts
-import { FetchError } from "@zap-studio/fetch/errors";
+import { FetchError } from "@zap-studio/fetch";
 
 try {
   await api.get("/api/users/404", UserSchema);

package/dist/constants.d.ts

@@ -0,0 +1,17 @@
+import { FetchDefaults } from "./types.js";
+//#region src/constants.d.ts
+/**
+ * Default options for the global $fetch
+ *
+ * These defaults are used by the top-level `$fetch` export.
+ * Use `createFetch(...)` when you need per-client defaults.
+ *
+ * @example
+ * import { GLOBAL_DEFAULTS } from "@zap-studio/fetch/constants";
+ *
+ * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true
+ */
+declare const GLOBAL_DEFAULTS: FetchDefaults;
+//#endregion
+export { GLOBAL_DEFAULTS };
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/constants.ts"],"mappings":";;;;;;;;;;;;;cAmBa,iBAAiB"}

package/dist/{constants.mjs → constants.js}

@@ -18,4 +18,4 @@ const GLOBAL_DEFAULTS = {
 //#endregion
 export { GLOBAL_DEFAULTS };
 
-//# sourceMappingURL=constants.mjs.map
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Shared defaults and constants for fetch behavior.\n *\n * @module @zap-studio/fetch/constants\n */\n\nimport type { FetchDefaults } from \"./types.js\";\n\n/**\n * Default options for the global $fetch\n *\n * These defaults are used by the top-level `$fetch` export.\n * Use `createFetch(...)` when you need per-client defaults.\n *\n * @example\n * import { GLOBAL_DEFAULTS } from \"@zap-studio/fetch/constants\";\n *\n * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true\n */\nexport const GLOBAL_DEFAULTS: FetchDefaults = {\n  baseURL: \"\",\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n};\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAa,kBAAiC;CAC5C,SAAS;CACT,mBAAmB;CACnB,wBAAwB;AAC1B"}

package/dist/errors.d.ts

@@ -0,0 +1,41 @@
+//#region src/errors.d.ts
+/**
+ * Custom error types used by the fetch package.
+ *
+ * @module @zap-studio/fetch/errors
+ */
+/**
+ * Error thrown for HTTP errors (non-2xx responses)
+ *
+ * Includes the failing `Response` object and status code for
+ * downstream error handling and response inspection.
+ *
+ * @example
+ * import { FetchError } from "@zap-studio/fetch/errors";
+ *
+ * try {
+ *   await $fetch("/users/404");
+ * } catch (error) {
+ *   if (error instanceof FetchError) {
+ *     console.error(error.status);
+ *     console.error(await error.response.text());
+ *   }
+ * }
+ */
+declare class FetchError extends Error {
+  /**
+   * HTTP status code from the failing response.
+   */
+  status: Response["status"];
+  /**
+   * Full response object for additional inspection.
+   */
+  response: Response;
+  /**
+   * Creates a FetchError from a non-ok response.
+   */
+  constructor(message: string, response: Response);
+}
+//#endregion
+export { FetchError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cAwBa,mBAAmB;;;;EAI9B,QAAQ;;;;EAIR,UAAU;;;;EAKV,YAAY,iBAAiB,UAAU"}

package/dist/{errors.mjs → errors.js}

@@ -44,4 +44,4 @@ var FetchError = class extends Error {
 //#endregion
 export { FetchError };
 
-//# sourceMappingURL=errors.mjs.map
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Custom error types used by the fetch package.\n *\n * @module @zap-studio/fetch/errors\n */\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n *\n * Includes the failing `Response` object and status code for\n * downstream error handling and response inspection.\n *\n * @example\n * import { FetchError } from \"@zap-studio/fetch/errors\";\n *\n * try {\n *   await $fetch(\"/users/404\");\n * } catch (error) {\n *   if (error instanceof FetchError) {\n *     console.error(error.status);\n *     console.error(await error.response.text());\n *   }\n * }\n */\nexport class FetchError extends Error {\n  /**\n   * HTTP status code from the failing response.\n   */\n  status: Response[\"status\"];\n  /**\n   * Full response object for additional inspection.\n   */\n  response: Response;\n\n  /**\n   * Creates a FetchError from a non-ok response.\n   */\n  constructor(message: string, response: Response) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = response.status;\n    this.response = response;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAKA,YAAY,SAAiB,UAAoB;EAC/C,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;EACvB,KAAK,WAAW;CAClB;AACF"}

package/dist/fetch-D0IXjsUD.js

@@ -0,0 +1,222 @@
+import { GLOBAL_DEFAULTS } from "./constants.js";
+import { FetchError } from "./errors.js";
+import { mergeHeaders } from "./headers.js";
+import { normalizeRequest } from "./request.js";
+import { resolveRequestUrl } from "./url.js";
+import { isStandardSchema, standardValidate } from "@zap-studio/validation";
+//#region src/_internal.ts
+/**
+* Normalizes request-level options into a final RequestInit payload and runtime flags.
+*
+* @param options - Request-level options.
+* @param defaults - Client-level defaults.
+* @returns Fully merged request init payload and effective runtime flags.
+*/
+const prepareRequestInit = (options, defaults) => {
+	const { headers, json, searchParams, throwOnFetchError = defaults.throwOnFetchError, throwOnValidationError = defaults.throwOnValidationError, ...rest } = options;
+	const init = { ...rest };
+	const mergedHeaders = mergeHeaders(defaults.headers, headers);
+	if (mergedHeaders !== void 0) init.headers = mergedHeaders;
+	if (json !== void 0) {
+		if (init.body !== void 0 && init.body !== null) throw new TypeError("Cannot provide both `body` and `json`.");
+		init.body = JSON.stringify(json);
+		if (init.headers === void 0) init.headers = new Headers({ "Content-Type": "application/json" });
+		else {
+			const requestHeaders = new Headers(init.headers);
+			if (!requestHeaders.has("Content-Type")) requestHeaders.set("Content-Type", "application/json");
+			init.headers = requestHeaders;
+		}
+	}
+	return {
+		init,
+		searchParams,
+		throwOnFetchError,
+		throwOnValidationError
+	};
+};
+/**
+* Internal fetch implementation used by both $fetch and createFetch.
+*
+* This function normalizes request input, resolves final URL + query params,
+* executes `fetch`, optionally throws `FetchError`, and optionally validates
+* JSON response payloads using Standard Schema.
+*
+* @param input - Request URL, path, or Request object.
+* @param schema - Optional Standard Schema for response validation.
+* @param options - Optional request options and package-specific flags.
+* @param defaults - Effective client defaults.
+* @returns Raw `Response` when no schema is provided; otherwise validated output.
+* @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+* @throws {ValidationError} When a schema is provided, validation returns issues, and
+*   `throwOnValidationError` is `true`.
+* @throws {TypeError} When both `body` and `json` are provided, when JSON request
+*   serialization fails, when request construction fails, when headers/search params are
+*   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
+*   implementation rejects network-level failures as `TypeError`.
+* @throws {DOMException} When the runtime rejects an aborted request or response body read
+*   as an `AbortError` DOMException.
+* @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
+*   response body.
+* @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+*/
+const fetchInternal = async (input, schema, options, defaults) => {
+	const request = normalizeRequest(input, options);
+	const { init, searchParams, throwOnFetchError, throwOnValidationError } = prepareRequestInit(request.options, defaults);
+	const url = resolveRequestUrl(request.url, defaults, searchParams);
+	const response = request.request ? await fetch(new Request(url, request.request), init) : await fetch(url, init);
+	if (throwOnFetchError && !response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);
+	if (schema === void 0) return response;
+	const raw = await response.json();
+	if (throwOnValidationError) return await standardValidate(schema, raw, { throwOnError: true });
+	return await standardValidate(schema, raw, { throwOnError: false });
+};
+//#endregion
+//#region src/_methods.ts
+/**
+* Method helper factories used to build verb-specific fetch functions.
+*
+* @module @zap-studio/fetch/_methods (private)
+*/
+/**
+* Creates an HTTP method helper bound to a fetch function.
+*
+* The returned function mirrors `$Fetch` overloads but forces the provided
+* HTTP method (`GET`, `POST`, etc.) into request options.
+*
+* @param fetchFn - Fetch function to wrap.
+* @param method - HTTP method to enforce.
+* @returns Method-bound fetch function.
+* @throws {unknown} Any error thrown or rejected by `fetchFn` when the returned method-bound
+*   fetch function is called.
+*
+* @example
+* const get = createMethod($fetch, "GET");
+* const user = await get("/users/1", UserSchema);
+*/
+const createMethod = (fetchFn, method) => {
+	/**
+	* Method-bound `$Fetch` implementation.
+	*
+	* Resolves schema/option overloads and injects the configured HTTP method.
+	*/
+	async function methodFetch(input, schemaOrOptions, optionsOrUndefined) {
+		if (isStandardSchema(schemaOrOptions)) {
+			if (optionsOrUndefined?.throwOnValidationError === false) return await fetchFn(input, schemaOrOptions, {
+				...optionsOrUndefined,
+				method,
+				throwOnValidationError: false
+			});
+			const { throwOnValidationError, ...restOptions } = optionsOrUndefined ?? {};
+			if (throwOnValidationError === true) return await fetchFn(input, schemaOrOptions, {
+				...restOptions,
+				method,
+				throwOnValidationError: true
+			});
+			return await fetchFn(input, schemaOrOptions, {
+				...restOptions,
+				method
+			});
+		}
+		return await fetchFn(input, {
+			...schemaOrOptions,
+			method
+		});
+	}
+	return methodFetch;
+};
+//#endregion
+//#region src/fetch.ts
+/**
+* Typed fetch client: `$fetch`, `api` method shortcuts, and the `createFetch`
+* instance factory.
+*
+* @module @zap-studio/fetch/fetch
+*/
+async function $fetch(input, schemaOrOptions, optionsOrUndefined) {
+	const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+	return await fetchInternal(input, schema, options, GLOBAL_DEFAULTS);
+}
+/**
+* Convenience methods for common HTTP verbs.
+*
+* These methods always require a schema for validation.
+* For raw responses without validation, use `$fetch` directly.
+*
+* Each method has the same throw behavior as {@link $fetch}.
+*
+* @example
+* import { z } from "zod";
+* import { api } from "@zap-studio/fetch";
+*
+* const PostSchema = z.object({
+*   id: z.number(),
+*   title: z.string(),
+*   content: z.string(),
+* });
+*
+* async function fetchPost(postId: number) {
+*   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+*   return post; // post is typed as { id: number; title: string; content: string; }
+* }
+*/
+const api = {
+	delete: createMethod($fetch, "DELETE"),
+	get: createMethod($fetch, "GET"),
+	patch: createMethod($fetch, "PATCH"),
+	post: createMethod($fetch, "POST"),
+	put: createMethod($fetch, "PUT")
+};
+/**
+* Creates a custom fetch instance with pre-configured defaults.
+*
+* Use this factory to create API clients with a base URL, default headers,
+* and other shared configuration. Each instance is independent.
+*
+* The returned `$fetch` and `api` methods have the same throw behavior as the
+* top-level {@link $fetch} export.
+*
+* @example
+* import { z } from "zod";
+* import { createFetch } from "@zap-studio/fetch";
+*
+* // Create a configured instance
+* const { $fetch, api } = createFetch({
+*   baseURL: "https://api.example.com",
+*   headers: { "Authorization": "Bearer token" },
+* });
+*
+* const UserSchema = z.object({ id: z.number(), name: z.string() });
+*
+* // Now use relative paths - baseURL is prepended automatically
+* const user = await api.get("/users/1", UserSchema);
+*
+* // Or use $fetch directly
+* const response = await $fetch("/users", UserSchema, { method: "POST", json: { name: "John" } });
+*/
+const createFetch = (factoryOptions = {}) => {
+	const defaults = {
+		...GLOBAL_DEFAULTS,
+		...factoryOptions,
+		baseURL: factoryOptions.baseURL ?? GLOBAL_DEFAULTS.baseURL,
+		throwOnFetchError: factoryOptions.throwOnFetchError ?? GLOBAL_DEFAULTS.throwOnFetchError,
+		throwOnValidationError: factoryOptions.throwOnValidationError ?? GLOBAL_DEFAULTS.throwOnValidationError
+	};
+	async function customFetch(input, schemaOrOptions, optionsOrUndefined) {
+		const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+		return await fetchInternal(input, schema, options, defaults);
+	}
+	return {
+		$fetch: customFetch,
+		api: {
+			delete: createMethod(customFetch, "DELETE"),
+			get: createMethod(customFetch, "GET"),
+			patch: createMethod(customFetch, "PATCH"),
+			post: createMethod(customFetch, "POST"),
+			put: createMethod(customFetch, "PUT")
+		}
+	};
+};
+//#endregion
+export { api as n, createFetch as r, $fetch as t };
+
+//# sourceMappingURL=fetch-D0IXjsUD.js.map

package/dist/fetch-D0IXjsUD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-D0IXjsUD.js","names":[],"sources":["../src/_internal.ts","../src/_methods.ts","../src/fetch.ts"],"sourcesContent":["/**\n * Internal request execution and option preparation utilities.\n *\n * @module @zap-studio/fetch/_internal (private)\n */\n\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\nimport { standardValidate } from \"@zap-studio/validation\";\n\nimport { FetchError } from \"./errors.js\";\nimport { mergeHeaders } from \"./headers.js\";\nimport { normalizeRequest } from \"./request.js\";\nimport type {\n  ExtendedRequestInit,\n  FetchDefaults,\n  FetchInput,\n} from \"./types.js\";\nimport { resolveRequestUrl } from \"./url.js\";\n\n/**\n * Normalizes request-level options into a final RequestInit payload and runtime flags.\n *\n * @param options - Request-level options.\n * @param defaults - Client-level defaults.\n * @returns Fully merged request init payload and effective runtime flags.\n */\nconst prepareRequestInit = (\n  options: ExtendedRequestInit,\n  defaults: FetchDefaults\n): {\n  init: RequestInit;\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined;\n  throwOnFetchError: boolean;\n  throwOnValidationError: boolean;\n} => {\n  const {\n    headers,\n    json,\n    searchParams,\n    throwOnFetchError = defaults.throwOnFetchError,\n    throwOnValidationError = defaults.throwOnValidationError,\n    ...rest\n  } = options;\n\n  const init: RequestInit = { ...rest };\n  const mergedHeaders = mergeHeaders(defaults.headers, headers);\n  if (mergedHeaders !== undefined) {\n    init.headers = mergedHeaders;\n  }\n\n  if (json !== undefined) {\n    if (init.body !== undefined && init.body !== null) {\n      throw new TypeError(\"Cannot provide both `body` and `json`.\");\n    }\n\n    init.body = JSON.stringify(json);\n    if (init.headers === undefined) {\n      init.headers = new Headers({ \"Content-Type\": \"application/json\" });\n    } else {\n      const requestHeaders = new Headers(init.headers);\n      if (!requestHeaders.has(\"Content-Type\")) {\n        requestHeaders.set(\"Content-Type\", \"application/json\");\n      }\n      init.headers = requestHeaders;\n    }\n  }\n\n  return {\n    init,\n    searchParams,\n    throwOnFetchError,\n    throwOnValidationError,\n  };\n};\n\n/**\n * Internal fetch implementation used by both $fetch and createFetch.\n *\n * This function normalizes request input, resolves final URL + query params,\n * executes `fetch`, optionally throws `FetchError`, and optionally validates\n * JSON response payloads using Standard Schema.\n *\n * @param input - Request URL, path, or Request object.\n * @param schema - Optional Standard Schema for response validation.\n * @param options - Optional request options and package-specific flags.\n * @param defaults - Effective client defaults.\n * @returns Raw `Response` when no schema is provided; otherwise validated output.\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.\n */\nexport const fetchInternal = async (\n  input: FetchInput,\n  schema: StandardSchemaV1 | undefined,\n  options: ExtendedRequestInit | undefined,\n  defaults: FetchDefaults\n): Promise<unknown> => {\n  const request = normalizeRequest(input, options);\n  const { init, searchParams, throwOnFetchError, throwOnValidationError } =\n    prepareRequestInit(request.options, defaults);\n  const url = resolveRequestUrl(request.url, defaults, searchParams);\n  const response = request.request\n    ? await fetch(new Request(url, request.request), init)\n    : await fetch(url, init);\n\n  if (throwOnFetchError && !response.ok) {\n    throw new FetchError(\n      `HTTP ${response.status}: ${response.statusText}`,\n      response\n    );\n  }\n\n  if (schema === undefined) {\n    return response;\n  }\n\n  const raw: unknown = await response.json();\n  if (throwOnValidationError) {\n    return await standardValidate(schema, raw, { throwOnError: true });\n  }\n  return await standardValidate(schema, raw, { throwOnError: false });\n};\n","/**\n * Method helper factories used to build verb-specific fetch functions.\n *\n * @module @zap-studio/fetch/_methods (private)\n */\n\nimport { isStandardSchema } from \"@zap-studio/validation\";\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport type { $Fetch, ExtendedRequestInit, FetchInput } from \"./types.js\";\n\n/**\n * Creates an HTTP method helper bound to a fetch function.\n *\n * The returned function mirrors `$Fetch` overloads but forces the provided\n * HTTP method (`GET`, `POST`, etc.) into request options.\n *\n * @param fetchFn - Fetch function to wrap.\n * @param method - HTTP method to enforce.\n * @returns Method-bound fetch function.\n * @throws {unknown} Any error thrown or rejected by `fetchFn` when the returned method-bound\n *   fetch function is called.\n *\n * @example\n * const get = createMethod($fetch, \"GET\");\n * const user = await get(\"/users/1\", UserSchema);\n */\nexport const createMethod = (fetchFn: $Fetch, method: string): $Fetch => {\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & {\n      throwOnValidationError: false;\n    }\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  function methodFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    }\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  function methodFetch(\n    input: FetchInput,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  /**\n   * Method-bound `$Fetch` implementation.\n   *\n   * Resolves schema/option overloads and injects the configured HTTP method.\n   */\n  async function methodFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit\n  ): Promise<unknown> {\n    if (isStandardSchema(schemaOrOptions)) {\n      if (optionsOrUndefined?.throwOnValidationError === false) {\n        return await fetchFn(input, schemaOrOptions, {\n          ...optionsOrUndefined,\n          method,\n          throwOnValidationError: false,\n        });\n      }\n\n      const { throwOnValidationError, ...restOptions } =\n        optionsOrUndefined ?? {};\n\n      if (throwOnValidationError === true) {\n        return await fetchFn(input, schemaOrOptions, {\n          ...restOptions,\n          method,\n          throwOnValidationError: true,\n        });\n      }\n\n      return await fetchFn(input, schemaOrOptions, {\n        ...restOptions,\n        method,\n      });\n    }\n\n    return await fetchFn(input, {\n      ...schemaOrOptions,\n      method,\n    });\n  }\n\n  return methodFetch;\n};\n","/**\n * Typed fetch client: `$fetch`, `api` method shortcuts, and the `createFetch`\n * instance factory.\n *\n * @module @zap-studio/fetch/fetch\n */\n\nimport { isStandardSchema } from \"@zap-studio/validation\";\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport { fetchInternal } from \"./_internal.js\";\nimport { createMethod } from \"./_methods.js\";\nimport { GLOBAL_DEFAULTS } from \"./constants.js\";\nimport type {\n  $Fetch,\n  ApiMethods,\n  ExtendedRequestInit,\n  FetchDefaults,\n  FetchInput,\n} from \"./types.js\";\n\n/**\n * Type-safe fetch wrapper with Standard Schema validation.\n *\n * - When `throwOnValidationError: true`: validated data of type `TSchema`\n * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`\n * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses\n *\n * If no schema is provided, returns the raw `Response` object.\n *\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.\n *\n * @example\n * import { z } from \"zod\";\n * import { $fetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage (schema validation)\n * const user = await $fetch(\"/api/users/1\", UserSchema, { headers: { \"Authorization\": \"Bearer token\" } });\n * console.log(\"Validated user:\", user);\n *\n * // Raw usage (no schema validation and typed Response object)\n * const result = await $fetch(\"/api/data\", { method: \"POST\", body: JSON.stringify({ key: \"value\" }) });\n * const json = await result.json() as ResultType;\n * console.log(\"Raw response data:\", json);\n *\n * // Usage with validation errors returned instead of thrown\n * const result = await $fetch(\"/api/users/1\", UserSchema, { throwOnValidationError: false });\n *\n * if (result.issues) {\n *   console.error(\"Validation errors:\", result.issues);\n * } else {\n *   console.log(\"Validated user:\", result.value);\n * }\n */\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options: ExtendedRequestInit & { throwOnValidationError: false }\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options?: ExtendedRequestInit & { throwOnValidationError?: true }\n): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\nexport async function $fetch(\n  input: FetchInput,\n  options?: ExtendedRequestInit\n): Promise<Response>;\n\nexport async function $fetch(\n  input: FetchInput,\n  schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n  optionsOrUndefined?: ExtendedRequestInit\n): Promise<unknown> {\n  const [schema, options] = isStandardSchema(schemaOrOptions)\n    ? [schemaOrOptions, optionsOrUndefined]\n    : [undefined, schemaOrOptions];\n\n  return await fetchInternal(input, schema, options, GLOBAL_DEFAULTS);\n}\n\n/**\n * Convenience methods for common HTTP verbs.\n *\n * These methods always require a schema for validation.\n * For raw responses without validation, use `$fetch` directly.\n *\n * Each method has the same throw behavior as {@link $fetch}.\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api: ApiMethods = {\n  delete: createMethod($fetch, \"DELETE\"),\n  get: createMethod($fetch, \"GET\"),\n  patch: createMethod($fetch, \"PATCH\"),\n  post: createMethod($fetch, \"POST\"),\n  put: createMethod($fetch, \"PUT\"),\n};\n\n/**\n * Creates a custom fetch instance with pre-configured defaults.\n *\n * Use this factory to create API clients with a base URL, default headers,\n * and other shared configuration. Each instance is independent.\n *\n * The returned `$fetch` and `api` methods have the same throw behavior as the\n * top-level {@link $fetch} export.\n *\n * @example\n * import { z } from \"zod\";\n * import { createFetch } from \"@zap-studio/fetch\";\n *\n * // Create a configured instance\n * const { $fetch, api } = createFetch({\n *   baseURL: \"https://api.example.com\",\n *   headers: { \"Authorization\": \"Bearer token\" },\n * });\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Now use relative paths - baseURL is prepended automatically\n * const user = await api.get(\"/users/1\", UserSchema);\n *\n * // Or use $fetch directly\n * const response = await $fetch(\"/users\", UserSchema, { method: \"POST\", json: { name: \"John\" } });\n */\nexport const createFetch = (\n  factoryOptions: Partial<FetchDefaults> = {}\n): {\n  $fetch: $Fetch;\n  api: ApiMethods;\n} => {\n  const defaults: FetchDefaults = {\n    ...GLOBAL_DEFAULTS,\n    ...factoryOptions,\n    baseURL: factoryOptions.baseURL ?? GLOBAL_DEFAULTS.baseURL,\n    throwOnFetchError:\n      factoryOptions.throwOnFetchError ?? GLOBAL_DEFAULTS.throwOnFetchError,\n    throwOnValidationError:\n      factoryOptions.throwOnValidationError ??\n      GLOBAL_DEFAULTS.throwOnValidationError,\n  };\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & { throwOnValidationError: false }\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    }\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  async function customFetch(\n    input: FetchInput,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  async function customFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit\n  ): Promise<unknown> {\n    const [schema, options] = isStandardSchema(schemaOrOptions)\n      ? [schemaOrOptions, optionsOrUndefined]\n      : [undefined, schemaOrOptions];\n\n    return await fetchInternal(input, schema, options, defaults);\n  }\n\n  const customApi = {\n    delete: createMethod(customFetch, \"DELETE\"),\n    get: createMethod(customFetch, \"GET\"),\n    patch: createMethod(customFetch, \"PATCH\"),\n    post: createMethod(customFetch, \"POST\"),\n    put: createMethod(customFetch, \"PUT\"),\n  };\n\n  return {\n    $fetch: customFetch,\n    api: customApi,\n  };\n};\n"],"mappings":"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"}

package/dist/fetch.d.ts

@@ -0,0 +1,114 @@
+import { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput } from "./types.js";
+import { StandardSchemaV1 } from "@zap-studio/validation";
+//#region src/fetch.d.ts
+/**
+ * Type-safe fetch wrapper with Standard Schema validation.
+ *
+ * - When `throwOnValidationError: true`: validated data of type `TSchema`
+ * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`
+ * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses
+ *
+ * If no schema is provided, returns the raw `Response` object.
+ *
+ * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+ * @throws {ValidationError} When a schema is provided, validation returns issues, and
+ *   `throwOnValidationError` is `true`.
+ * @throws {TypeError} When both `body` and `json` are provided, when JSON request
+ *   serialization fails, when request construction fails, when headers/search params are
+ *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
+ *   implementation rejects network-level failures as `TypeError`.
+ * @throws {DOMException} When the runtime rejects an aborted request or response body read
+ *   as an `AbortError` DOMException.
+ * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
+ *   response body.
+ * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { $fetch } from "@zap-studio/fetch";
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Basic usage (schema validation)
+ * const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
+ * console.log("Validated user:", user);
+ *
+ * // Raw usage (no schema validation and typed Response object)
+ * const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
+ * const json = await result.json() as ResultType;
+ * console.log("Raw response data:", json);
+ *
+ * // Usage with validation errors returned instead of thrown
+ * const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
+ *
+ * if (result.issues) {
+ *   console.error("Validation errors:", result.issues);
+ * } else {
+ *   console.log("Validated user:", result.value);
+ * }
+ */
+declare function $fetch<TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
+  throwOnValidationError: false;
+}): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+declare function $fetch<TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options?: ExtendedRequestInit & {
+  throwOnValidationError?: true;
+}): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+declare function $fetch(input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
+/**
+ * Convenience methods for common HTTP verbs.
+ *
+ * These methods always require a schema for validation.
+ * For raw responses without validation, use `$fetch` directly.
+ *
+ * Each method has the same throw behavior as {@link $fetch}.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { api } from "@zap-studio/fetch";
+ *
+ * const PostSchema = z.object({
+ *   id: z.number(),
+ *   title: z.string(),
+ *   content: z.string(),
+ * });
+ *
+ * async function fetchPost(postId: number) {
+ *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+ *   return post; // post is typed as { id: number; title: string; content: string; }
+ * }
+ */
+declare const api: ApiMethods;
+/**
+ * Creates a custom fetch instance with pre-configured defaults.
+ *
+ * Use this factory to create API clients with a base URL, default headers,
+ * and other shared configuration. Each instance is independent.
+ *
+ * The returned `$fetch` and `api` methods have the same throw behavior as the
+ * top-level {@link $fetch} export.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { createFetch } from "@zap-studio/fetch";
+ *
+ * // Create a configured instance
+ * const { $fetch, api } = createFetch({
+ *   baseURL: "https://api.example.com",
+ *   headers: { "Authorization": "Bearer token" },
+ * });
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Now use relative paths - baseURL is prepended automatically
+ * const user = await api.get("/users/1", UserSchema);
+ *
+ * // Or use $fetch directly
+ * const response = await $fetch("/users", UserSchema, { method: "POST", json: { name: "John" } });
+ */
+declare const createFetch: (factoryOptions?: Partial<FetchDefaults>) => {
+  $fetch: $Fetch;
+  api: ApiMethods;
+};
+//#endregion
+export { $fetch, api, createFetch };
+//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","names":[],"sources":["../src/fetch.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEsB,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,SAAS;EAAwB;IAChC,QAAQ,iBAAiB,OAAO,iBAAiB,YAAY;iBAE1C,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,UAAU;EAAwB;IACjC,QAAQ,iBAAiB,YAAY;iBAElB,OACpB,OAAO,YACP,UAAU,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,cACX,iBAAgB,QAAQ;EAExB,QAAQ;EACR,KAAK"}

package/dist/fetch.js

@@ -0,0 +1,3 @@
+import "./constants.js";
+import { n as api, r as createFetch, t as $fetch } from "./fetch-D0IXjsUD.js";
+export { $fetch, api, createFetch };

package/dist/headers.d.ts

@@ -0,0 +1,26 @@
+//#region src/headers.d.ts
+/**
+ * Header utility helpers for request normalization and merging.
+ *
+ * @module @zap-studio/fetch/headers
+ */
+/**
+ * Merges two HeadersInit objects, with the second one taking precedence.
+ *
+ * @param base - Base/default headers.
+ * @param override - Request-level override headers.
+ * @returns A merged `Headers` object, or `undefined` when both inputs are empty.
+ * @throws {TypeError} When either header input contains invalid header names or values.
+ *
+ * @example
+ * const headers = mergeHeaders(
+ *   { Authorization: "Bearer token" },
+ *   { "X-Trace-Id": "abc" },
+ * );
+ *
+ * console.log(headers?.get("Authorization")); // Bearer token
+ */
+declare const mergeHeaders: (base?: HeadersInit, override?: HeadersInit) => Headers | undefined;
+//#endregion
+export { mergeHeaders };
+//# sourceMappingURL=headers.d.ts.map

package/dist/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","names":[],"sources":["../src/headers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAsBa,eACX,OAAO,aACP,WAAW,gBACV"}

package/dist/{headers.mjs → headers.js}

@@ -20,15 +20,15 @@
 *
 * console.log(headers?.get("Authorization")); // Bearer token
 */
-function mergeHeaders(base, override) {
-	if (!(base || override)) return;
-	if (!base) return new Headers(override);
-	if (!override) return new Headers(base);
+const mergeHeaders = (base, override) => {
+	if (base === void 0 && override === void 0) return;
+	if (base === void 0) return new Headers(override);
+	if (override === void 0) return new Headers(base);
 	const merged = new Headers(base);
 	for (const [key, value] of new Headers(override).entries()) merged.set(key, value);
 	return merged;
-}
+};
 //#endregion
 export { mergeHeaders };
 
-//# sourceMappingURL=headers.mjs.map
+//# sourceMappingURL=headers.js.map

package/dist/headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.js","names":[],"sources":["../src/headers.ts"],"sourcesContent":["/**\n * Header utility helpers for request normalization and merging.\n *\n * @module @zap-studio/fetch/headers\n */\n\n/**\n * Merges two HeadersInit objects, with the second one taking precedence.\n *\n * @param base - Base/default headers.\n * @param override - Request-level override headers.\n * @returns A merged `Headers` object, or `undefined` when both inputs are empty.\n * @throws {TypeError} When either header input contains invalid header names or values.\n *\n * @example\n * const headers = mergeHeaders(\n *   { Authorization: \"Bearer token\" },\n *   { \"X-Trace-Id\": \"abc\" },\n * );\n *\n * console.log(headers?.get(\"Authorization\")); // Bearer token\n */\nexport const mergeHeaders = (\n  base?: HeadersInit,\n  override?: HeadersInit\n): Headers | undefined => {\n  if (base === undefined && override === undefined) {\n    return undefined;\n  }\n\n  if (base === undefined) {\n    return new Headers(override);\n  }\n\n  if (override === undefined) {\n    return new Headers(base);\n  }\n\n  const merged = new Headers(base);\n  for (const [key, value] of new Headers(override).entries()) {\n    merged.set(key, value);\n  }\n  return merged;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBACX,MACA,aACwB;CACxB,IAAI,SAAS,KAAA,KAAa,aAAa,KAAA,GACrC;CAGF,IAAI,SAAS,KAAA,GACX,OAAO,IAAI,QAAQ,QAAQ;CAG7B,IAAI,aAAa,KAAA,GACf,OAAO,IAAI,QAAQ,IAAI;CAGzB,MAAM,SAAS,IAAI,QAAQ,IAAI;CAC/B,KAAK,MAAM,CAAC,KAAK,UAAU,IAAI,QAAQ,QAAQ,CAAC,CAAC,QAAQ,GACvD,OAAO,IAAI,KAAK,KAAK;CAEvB,OAAO;AACT"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput } from "./types.js";
+import { GLOBAL_DEFAULTS } from "./constants.js";
+import { FetchError } from "./errors.js";
+import { $fetch, api, createFetch } from "./fetch.js";
+import { mergeHeaders } from "./headers.js";
+import { NormalizedRequest, normalizeRequest } from "./request.js";
+import { resolveRequestUrl } from "./url.js";
+export { type $Fetch, $fetch, type ApiMethods, type ExtendedRequestInit, type FetchDefaults, FetchError, type FetchInput, GLOBAL_DEFAULTS, type NormalizedRequest, api, createFetch, mergeHeaders, normalizeRequest, resolveRequestUrl };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { GLOBAL_DEFAULTS } from "./constants.js";
+import { FetchError } from "./errors.js";
+import { mergeHeaders } from "./headers.js";
+import { normalizeRequest } from "./request.js";
+import { resolveRequestUrl } from "./url.js";
+import { n as api, r as createFetch, t as $fetch } from "./fetch-D0IXjsUD.js";
+export { $fetch, FetchError, GLOBAL_DEFAULTS, api, createFetch, mergeHeaders, normalizeRequest, resolveRequestUrl };