@zap-studio/fetch 0.5.4 → 0.5.6

package/dist/request.d.ts

@@ -0,0 +1,30 @@
+import { ExtendedRequestInit, FetchInput } from "./types.js";
+//#region src/request.d.ts
+/**
+ * Normalized representation used by internal request execution.
+ *
+ * - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)
+ * - `request`: original Request clone when input is a Request
+ * - `options`: normalized request options merged with Request headers
+ */
+interface NormalizedRequest {
+  url: string;
+  request?: Request;
+  options: ExtendedRequestInit;
+}
+/**
+ * Normalizes fetch `input` and request-level options into a consistent internal shape.
+ *
+ * @param input - Request URL/path or Request instance.
+ * @param options - Optional request options.
+ * @returns A normalized request structure for internal processing.
+ * @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.
+ *
+ * @example
+ * const normalized = normalizeRequest("/users", { method: "GET" });
+ * console.log(normalized.url); // "/users"
+ */
+declare const normalizeRequest: (input: FetchInput, options?: ExtendedRequestInit) => NormalizedRequest;
+//#endregion
+export { NormalizedRequest, normalizeRequest };
+//# sourceMappingURL=request.d.ts.map

package/dist/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","names":[],"sources":["../src/request.ts"],"mappings":";;;;;;;;;UAkBiB;EACf;EACA,UAAU;EACV,SAAS;;;;;;;;;;;;;;cAeE,mBACX,OAAO,YACP,UAAU,wBACT"}

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

@@ -1,4 +1,4 @@
-import { mergeHeaders } from "./headers.mjs";
+import { mergeHeaders } from "./headers.js";
 //#region src/request.ts
 /**
 * Request normalization helpers for fetch `input` values.
@@ -18,23 +18,26 @@ const EMPTY_OPTIONS = {};
 * const normalized = normalizeRequest("/users", { method: "GET" });
 * console.log(normalized.url); // "/users"
 */
-function normalizeRequest(input, options) {
-	if (!(input instanceof Request)) return {
-		url: input instanceof URL ? input.href : input,
-		options: options ?? EMPTY_OPTIONS
-	};
+const normalizeRequest = (input, options) => {
+	if (!(input instanceof Request)) {
+		const url = input instanceof URL ? input.href : input;
+		return {
+			options: options ?? EMPTY_OPTIONS,
+			url
+		};
+	}
 	const request = new Request(input);
-	const { headers, ...rest } = options || {};
+	const { headers, ...rest } = options ?? {};
 	const mergedHeaders = mergeHeaders(request.headers, headers);
 	const normalizedOptions = { ...rest };
-	if (mergedHeaders) normalizedOptions.headers = mergedHeaders;
+	if (mergedHeaders !== void 0) normalizedOptions.headers = mergedHeaders;
 	return {
-		url: request.url,
+		options: normalizedOptions,
 		request,
-		options: normalizedOptions
+		url: request.url
 	};
-}
+};
 //#endregion
 export { normalizeRequest };
 
-//# sourceMappingURL=request.mjs.map
+//# sourceMappingURL=request.js.map

