@zap-studio/fetch 0.5.6 → 1.0.0

package/dist/constants.js

@@ -1,21 +0,0 @@
-//#region src/constants.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
-*/
-const GLOBAL_DEFAULTS = {
-	baseURL: "",
-	throwOnFetchError: true,
-	throwOnValidationError: true
-};
-//#endregion
-export { GLOBAL_DEFAULTS };
-
-//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"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/fetch-D0IXjsUD.js

@@ -1,222 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,114 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,3 +0,0 @@
-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

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

package/dist/headers.d.ts.map

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

package/dist/headers.js

@@ -1,34 +0,0 @@
-//#region src/headers.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
-*/
-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.js.map

package/dist/headers.js.map

@@ -1 +0,0 @@
-{"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/request.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.js

@@ -1,43 +0,0 @@
-import { mergeHeaders } from "./headers.js";
-//#region src/request.ts
-/**
-* Request normalization helpers for fetch `input` values.
-*
-* @module @zap-studio/fetch/request
-*/
-const EMPTY_OPTIONS = {};
-/**
-* 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"
-*/
-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 mergedHeaders = mergeHeaders(request.headers, headers);
-	const normalizedOptions = { ...rest };
-	if (mergedHeaders !== void 0) normalizedOptions.headers = mergedHeaders;
-	return {
-		options: normalizedOptions,
-		request,
-		url: request.url
-	};
-};
-//#endregion
-export { normalizeRequest };
-
-//# sourceMappingURL=request.js.map

package/dist/request.js.map

@@ -1 +0,0 @@
-{"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/url.d.ts

@@ -1,26 +0,0 @@
-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

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