package/dist/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","names":[],"sources":["../src/request.ts"],"sourcesContent":["/**\n * Request normalization helpers for fetch `input` values.\n *\n * @module @zap-studio/fetch/request\n */\n\nimport { mergeHeaders } from \"./headers.js\";\nimport type { ExtendedRequestInit, FetchInput } from \"./types.js\";\n\nconst EMPTY_OPTIONS = {} as ExtendedRequestInit;\n\n/**\n * Normalized representation used by internal request execution.\n *\n * - `url`: resolved string URL from the input (string or `URL`; `Request` uses `request.url`)\n * - `request`: original Request clone when input is a Request\n * - `options`: normalized request options merged with Request headers\n */\nexport interface NormalizedRequest {\n  url: string;\n  request?: Request;\n  options: ExtendedRequestInit;\n}\n\n/**\n * Normalizes fetch `input` and request-level options into a consistent internal shape.\n *\n * @param input - Request URL/path or Request instance.\n * @param options - Optional request options.\n * @returns A normalized request structure for internal processing.\n * @throws {TypeError} When cloning a `Request` fails or the merged headers are invalid.\n *\n * @example\n * const normalized = normalizeRequest(\"/users\", { method: \"GET\" });\n * console.log(normalized.url); // \"/users\"\n */\nexport const normalizeRequest = (\n  input: FetchInput,\n  options?: ExtendedRequestInit\n): NormalizedRequest => {\n  if (!(input instanceof Request)) {\n    const url = input instanceof URL ? input.href : input;\n    return {\n      options: options ?? EMPTY_OPTIONS,\n      url,\n    };\n  }\n\n  const request = new Request(input);\n  const { headers, ...rest } = options ?? {};\n  const mergedHeaders = mergeHeaders(request.headers, headers);\n  const normalizedOptions = { ...rest } as ExtendedRequestInit;\n\n  if (mergedHeaders !== undefined) {\n    normalizedOptions.headers = mergedHeaders;\n  }\n\n  return {\n    options: normalizedOptions,\n    request,\n    url: request.url,\n  };\n};\n"],"mappings":";;;;;;;AASA,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;AA2BvB,MAAa,oBACX,OACA,YACsB;CACtB,IAAI,EAAE,iBAAiB,UAAU;EAC/B,MAAM,MAAM,iBAAiB,MAAM,MAAM,OAAO;EAChD,OAAO;GACL,SAAS,WAAW;GACpB;EACF;CACF;CAEA,MAAM,UAAU,IAAI,QAAQ,KAAK;CACjC,MAAM,EAAE,SAAS,GAAG,SAAS,WAAW,CAAC;CACzC,MAAM,gBAAgB,aAAa,QAAQ,SAAS,OAAO;CAC3D,MAAM,oBAAoB,EAAE,GAAG,KAAK;CAEpC,IAAI,kBAAkB,KAAA,GACpB,kBAAkB,UAAU;CAG9B,OAAO;EACL,SAAS;EACT;EACA,KAAK,QAAQ;CACf;AACF"}

package/dist/types.d.ts

@@ -0,0 +1,168 @@
+import { StandardSchemaV1 } from "@zap-studio/validation";
+//#region src/types.d.ts
+/**
+ * Accepted `fetch` input type (`string`, `URL`, or `Request`).
+ */
+type FetchInput = Parameters<typeof fetch>[0];
+type URLSearchParamsInput = ConstructorParameters<typeof URLSearchParams>[0];
+type RequestBodyInit = RequestInit & {
+  json?: never;
+};
+type JsonBodyInit = Omit<RequestInit, "body"> & {
+  /**
+   * JSON body convenience. When provided, this is JSON-stringified into `body`.
+   * @default undefined
+   */
+  json: unknown;
+  body?: never;
+};
+interface CustomRequestInit {
+  /**
+   * Per-request query/search params
+   * @default undefined
+   */
+  searchParams?: URLSearchParamsInput;
+  /**
+   * Whether to throw a FetchError on HTTP errors (non-2xx responses)
+   * @default true
+   */
+  throwOnFetchError?: boolean;
+  /**
+   * Whether to throw a ValidationError on validation errors
+   * @default true
+   */
+  throwOnValidationError?: boolean;
+}
+/**
+ * Extended RequestInit type to include custom fetch options
+ *
+ * @example
+ * const options: ExtendedRequestInit = {
+ *   method: "POST",
+ *   json: { name: "Ada" },
+ *   throwOnFetchError: true,
+ * };
+ */
+type ExtendedRequestInit = (RequestBodyInit | JsonBodyInit) & CustomRequestInit;
+/**
+ * Internal defaults used by fetchInternal
+ *
+ * @example
+ * const defaults: FetchDefaults = {
+ *   baseURL: "https://api.example.com",
+ *   throwOnFetchError: true,
+ *   throwOnValidationError: true,
+ * };
+ */
+interface FetchDefaults {
+  /**
+   * Base URL to prepend to all requests
+   * @default ""
+   */
+  baseURL: string;
+  /**
+   * Default headers to include in all requests (can be overridden per request)
+   * @default undefined
+   */
+  headers?: HeadersInit;
+  /**
+   * Default query/search params applied to every request (can be overridden per request)
+   * @default undefined
+   */
+  searchParams?: URLSearchParamsInput;
+  /**
+   * Whether to throw a `FetchError` on HTTP errors (non-2xx responses)
+   * @default true
+   */
+  throwOnFetchError: boolean;
+  /**
+   * Whether to throw a `ValidationError` on validation errors
+   * @default true
+   */
+  throwOnValidationError: boolean;
+}
+/**
+ * Type-safe fetch function with Standard Schema validation support
+ */
+interface $Fetch {
+  /**
+   * Fetch with schema validation and throwOnValidationError: false
+   * @param input - URL or path to fetch
+   * @param schema - Standard Schema for response validation
+   * @param options - Extended request options with throwOnValidationError: false
+   * @returns Standard Schema Result object with value or issues
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, native `fetch`, or `response.json()` body reading fail with a
+   *   `TypeError`.
+   * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+   *   request/body read as an `AbortError` DOMException.
+   * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+   * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+   */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
+    throwOnValidationError: false;
+  }): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  /**
+   * Fetch with schema validation and throwOnValidationError: true or undefined (default)
+   * @param input - URL or path to fetch
+   * @param schema - Standard Schema for response validation
+   * @param options - Extended request options
+   * @returns Validated data of type TSchema
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {ValidationError} When validation returns issues.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, native `fetch`, or `response.json()` body reading fail with a
+   *   `TypeError`.
+   * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+   *   request/body read as an `AbortError` DOMException.
+   * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+   * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+   */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options?: ExtendedRequestInit & {
+    throwOnValidationError?: true;
+  }): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+  /**
+   * Fetch without schema validation
+   * @param input - URL or path to fetch
+   * @param options - Extended request options
+   * @returns Raw Response object
+   * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+   * @throws {TypeError} When request construction, JSON request serialization, headers,
+   *   search params, or native `fetch` fail with a `TypeError`.
+   * @throws {DOMException} When native `fetch` rejects an aborted request as an
+   *   `AbortError` DOMException.
+   */
+  (input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
+}
+/**
+ * API HTTP method-specific fetch functions
+ *
+ * @example
+ * const user = await api.get("/users/1", UserSchema);
+ */
+interface ApiMethods {
+  /**
+   * DELETE method fetch function
+   */
+  delete: $Fetch;
+  /**
+   * GET method fetch function
+   */
+  get: $Fetch;
+  /**
+   * PATCH method fetch function
+   */
+  patch: $Fetch;
+  /**
+   * POST method fetch function
+   */
+  post: $Fetch;
+  /**
+   * PUT method fetch function
+   */
+  put: $Fetch;
+}
+//#endregion
+export { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;KAWY,aAAa,kBAAkB;KAEtC,uBAAuB,6BAA6B;KAEpD,kBAAkB;EACrB;;KAGG,eAAe,KAAK;;;;;EAKvB;EACA;;UAGQ;;;;;EAKR,eAAe;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;KAaU,uBAAuB,kBAAkB,gBACnD;;;;;;;;;;;UAYe;;;;;EAKf;;;;;EAKA,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;EAKA;;;;;UAMe;;;;;;;;;;;;;;;;GAgBd,gBAAgB,kBACf,OAAO,YACP,QAAQ,SACR,SAAS;IAAwB;MAChC,QAAQ,iBAAiB,OAAO,iBAAiB,YAAY;;;;;;;;;;;;;;;;;GAkB/D,gBAAgB,kBACf,OAAO,YACP,QAAQ,SACR,UAAU;IACR;MAED,QAAQ,iBAAiB,YAAY;;;;;;;;;;;;GAavC,OAAO,YAAY,UAAU,sBAAsB,QAAQ;;;;;;;;UAS7C;;;;EAIf,QAAQ;;;;EAIR,KAAK;;;;EAIL,OAAO;;;;EAIP,MAAM;;;;EAIN,KAAK"}

package/dist/url.d.ts

@@ -0,0 +1,26 @@
+import { ExtendedRequestInit, FetchDefaults } from "./types.js";
+//#region src/url.d.ts
+/**
+ * Resolves final request URL by applying baseURL and layered search params.
+ *
+ * Search param precedence:
+ * 1. `defaults.searchParams`
+ * 2. search params already present in `resourceUrl`
+ * 3. per-request `searchParams`
+ *
+ * @example
+ * const finalUrl = resolveRequestUrl(
+ *   "/users?page=2",
+ *   { ...defaults, baseURL: "https://api.example.com", searchParams: { locale: "en" } },
+ *   { page: "3" },
+ * );
+ * // https://api.example.com/users?locale=en&page=3
+ *
+ * @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by
+ *   `URL`, or when default/per-request search params cannot be converted by
+ *   `URLSearchParams`.
+ */
+declare const resolveRequestUrl: (resourceUrl: string, defaults: FetchDefaults, searchParams?: ExtendedRequestInit["searchParams"]) => string;
+//#endregion
+export { resolveRequestUrl };
+//# sourceMappingURL=url.d.ts.map

package/dist/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAmFa,oBACX,qBACA,UAAU,eACV,eAAe"}

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

@@ -1,5 +1,36 @@
 //#region src/url.ts
 /**
+* Copies search params into target, overriding duplicate keys.
+*/
+const mergeSearchParams = (target, source) => {
+	for (const [key, value] of new URLSearchParams(source)) target.set(key, value);
+};
+/**
+* Ensures a URL has a trailing slash for relative URL resolution.
+*/
+const ensureTrailingSlash = (url) => url.endsWith("/") ? url : `${url}/`;
+/**
+* Resolves search params by applying default params, URL params, then request params.
+*/
+const resolveSearchParams = (url, defaultSearchParams, searchParams) => {
+	if (defaultSearchParams === void 0 && searchParams === void 0) return url;
+	const hashIndex = url.indexOf("#");
+	const hasFragment = hashIndex !== -1;
+	const urlWithoutHash = hasFragment ? url.slice(0, hashIndex) : url;
+	const hash = hasFragment ? url.slice(hashIndex + 1) : "";
+	const queryIndex = urlWithoutHash.indexOf("?");
+	const pathname = queryIndex === -1 ? urlWithoutHash : urlWithoutHash.slice(0, queryIndex);
+	const urlSearchParams = queryIndex === -1 ? void 0 : urlWithoutHash.slice(queryIndex + 1);
+	const resolvedSearchParams = new URLSearchParams();
+	mergeSearchParams(resolvedSearchParams, defaultSearchParams);
+	mergeSearchParams(resolvedSearchParams, urlSearchParams);
+	mergeSearchParams(resolvedSearchParams, searchParams);
+	const resolvedSearch = resolvedSearchParams.toString();
+	const fragmentSuffix = hasFragment ? `#${hash}` : "";
+	if (resolvedSearch.length === 0) return `${pathname}${fragmentSuffix}`;
+	return `${pathname}?${resolvedSearch}${fragmentSuffix}`;
+};
+/**
 * Resolves final request URL by applying baseURL and layered search params.
 *
 * Search param precedence:
@@ -19,43 +50,11 @@
 *   `URL`, or when default/per-request search params cannot be converted by
 *   `URLSearchParams`.
 */
-function resolveRequestUrl(resourceUrl, defaults, searchParams) {
-	return resolveSearchParams(defaults.baseURL ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString() : resourceUrl, defaults.searchParams, searchParams);
-}
-/**
-* Resolves search params by applying default params, URL params, then request params.
-*/
-function resolveSearchParams(url, defaultSearchParams, searchParams) {
-	if (!defaultSearchParams && searchParams === void 0) return url;
-	const hashIndex = url.indexOf("#");
-	const hasFragment = hashIndex >= 0;
-	const urlWithoutHash = hasFragment ? url.slice(0, hashIndex) : url;
-	const hash = hasFragment ? url.slice(hashIndex + 1) : "";
-	const queryIndex = urlWithoutHash.indexOf("?");
-	const pathname = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
-	const urlSearchParams = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : void 0;
-	const resolvedSearchParams = new URLSearchParams();
-	mergeSearchParams(resolvedSearchParams, defaultSearchParams);
-	mergeSearchParams(resolvedSearchParams, urlSearchParams);
-	mergeSearchParams(resolvedSearchParams, searchParams);
-	const resolvedSearch = resolvedSearchParams.toString();
-	const fragmentSuffix = hasFragment ? `#${hash}` : "";
-	if (!resolvedSearch) return `${pathname}${fragmentSuffix}`;
-	return `${pathname}?${resolvedSearch}${fragmentSuffix}`;
-}
-/**
-* Ensures a URL has a trailing slash for relative URL resolution.
-*/
-function ensureTrailingSlash(url) {
-	return url.endsWith("/") ? url : `${url}/`;
-}
-/**
-* Copies search params into target, overriding duplicate keys.
-*/
-function mergeSearchParams(target, source) {
-	for (const [key, value] of new URLSearchParams(source)) target.set(key, value);
-}
+const resolveRequestUrl = (resourceUrl, defaults, searchParams) => {
+	const url = defaults.baseURL ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString() : resourceUrl;
+	return resolveSearchParams(url, defaults.searchParams, searchParams);
+};
 //#endregion
 export { resolveRequestUrl };
 
-//# sourceMappingURL=url.mjs.map
+//# sourceMappingURL=url.js.map

package/dist/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * URL resolution and query merging utilities.\n *\n * @module @zap-studio/fetch/url\n */\n\nimport type { ExtendedRequestInit, FetchDefaults } from \"./types.js\";\n\n/**\n * Copies search params into target, overriding duplicate keys.\n */\nconst mergeSearchParams = (\n  target: URLSearchParams,\n  source: ExtendedRequestInit[\"searchParams\"] | undefined\n): void => {\n  for (const [key, value] of new URLSearchParams(source)) {\n    target.set(key, value);\n  }\n};\n\n/**\n * Ensures a URL has a trailing slash for relative URL resolution.\n */\nconst ensureTrailingSlash = (url: string): string =>\n  url.endsWith(\"/\") ? url : `${url}/`;\n\n/**\n * Resolves search params by applying default params, URL params, then request params.\n */\nconst resolveSearchParams = (\n  url: string,\n  defaultSearchParams: FetchDefaults[\"searchParams\"] | undefined,\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined\n): string => {\n  if (defaultSearchParams === undefined && searchParams === undefined) {\n    return url;\n  }\n\n  const hashIndex = url.indexOf(\"#\");\n  const hasFragment = hashIndex !== -1;\n  const urlWithoutHash = hasFragment ? url.slice(0, hashIndex) : url;\n  const hash = hasFragment ? url.slice(hashIndex + 1) : \"\";\n  const queryIndex = urlWithoutHash.indexOf(\"?\");\n  const pathname =\n    queryIndex === -1 ? urlWithoutHash : urlWithoutHash.slice(0, queryIndex);\n  const urlSearchParams =\n    queryIndex === -1 ? undefined : urlWithoutHash.slice(queryIndex + 1);\n  const resolvedSearchParams = new URLSearchParams();\n\n  mergeSearchParams(resolvedSearchParams, defaultSearchParams);\n  mergeSearchParams(resolvedSearchParams, urlSearchParams);\n  mergeSearchParams(resolvedSearchParams, searchParams);\n\n  const resolvedSearch = resolvedSearchParams.toString();\n  const fragmentSuffix = hasFragment ? `#${hash}` : \"\";\n\n  if (resolvedSearch.length === 0) {\n    return `${pathname}${fragmentSuffix}`;\n  }\n\n  return `${pathname}?${resolvedSearch}${fragmentSuffix}`;\n};\n\n/**\n * Resolves final request URL by applying baseURL and layered search params.\n *\n * Search param precedence:\n * 1. `defaults.searchParams`\n * 2. search params already present in `resourceUrl`\n * 3. per-request `searchParams`\n *\n * @example\n * const finalUrl = resolveRequestUrl(\n *   \"/users?page=2\",\n *   { ...defaults, baseURL: \"https://api.example.com\", searchParams: { locale: \"en\" } },\n *   { page: \"3\" },\n * );\n * // https://api.example.com/users?locale=en&page=3\n *\n * @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by\n *   `URL`, or when default/per-request search params cannot be converted by\n *   `URLSearchParams`.\n */\nexport const resolveRequestUrl = (\n  resourceUrl: string,\n  defaults: FetchDefaults,\n  searchParams?: ExtendedRequestInit[\"searchParams\"]\n): string => {\n  const url = defaults.baseURL\n    ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString()\n    : resourceUrl;\n\n  return resolveSearchParams(url, defaults.searchParams, searchParams);\n};\n"],"mappings":";;;;AAWA,MAAM,qBACJ,QACA,WACS;CACT,KAAK,MAAM,CAAC,KAAK,UAAU,IAAI,gBAAgB,MAAM,GACnD,OAAO,IAAI,KAAK,KAAK;AAEzB;;;;AAKA,MAAM,uBAAuB,QAC3B,IAAI,SAAS,GAAG,IAAI,MAAM,GAAG,IAAI;;;;AAKnC,MAAM,uBACJ,KACA,qBACA,iBACW;CACX,IAAI,wBAAwB,KAAA,KAAa,iBAAiB,KAAA,GACxD,OAAO;CAGT,MAAM,YAAY,IAAI,QAAQ,GAAG;CACjC,MAAM,cAAc,cAAc;CAClC,MAAM,iBAAiB,cAAc,IAAI,MAAM,GAAG,SAAS,IAAI;CAC/D,MAAM,OAAO,cAAc,IAAI,MAAM,YAAY,CAAC,IAAI;CACtD,MAAM,aAAa,eAAe,QAAQ,GAAG;CAC7C,MAAM,WACJ,eAAe,KAAK,iBAAiB,eAAe,MAAM,GAAG,UAAU;CACzE,MAAM,kBACJ,eAAe,KAAK,KAAA,IAAY,eAAe,MAAM,aAAa,CAAC;CACrE,MAAM,uBAAuB,IAAI,gBAAgB;CAEjD,kBAAkB,sBAAsB,mBAAmB;CAC3D,kBAAkB,sBAAsB,eAAe;CACvD,kBAAkB,sBAAsB,YAAY;CAEpD,MAAM,iBAAiB,qBAAqB,SAAS;CACrD,MAAM,iBAAiB,cAAc,IAAI,SAAS;CAElD,IAAI,eAAe,WAAW,GAC5B,OAAO,GAAG,WAAW;CAGvB,OAAO,GAAG,SAAS,GAAG,iBAAiB;AACzC;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,qBACX,aACA,UACA,iBACW;CACX,MAAM,MAAM,SAAS,UACjB,IAAI,IAAI,aAAa,oBAAoB,SAAS,OAAO,CAAC,CAAC,CAAC,SAAS,IACrE;CAEJ,OAAO,oBAAoB,KAAK,SAAS,cAAc,YAAY;AACrE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "private": false,
   "description": "A type-safe fetch wrapper for HTTP requests with runtime schema validation.",
   "keywords": [
@@ -35,43 +35,34 @@
   ],
   "type": "module",
   "sideEffects": false,
-  "types": "./dist/index.d.mts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./constants": "./dist/constants.mjs",
-    "./errors": "./dist/errors.mjs",
-    "./headers": "./dist/headers.mjs",
-    "./internal": "./dist/internal.mjs",
-    "./methods": "./dist/methods.mjs",
-    "./request": "./dist/request.mjs",
-    "./types": "./dist/types.mjs",
-    "./url": "./dist/url.mjs",
+    ".": "./dist/index.js",
+    "./constants": "./dist/constants.js",
+    "./errors": "./dist/errors.js",
+    "./fetch": "./dist/fetch.js",
+    "./headers": "./dist/headers.js",
+    "./request": "./dist/request.js",
+    "./types": "./dist/types.js",
+    "./url": "./dist/url.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@zap-studio/validation": "0.3.4"
+    "@zap-studio/validation": "workspace:*"
   },
   "devDependencies": {
-    "@better-fetch/fetch": "^1.1.21",
-    "arktype": "^2.2.0",
-    "axios": "^1.15.2",
-    "ky": "^2.0.2",
-    "ofetch": "^1.5.1",
-    "typescript": "^6.0.3",
-    "valibot": "^1.3.1",
-    "vite-plus": "^0.1.19",
-    "zod": "^4.3.6",
-    "@zap-studio/typescript": "0.0.0"
+    "@zap-studio/typescript": "workspace:*",
+    "arktype": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "valibot": "catalog:",
+    "vitest": "catalog:",
+    "zod": "catalog:"
   },
   "engines": {
     "node": ">=18.0.0"
-  },
-  "scripts": {
-    "build": "vp pack",
-    "test": "vp test run",
-    "test:watch": "vp test watch"
   }
-}
+}

package/dist/constants.d.mts

@@ -1,18 +0,0 @@
-import { FetchDefaults } from "./types.mjs";
-
-//#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.mts.map

package/dist/constants.d.mts.map

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

package/dist/constants.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.mjs","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;CACzB"}

package/dist/errors.d.mts

@@ -1,41 +0,0 @@
-//#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.mts.map

package/dist/errors.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;AAwBA;;;;;;;;;;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;;;;EAI9B,MAAA,EAAQ,QAAA;;;;EAIR,QAAA,EAAU,QAAA;;;;EAKV,WAAA,CAAY,OAAA,UAAiB,QAAA,EAAU,QAAA;AAAA"}

package/dist/errors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.mjs","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;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW"}

package/dist/headers.d.mts

@@ -1,26 +0,0 @@
-//#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 function mergeHeaders(base?: HeadersInit, override?: HeadersInit): Headers | undefined;
-//#endregion
-export { mergeHeaders };
-//# sourceMappingURL=headers.d.mts.map

package/dist/headers.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"headers.d.mts","names":[],"sources":["../src/headers.ts"],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,CAAa,IAAA,GAAO,WAAA,EAAa,QAAA,GAAW,WAAA,GAAc,OAAA"}

package/dist/headers.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"headers.mjs","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 function mergeHeaders(base?: HeadersInit, override?: HeadersInit): Headers | undefined {\n  if (!(base || override)) {\n    return;\n  }\n\n  if (!base) {\n    return new Headers(override);\n  }\n\n  if (!override) {\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,SAAgB,aAAa,MAAoB,UAA6C;AAC5F,KAAI,EAAE,QAAQ,UACZ;AAGF,KAAI,CAAC,KACH,QAAO,IAAI,QAAQ,SAAS;AAG9B,KAAI,CAAC,SACH,QAAO,IAAI,QAAQ,KAAK;CAG1B,MAAM,SAAS,IAAI,QAAQ,KAAK;AAChC,MAAK,MAAM,CAAC,KAAK,UAAU,IAAI,QAAQ,SAAS,CAAC,SAAS,CACxD,QAAO,IAAI,KAAK,MAAM;AAExB,QAAO"}