@zap-studio/fetch 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @zap-studio/fetch
 
+## 0.2.0
+
+### Minor Changes
+
+- 78afb76: ### Standard Schema Support
+
+  Migrated from Zod-only validation to **Standard Schema v1** specification, enabling support for multiple validation libraries:
+
+  - Zod
+  - Valibot
+  - ArkType
+  - Any Standard Schema compliant library
+
+  ### New Features
+
+  - **Factory Pattern**: `createFetch()` for creating pre-configured fetch instances with `baseURL`, default `headers`, and error handling options
+  - **Smart URL Handling**: Absolute URLs bypass `baseURL` configuration
+  - **Auto JSON Body**: Automatic `JSON.stringify()` and `Content-Type` header when using schemas with request bodies
+
+  ### Breaking Changes
+
+  - Schema validation now requires Standard Schema compliant libraries (Zod 3.23+, Valibot 1.0+, ArkType 2.0+)
+  - Internal file structure reorganized (affects deep imports if any were used)
+  - `FetchError` constructor signature changed: now requires `(message, response)`
+
+  ### Migration Guide
+
+  ```typescript
+  // Before (Zod-only)
+  import { $fetch } from "@zap-studio/fetch";
+  import { z } from "zod";
+
+  // After (Standard Schema - works the same with Zod!)
+  import { $fetch } from "@zap-studio/fetch";
+  import { z } from "zod"; // Zod 3.23+ is Standard Schema compliant
+
+  // Or use other libraries
+  import * as v from "valibot";
+  import { type } from "arktype";
+  ```
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -1,22 +1,38 @@
 # @zap-studio/fetch
 
-A type-safe fetch wrapper with Zod validation for TypeScript.
+A type-safe fetch wrapper with Standard Schema validation.
+
+## Why @zap-studio/fetch?
+
+**Before:**
+
+```typescript
+const response = await fetch("/api/users/1");
+const data = await response.json();
+const user = data as User; // 😱 Unsafe type assertion
+```
+
+**After:**
+
+```typescript
+const user = await api.get("/api/users/1", UserSchema);
+// ✨ Typed, validated, and safe!
+```
 
 ## Features
 
 - 🎯 **Type-safe requests** with automatic type inference
-- 🛡️ **Runtime validation** using Zod schemas
-- 🔄 **Automatic content-type** detection and handling
+- 🛡️ **Runtime validation** using Standard Schema (Zod, Valibot, ArkType, etc.)
 - ⚡️ **Convenient API methods** (GET, POST, PUT, PATCH, DELETE)
-- 📦 **Multiple response types** (JSON, text, blob, arrayBuffer)
-- 🚨 **Custom error handling** with FetchError class
+- 🏭 **Factory pattern** for creating pre-configured instances with base URLs
+- 🚨 **Custom error handling** with FetchError and ValidationError classes
 - 📘 **Full TypeScript support** with zero configuration
 
 ## Installation
 
 ```bash
 pnpm add @zap-studio/fetch
-#or
+# or
 npm install @zap-studio/fetch
 ```
 
@@ -34,10 +50,7 @@ const UserSchema = z.object({
 });
 
 // Make a type-safe request
-const user = await api.get(
-  "https://api.example.com/users/1",
-  UserSchema
-);
+const user = await api.get("https://api.example.com/users/1", UserSchema);
 
 // user is fully typed and validated! ✨
 console.log(user.name); // TypeScript knows this is a string
@@ -51,28 +64,31 @@ console.log(user.name); // TypeScript knows this is a string
 const user = await api.get("/api/users/1", UserSchema);
 ```
 
-### `api.post(url, schema, body?, options?)`
+### `api.post(url, schema, options?)`
 
 ```typescript
 const newUser = await api.post("/api/users", UserSchema, {
-  name: "John Doe",
-  email: "john@example.com",
+  body: {
+    name: "John Doe",
+    email: "john@example.com",
+  },
 });
+// Automatically stringifies body and sets Content-Type: application/json
 ```
 
-### `api.put(url, schema, body?, options?)`
+### `api.put(url, schema, options?)`
 
 ```typescript
 const updated = await api.put("/api/users/1", UserSchema, {
-  name: "Jane Doe",
+  body: { name: "Jane Doe" },
 });
 ```
 
-### `api.patch(url, schema, body?, options?)`
+### `api.patch(url, schema, options?)`
 
 ```typescript
 const patched = await api.patch("/api/users/1", UserSchema, {
-  email: "newemail@example.com",
+  body: { email: "newemail@example.com" },
 });
 ```
 
@@ -82,58 +98,121 @@ const patched = await api.patch("/api/users/1", UserSchema, {
 const deleted = await api.delete("/api/users/1", UserSchema);
 ```
 
+> **Note:** The `api.*` methods always require a schema for validation. For raw responses without validation, use `$fetch` directly.
+
 ## Advanced Usage
 
 ### Using `$fetch` directly
 
+For more control or when you don't need schema validation:
+
 ```typescript
 import { $fetch } from "@zap-studio/fetch";
 
-const result = await $fetch(
-  "https://api.example.com/users/1",
-  UserSchema,
-  {
-    method: "GET",
-    headers: {
-      "Authorization": "Bearer token",
-    },
-  }
-);
+// With schema validation
+const user = await $fetch("https://api.example.com/users/1", UserSchema, {
+  method: "GET",
+  headers: {
+    Authorization: "Bearer token",
+  },
+});
+
+// Without schema - returns raw Response object
+const response = await $fetch("https://api.example.com/users/1", {
+  method: "GET",
+});
+const data = await response.json();
 ```
 
-### Custom response types
+### Factory Pattern with `createFetch`
+
+Create pre-configured fetch instances with base URLs and default headers. Useful for API clients:
 
 ```typescript
-// Get text response
-const text = await $fetch(
-  "/api/data",
-  z.string(),
-  { responseType: "text" }
-);
-
-// Get blob response
-const blob = await $fetch(
-  "/api/file",
-  z.instanceof(Blob),
-  { responseType: "blob" }
-);
+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 your-token",
+    "X-API-Key": "your-api-key",
+  },
+});
+
+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);
+
+// POST with auto-stringified body
+const newUser = await api.post("/users", UserSchema, {
+  body: { name: "John Doe" },
+});
 ```
 
-### Error handling
+#### Factory Options
+
+| Option                   | Type          | Default | Description                                      |
+| ------------------------ | ------------- | ------- | ------------------------------------------------ |
+| `baseURL`                | `string`      | `""`    | Base URL prepended to relative paths only        |
+| `headers`                | `HeadersInit` | -       | Default headers included in all requests         |
+| `throwOnFetchError`      | `boolean`     | `true`  | Throw `FetchError` on non-2xx responses          |
+| `throwOnValidationError` | `boolean`     | `true`  | Throw `ValidationError` on schema validation failures |
+
+> **Note:** Absolute URLs (starting with `http://`, `https://`, or `//`) are used as-is and ignore the `baseURL`.
+
+#### Multiple API Clients
+
+You can create separate fetch instances for different APIs:
 
 ```typescript
-import { FetchError } from "@zap-studio/fetch/errors";
+import { createFetch } from "@zap-studio/fetch";
+
+// GitHub API client
+const github = createFetch({
+  baseURL: "https://api.github.com",
+  headers: { Authorization: "Bearer github-token" },
+});
+
+// Your internal API client
+const internal = createFetch({
+  baseURL: "https://internal.example.com/api",
+  headers: { "X-Internal-Key": "secret" },
+});
+
+// Use them independently
+const repo = await github.api.get("/repos/owner/repo", RepoSchema);
+const data = await internal.api.get("/data", DataSchema);
+```
+
+### Error Handling
+
+The package exports specialized error classes for granular error handling:
+
+```typescript
+import { $fetch } from "@zap-studio/fetch";
+import { FetchError, ValidationError } from "@zap-studio/fetch/errors";
 
 try {
   const user = await api.get("/api/users/1", UserSchema);
 } catch (error) {
   if (error instanceof FetchError) {
-    console.error(`HTTP ${error.status}: ${error.statusText}`);
+    console.error(`HTTP ${error.status}: ${error.response.statusText}`);
+  }
+  if (error instanceof ValidationError) {
+    console.error("Validation failed:", error.issues);
   }
 }
 ```
 
-### Flexible validation
+### Flexible Validation
+
+You can choose whether validation errors should throw exceptions:
 
 ```typescript
 // Throw on validation error (default)
@@ -146,24 +225,9 @@ const result = await $fetch(url, UserSchema, {
   throwOnValidationError: false,
 });
 
-if (result.success) {
-  console.log(result.data);
+if (result.issues) {
+  console.error("Validation failed:", result.issues);
 } else {
-  console.error(result.error);
+  console.log("Success:", result.value);
 }
 ```
-
-## Why @zap-studio/fetch?
-
-**Before:**
-```typescript
-const response = await fetch("/api/users/1");
-const data = await response.json();
-const user = data as User; // 😱 Unsafe type assertion
-```
-
-**After:**
-```typescript
-const user = await api.get("/api/users/1", UserSchema);
-// ✨ Typed, validated, and safe!
-```

package/dist/errors-DKxnbFHZ.mjs

@@ -0,0 +1,29 @@
+//#region src/errors.ts
+/**
+* Error thrown for HTTP errors (non-2xx responses)
+*/
+var FetchError = class extends Error {
+	status;
+	response;
+	constructor(message, response) {
+		super(message);
+		this.name = "FetchError";
+		this.status = response.status;
+		this.response = response;
+	}
+};
+/**
+* Error thrown for validation errors
+*/
+var ValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(JSON.stringify(issues, null, 2));
+		this.name = "ValidationError";
+		this.issues = issues;
+	}
+};
+
+//#endregion
+export { ValidationError as n, FetchError as t };
+//# sourceMappingURL=errors-DKxnbFHZ.mjs.map

package/dist/errors-DKxnbFHZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DKxnbFHZ.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n */\nexport class FetchError extends Error {\n  status: Response[\"status\"];\n  response: 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\n/**\n * Error thrown for validation errors\n */\nexport class ValidationError extends Error {\n  issues: StandardSchemaV1.Issue[];\n\n  constructor(issues: StandardSchemaV1.Issue[]) {\n    super(JSON.stringify(issues, null, 2));\n    this.name = \"ValidationError\";\n    this.issues = issues;\n  }\n}\n"],"mappings":";;;;AAKA,IAAa,aAAb,cAAgC,MAAM;CACpC;CACA;CAEA,YAAY,SAAiB,UAAoB;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW;;;;;;AAOpB,IAAa,kBAAb,cAAqC,MAAM;CACzC;CAEA,YAAY,QAAkC;AAC5C,QAAM,KAAK,UAAU,QAAQ,MAAM,EAAE,CAAC;AACtC,OAAK,OAAO;AACZ,OAAK,SAAS"}

package/dist/errors.d.mts

@@ -0,0 +1,22 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/errors.d.ts
+
+/**
+ * Error thrown for HTTP errors (non-2xx responses)
+ */
+declare class FetchError extends Error {
+  status: Response["status"];
+  response: Response;
+  constructor(message: string, response: Response);
+}
+/**
+ * Error thrown for validation errors
+ */
+declare class ValidationError extends Error {
+  issues: StandardSchemaV1.Issue[];
+  constructor(issues: StandardSchemaV1.Issue[]);
+}
+//#endregion
+export { FetchError, ValidationError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AACU,cADG,UAAA,SAAmB,KAAA,CACtB;EACE,MAAA,EADF,QACE,CAAA,QAAA,CAAA;EAE6B,QAAA,EAF7B,QAE6B;EAJT,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EAIS,QAJT;;AAehC;;;AAAqC,cAAxB,eAAA,SAAwB,KAAA,CAAA;EAAK,MAAA,EAChC,gBAAA,CAAiB,KADe,EAAA;sBAGpB,gBAAA,CAAiB"}

package/dist/errors.mjs

@@ -0,0 +1,3 @@
+import { n as ValidationError, t as FetchError } from "./errors-DKxnbFHZ.mjs";
+
+export { FetchError, ValidationError };

package/dist/index.d.mts

@@ -1,37 +1,51 @@
-import { n as ResponseType, t as FetchConfig } from "./index-Dz58_HD6.mjs";
-import { z } from "zod";
+import { n as ExtendedRequestInit, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/index.d.ts
 
 /**
- * Type-safe fetch wrapper with Zod validation
+ * 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: true` and response is not ok
+ * @throws {ValidationError} When `throwOnValidationError: true` and validation fails
  *
  * @example
  * import { z } from "zod";
  * import { $fetch } from "@zap-studio/fetch";
  *
- * const UserSchema = z.object({
- *   id: z.number(),
- *   name: z.string(),
- *   email: z.string().email(),
- * });
+ * 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);
  *
- * async function getUser(userId: number) {
- *   const user = await $fetch(
- *     `https://api.example.com/users/${userId}`,
- *     UserSchema,
- *     { method: "GET" }
- *   );
- *   return user; // user is typed as { id: number; name: string; email: string; }
+ * // 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<TResponse, TBody = unknown, TResponseType extends ResponseType = "json">(resource: string, responseSchema: z.ZodType<TResponse>, config?: FetchConfig<TBody> & {
-  throwOnValidationError?: boolean;
-  responseType?: TResponseType;
-}): Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
-declare const safeFetch: typeof $fetch;
+declare function $fetch<TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: ExtendedRequestInit): Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+declare function $fetch(resource: string, options?: ExtendedRequestInit): Promise<Response>;
 /**
- * Convenience methods for common HTTP verbs
+ * Convenience methods for common HTTP verbs.
+ *
+ * These methods always require a schema for validation.
+ * For raw responses without validation, use `$fetch` directly.
  *
  * @example
  * import { z } from "zod";
@@ -44,17 +58,45 @@ declare const safeFetch: typeof $fetch;
  * });
  *
  * async function fetchPost(postId: number) {
- *  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+ *   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: {
-  get: <TResponse>(resource: string, schema: z.ZodType<TResponse>, options?: Omit<RequestInit, "method" | "body">) => Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
-  post: <TResponse, TBody = unknown>(resource: string, schema: z.ZodType<TResponse>, body?: TBody, options?: Omit<RequestInit, "method" | "body">) => Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
-  put: <TResponse, TBody = unknown>(resource: string, schema: z.ZodType<TResponse>, body?: TBody, options?: Omit<RequestInit, "method" | "body">) => Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
-  patch: <TResponse, TBody = unknown>(resource: string, schema: z.ZodType<TResponse>, body?: TBody, options?: Omit<RequestInit, "method" | "body">) => Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
-  delete: <TResponse>(resource: string, schema: z.ZodType<TResponse>, options?: Omit<RequestInit, "method" | "body">) => Promise<TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>>;
+  get: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  post: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  put: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  patch: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  delete: <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: Omit<ExtendedRequestInit, "method">) => Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+};
+/**
+ * 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.
+ *
+ * @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", body: { name: "John" } });
+ */
+declare function createFetch(factoryOptions?: CreateFetchOptions): {
+  $fetch: typeof $fetch;
+  api: typeof api;
 };
 //#endregion
-export { $fetch, api, safeFetch };
+export { $fetch, api, createFetch };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;AA+CA;AAoBA;;;;;AAIkD,iBAvE5B,MAuE4B,CAAA,SAAA,EAAA,QAAA,OAAA,EAAA,sBApE1B,YAoE0B,GAAA,MAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,cAAA,EAjEhC,CAAA,CAAE,OAiE8B,CAjEtB,SAiEsB,CAAA,EAAA,MAAA,CAAA,EAhEvC,WAgEuC,CAhE3B,KAgE2B,CAAA,GAAA;EAAA,sBAAA,CAAA,EAAA,OAAA;EAAA,YAAA,CAAA,EA9D/B,aA8D+B;CAAA,CAAA,EA5D/C,OA4D+C,CA3DhD,SA2DgD,GA3DpC,CAAA,CAAE,mBA2DkC,CA3Dd,SA2Dc,CAAA,GA3DD,CAAA,CAAE,iBA2DD,CA3DmB,SA2DnB,CAAA,CAAA;AAAA,cAxBrC,SAwBqC,EAAA,OAxB5B,MAwB4B;;;;;;;;;;;;;;;;;;;AAcA,cAlBrC,GAkBqC,EAAA;EAAA,GAAA,EAAA,CAAA,SAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAftC,CAAA,CAAE,OAeoC,CAf5B,SAe4B,CAAA,EAAA,OAAA,CAAA,EAdpC,IAcoC,CAd/B,WAc+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAdA,OAcA,CAdA,SAcA,GAdA,CAAA,CAAA,mBAcA,CAdA,SAcA,CAAA,GAdA,CAAA,CAAA,iBAcA,CAdA,SAcA,CAAA,CAAA;EAAA,IAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EATtC,CAAA,CAAE,OASoC,CAT5B,SAS4B,CAAA,EAAA,IAAA,CAAA,EARvC,KAQuC,EAAA,OAAA,CAAA,EAPpC,IAOoC,CAP/B,WAO+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAPA,OAOA,CAPA,SAOA,GAPA,CAAA,CAAA,mBAOA,CAPA,SAOA,CAAA,GAPA,CAAA,CAAA,iBAOA,CAPA,SAOA,CAAA,CAAA;EAAA,GAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAFtC,CAAA,CAAE,OAEoC,CAF5B,SAE4B,CAAA,EAAA,IAAA,CAAA,EADvC,KACuC,EAAA,OAAA,CAAA,EAApC,IAAoC,CAA/B,WAA+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAAA,OAAA,CAAA,SAAA,GAAA,CAAA,CAAA,mBAAA,CAAA,SAAA,CAAA,GAAA,CAAA,CAAA,iBAAA,CAAA,SAAA,CAAA,CAAA;EAAA,KAAA,EAAA,CAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAKtC,CAAA,CAAE,OALoC,CAK5B,SAL4B,CAAA,EAAA,IAAA,CAAA,EAMvC,KANuC,EAAA,OAAA,CAAA,EAOpC,IAPoC,CAO/B,WAP+B,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAOA,OAPA,CAOA,SAPA,GAOA,CAAA,CAAA,mBAPA,CAOA,SAPA,CAAA,GAOA,CAAA,CAAA,iBAPA,CAOA,SAPA,CAAA,CAAA;EAK5B,MAAA,EAAA,CAAA,SAAA,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAOV,CAAA,CAAE,OAPQ,CAOA,SAPA,CAAA,EAAA,OAAA,CAAA,EAQR,IARQ,CAQH,WARG,EAAA,QAAA,GAAA,MAAA,CAAA,EAAA,GAQ4B,OAR5B,CAQ4B,SAR5B,GAQ4B,CAAA,CAAA,mBAR5B,CAQ4B,SAR5B,CAAA,GAQ4B,CAAA,CAAA,iBAR5B,CAQ4B,SAR5B,CAAA,CAAA;CAAV"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AA8CA;;;;;;;;;;;AASA;;;;;AAsCA;;;;;;;;;;;;;;;;;;iBA/CsB,uBAAuB,4CAEnC,mBACE,sBACT,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;iBAGnC,MAAA,6BAEV,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAmCE;;;;;;;;;;;AAgCb;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,kBAA4B;iBAC3B;cACH"}

package/dist/index.mjs

@@ -1,44 +1,102 @@
-import { t as FetchError } from "./errors-BCMOymYz.mjs";
-import { n as prepareHeadersAndBody, t as parseResponse } from "./utils-CZ-1Z2-1.mjs";
+import { t as FetchError } from "./errors-DKxnbFHZ.mjs";
+import { n as standardValidate, t as isStandardSchema } from "./validator-BGjWrM4d.mjs";
 
-//#region src/index.ts
+//#region src/internal/constants.ts
+/**
+* Default options for the global $fetch
+*/
+const GLOBAL_DEFAULTS = {
+	baseURL: "",
+	headers: void 0,
+	throwOnFetchError: true,
+	throwOnValidationError: true
+};
+
+//#endregion
+//#region src/internal/utils.ts
 /**
-* Type-safe fetch wrapper with Zod validation
+* Merges two HeadersInit objects, with the second one taking precedence
 *
 * @example
-* import { z } from "zod";
-* import { $fetch } from "@zap-studio/fetch";
+* const baseHeaders = { "Authorization": "Bearer token", "Content-Type": "application/json" };
+* const overrideHeaders = { "Content-Type": "application/xml", "X-Custom-Header": "value" };
 *
-* const UserSchema = z.object({
-*   id: z.number(),
-*   name: z.string(),
-*   email: z.string().email(),
-* });
+* const merged = mergeHeaders(baseHeaders, overrideHeaders);
 *
-* async function getUser(userId: number) {
-*   const user = await $fetch(
-*     `https://api.example.com/users/${userId}`,
-*     UserSchema,
-*     { method: "GET" }
-*   );
-*   return user; // user is typed as { id: number; name: string; email: string; }
-* }
+* // Resulting headers:
+* // {
+* //   "Authorization": "Bearer token",
+* //   "Content-Type": "application/xml",
+* //   "X-Custom-Header": "value"
+* // }
 */
-async function $fetch(resource, responseSchema, config) {
-	const { body, headers, throwOnValidationError = true, responseType = "json", ...rest } = config || {};
-	const { body: preparedBody, headers: preparedHeaders } = prepareHeadersAndBody(body, headers);
-	const response = await fetch(resource, {
+function mergeHeaders(base, override) {
+	if (!(base || override)) return;
+	const merged = new Headers(base);
+	if (override) {
+		const overrideHeaders = new Headers(override);
+		for (const [key, value] of overrideHeaders.entries()) merged.set(key, value);
+	}
+	return merged;
+}
+const TRAILING_SLASHES = /\/+$/;
+const LEADING_SLASHES = /^\/+/;
+const ABSOLUTE_URL_PATTERN = /^(https?:)?\/\//i;
+/**
+* Checks if a URL is absolute (starts with http://, https://, or //)
+*/
+function isAbsoluteURL(url) {
+	return ABSOLUTE_URL_PATTERN.test(url);
+}
+/**
+* Internal fetch implementation used by both $fetch and createFetch
+*/
+async function fetchInternal(resource, schema, options, defaults) {
+	const { throwOnValidationError = defaults.throwOnValidationError, throwOnFetchError = defaults.throwOnFetchError, headers: requestHeaders, ...rest } = options || {};
+	const mergedHeaders = mergeHeaders(defaults.headers, requestHeaders);
+	const init = {
 		...rest,
-		body: preparedBody,
-		headers: preparedHeaders
+		headers: mergedHeaders
+	};
+	if (schema && init.body) {
+		init.body = JSON.stringify(init.body);
+		const existingHeaders = new Headers(init.headers);
+		if (!existingHeaders.has("Content-Type")) existingHeaders.set("Content-Type", "application/json");
+		init.headers = existingHeaders;
+	}
+	let url;
+	if (isAbsoluteURL(resource)) url = resource;
+	else {
+		const base = defaults.baseURL.replace(TRAILING_SLASHES, "");
+		const path = resource.replace(LEADING_SLASHES, "");
+		url = base ? `${base}/${path}` : resource;
+	}
+	const response = await fetch(url, init);
+	if (throwOnFetchError && !response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);
+	if (schema) return standardValidate(schema, await response.json(), throwOnValidationError);
+	return response;
+}
+/**
+* Creates an HTTP method helper bound to a fetch function
+*/
+function createMethod(fetchFn, method) {
+	return (resource, schema, options) => fetchFn(resource, schema, {
+		...options,
+		method
 	});
-	if (!response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response.status, response.statusText, response);
-	const data = await parseResponse(response, responseType);
-	return throwOnValidationError ? responseSchema.parse(data) : responseSchema.safeParse(data);
 }
-const safeFetch = $fetch;
+
+//#endregion
+//#region src/index.ts
+async function $fetch(resource, schemaOrOptions, optionsOrUndefined) {
+	const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+	return await fetchInternal(resource, schema, options, GLOBAL_DEFAULTS);
+}
 /**
-* Convenience methods for common HTTP verbs
+* Convenience methods for common HTTP verbs.
+*
+* These methods always require a schema for validation.
+* For raw responses without validation, use `$fetch` directly.
 *
 * @example
 * import { z } from "zod";
@@ -51,36 +109,64 @@ const safeFetch = $fetch;
 * });
 *
 * async function fetchPost(postId: number) {
-*  const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+*   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 = {
-	get: (resource, schema, options) => $fetch(resource, schema, {
-		...options,
-		method: "GET"
-	}),
-	post: (resource, schema, body, options) => $fetch(resource, schema, {
-		...options,
-		method: "POST",
-		body
-	}),
-	put: (resource, schema, body, options) => $fetch(resource, schema, {
-		...options,
-		method: "PUT",
-		body
-	}),
-	patch: (resource, schema, body, options) => $fetch(resource, schema, {
-		...options,
-		method: "PATCH",
-		body
-	}),
-	delete: (resource, schema, options) => $fetch(resource, schema, {
-		...options,
-		method: "DELETE"
-	})
+	get: createMethod($fetch, "GET"),
+	post: createMethod($fetch, "POST"),
+	put: createMethod($fetch, "PUT"),
+	patch: createMethod($fetch, "PATCH"),
+	delete: createMethod($fetch, "DELETE")
 };
+/**
+* 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.
+*
+* @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", body: { name: "John" } });
+*/
+function createFetch(factoryOptions = {}) {
+	const defaults = {
+		baseURL: factoryOptions.baseURL ?? "",
+		headers: factoryOptions.headers,
+		throwOnFetchError: factoryOptions.throwOnFetchError ?? true,
+		throwOnValidationError: factoryOptions.throwOnValidationError ?? true
+	};
+	async function customFetch(resource, schemaOrOptions, optionsOrUndefined) {
+		const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
+		return await fetchInternal(resource, schema, options, defaults);
+	}
+	return {
+		$fetch: customFetch,
+		api: {
+			get: createMethod(customFetch, "GET"),
+			post: createMethod(customFetch, "POST"),
+			put: createMethod(customFetch, "PUT"),
+			patch: createMethod(customFetch, "PATCH"),
+			delete: createMethod(customFetch, "DELETE")
+		}
+	};
+}
 
 //#endregion
-export { $fetch, api, safeFetch };
+export { $fetch, api, createFetch };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport { FetchError } from \"./errors\";\nimport type { FetchConfig, ResponseType } from \"./types\";\nimport { parseResponse, prepareHeadersAndBody } from \"./utils\";\n\n/**\n * Type-safe fetch wrapper with Zod validation\n *\n * @example\n * import { z } from \"zod\";\n * import { $fetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({\n *   id: z.number(),\n *   name: z.string(),\n *   email: z.string().email(),\n * });\n *\n * async function getUser(userId: number) {\n *   const user = await $fetch(\n *     `https://api.example.com/users/${userId}`,\n *     UserSchema,\n *     { method: \"GET\" }\n *   );\n *   return user; // user is typed as { id: number; name: string; email: string; }\n * }\n */\nexport async function $fetch<\n  TResponse,\n  TBody = unknown,\n  TResponseType extends ResponseType = \"json\",\n>(\n  resource: string,\n  responseSchema: z.ZodType<TResponse>,\n  config?: FetchConfig<TBody> & {\n    throwOnValidationError?: boolean;\n    responseType?: TResponseType;\n  }\n): Promise<\n  TResponse | z.ZodSafeParseSuccess<TResponse> | z.ZodSafeParseError<TResponse>\n> {\n  const {\n    body,\n    headers,\n    throwOnValidationError = true,\n    responseType = \"json\" as TResponseType,\n    ...rest\n  } = config || {};\n\n  const { body: preparedBody, headers: preparedHeaders } =\n    prepareHeadersAndBody(body, headers);\n\n  const response = await fetch(resource, {\n    ...rest,\n    body: preparedBody,\n    headers: preparedHeaders,\n  });\n\n  if (!response.ok) {\n    throw new FetchError(\n      `HTTP ${response.status}: ${response.statusText}`,\n      response.status,\n      response.statusText,\n      response\n    );\n  }\n\n  const data = await parseResponse(response, responseType);\n\n  return throwOnValidationError\n    ? responseSchema.parse(data)\n    : responseSchema.safeParse(data);\n}\n\nexport const safeFetch = $fetch;\n\n/**\n * Convenience methods for common HTTP verbs\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 = {\n  get: <TResponse>(\n    resource: string,\n    schema: z.ZodType<TResponse>,\n    options?: Omit<RequestInit, \"method\" | \"body\">\n  ) => $fetch(resource, schema, { ...options, method: \"GET\" }),\n\n  post: <TResponse, TBody = unknown>(\n    resource: string,\n    schema: z.ZodType<TResponse>,\n    body?: TBody,\n    options?: Omit<RequestInit, \"method\" | \"body\">\n  ) => $fetch(resource, schema, { ...options, method: \"POST\", body }),\n\n  put: <TResponse, TBody = unknown>(\n    resource: string,\n    schema: z.ZodType<TResponse>,\n    body?: TBody,\n    options?: Omit<RequestInit, \"method\" | \"body\">\n  ) => $fetch(resource, schema, { ...options, method: \"PUT\", body }),\n\n  patch: <TResponse, TBody = unknown>(\n    resource: string,\n    schema: z.ZodType<TResponse>,\n    body?: TBody,\n    options?: Omit<RequestInit, \"method\" | \"body\">\n  ) => $fetch(resource, schema, { ...options, method: \"PATCH\", body }),\n\n  delete: <TResponse>(\n    resource: string,\n    schema: z.ZodType<TResponse>,\n    options?: Omit<RequestInit, \"method\" | \"body\">\n  ) => $fetch(resource, schema, { ...options, method: \"DELETE\" }),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,eAAsB,OAKpB,UACA,gBACA,QAMA;CACA,MAAM,EACJ,MACA,SACA,yBAAyB,MACzB,eAAe,QACf,GAAG,SACD,UAAU,EAAE;CAEhB,MAAM,EAAE,MAAM,cAAc,SAAS,oBACnC,sBAAsB,MAAM,QAAQ;CAEtC,MAAM,WAAW,MAAM,MAAM,UAAU;EACrC,GAAG;EACH,MAAM;EACN,SAAS;EACV,CAAC;AAEF,KAAI,CAAC,SAAS,GACZ,OAAM,IAAI,WACR,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,SAAS,QACT,SAAS,YACT,SACD;CAGH,MAAM,OAAO,MAAM,cAAc,UAAU,aAAa;AAExD,QAAO,yBACH,eAAe,MAAM,KAAK,GAC1B,eAAe,UAAU,KAAK;;AAGpC,MAAa,YAAY;;;;;;;;;;;;;;;;;;;AAoBzB,MAAa,MAAM;CACjB,MACE,UACA,QACA,YACG,OAAO,UAAU,QAAQ;EAAE,GAAG;EAAS,QAAQ;EAAO,CAAC;CAE5D,OACE,UACA,QACA,MACA,YACG,OAAO,UAAU,QAAQ;EAAE,GAAG;EAAS,QAAQ;EAAQ;EAAM,CAAC;CAEnE,MACE,UACA,QACA,MACA,YACG,OAAO,UAAU,QAAQ;EAAE,GAAG;EAAS,QAAQ;EAAO;EAAM,CAAC;CAElE,QACE,UACA,QACA,MACA,YACG,OAAO,UAAU,QAAQ;EAAE,GAAG;EAAS,QAAQ;EAAS;EAAM,CAAC;CAEpE,SACE,UACA,QACA,YACG,OAAO,UAAU,QAAQ;EAAE,GAAG;EAAS,QAAQ;EAAU,CAAC;CAChE"}
+{"version":3,"file":"index.mjs","names":["url: string","defaults: FetchDefaults"],"sources":["../src/internal/constants.ts","../src/internal/utils.ts","../src/index.ts"],"sourcesContent":["import type { FetchDefaults } from \"../types\";\n\n/**\n * Default options for the global $fetch\n */\nexport const GLOBAL_DEFAULTS = {\n  baseURL: \"\",\n  headers: undefined,\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n} as const satisfies FetchDefaults;\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { $fetch } from \"..\";\nimport { FetchError } from \"../errors\";\nimport type { ExtendedRequestInit, FetchDefaults } from \"../types\";\nimport { standardValidate } from \"../validator\";\n\n/**\n * Merges two HeadersInit objects, with the second one taking precedence\n *\n * @example\n * const baseHeaders = { \"Authorization\": \"Bearer token\", \"Content-Type\": \"application/json\" };\n * const overrideHeaders = { \"Content-Type\": \"application/xml\", \"X-Custom-Header\": \"value\" };\n *\n * const merged = mergeHeaders(baseHeaders, overrideHeaders);\n *\n * // Resulting headers:\n * // {\n * //   \"Authorization\": \"Bearer token\",\n * //   \"Content-Type\": \"application/xml\",\n * //   \"X-Custom-Header\": \"value\"\n * // }\n */\nexport function mergeHeaders(\n  base: HeadersInit | undefined,\n  override: HeadersInit | undefined\n): Headers | undefined {\n  if (!(base || override)) {\n    return;\n  }\n\n  const merged = new Headers(base);\n  if (override) {\n    const overrideHeaders = new Headers(override);\n    for (const [key, value] of overrideHeaders.entries()) {\n      merged.set(key, value);\n    }\n  }\n  return merged;\n}\n\nconst TRAILING_SLASHES = /\\/+$/;\nconst LEADING_SLASHES = /^\\/+/;\nconst ABSOLUTE_URL_PATTERN = /^(https?:)?\\/\\//i;\n\n/**\n * Checks if a URL is absolute (starts with http://, https://, or //)\n */\nfunction isAbsoluteURL(url: string): boolean {\n  return ABSOLUTE_URL_PATTERN.test(url);\n}\n\n/**\n * Internal fetch implementation used by both $fetch and createFetch\n */\nexport async function fetchInternal(\n  resource: string,\n  schema: StandardSchemaV1 | undefined,\n  options: ExtendedRequestInit | undefined,\n  defaults: FetchDefaults\n): Promise<unknown> {\n  const {\n    throwOnValidationError = defaults.throwOnValidationError,\n    throwOnFetchError = defaults.throwOnFetchError,\n    headers: requestHeaders,\n    ...rest\n  } = options || {};\n\n  const mergedHeaders = mergeHeaders(defaults.headers, requestHeaders);\n  const init = { ...rest, headers: mergedHeaders } as RequestInit;\n\n  // Auto-stringify body and set default Content-Type if we have a schema\n  if (schema && init.body) {\n    init.body = JSON.stringify(init.body);\n\n    const existingHeaders = new Headers(init.headers);\n    if (!existingHeaders.has(\"Content-Type\")) {\n      existingHeaders.set(\"Content-Type\", \"application/json\");\n    }\n\n    init.headers = existingHeaders;\n  }\n\n  // For absolute URLs, ignore baseURL entirely\n  let url: string;\n  if (isAbsoluteURL(resource)) {\n    url = resource;\n  } else {\n    // Normalize URL by avoiding double slashes between baseURL and resource\n    const base = defaults.baseURL.replace(TRAILING_SLASHES, \"\");\n    const path = resource.replace(LEADING_SLASHES, \"\");\n    url = base ? `${base}/${path}` : resource;\n  }\n\n  const response = 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  // For json with schema, validate\n  if (schema) {\n    const raw = await response.json();\n    return standardValidate(schema, raw, throwOnValidationError);\n  }\n\n  // No validation, return raw response data\n  return response;\n}\n\n/**\n * Creates an HTTP method helper bound to a fetch function\n */\nexport function createMethod<TFetch extends typeof $fetch>(\n  fetchFn: TFetch,\n  method: string\n) {\n  return <TSchema extends StandardSchemaV1>(\n    resource: string,\n    schema: TSchema,\n    options?: Omit<ExtendedRequestInit, \"method\">\n  ) => fetchFn(resource, schema, { ...options, method });\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { GLOBAL_DEFAULTS } from \"./internal/constants\";\nimport { createMethod, fetchInternal } from \"./internal/utils\";\nimport type {\n  CreateFetchOptions,\n  ExtendedRequestInit,\n  FetchDefaults,\n} from \"./types\";\nimport { isStandardSchema } from \"./validator\";\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: true` and response is not ok\n * @throws {ValidationError} When `throwOnValidationError: true` and validation fails\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  resource: string,\n  schema: TSchema,\n  options?: ExtendedRequestInit\n): Promise<\n  | StandardSchemaV1.InferOutput<TSchema>\n  | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n>;\n\nexport async function $fetch(\n  resource: string,\n  options?: ExtendedRequestInit\n): Promise<Response>;\n\nexport async function $fetch(\n  resource: string,\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(resource, 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 * @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 = {\n  get: createMethod($fetch, \"GET\"),\n  post: createMethod($fetch, \"POST\"),\n  put: createMethod($fetch, \"PUT\"),\n  patch: createMethod($fetch, \"PATCH\"),\n  delete: createMethod($fetch, \"DELETE\"),\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 * @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\", body: { name: \"John\" } });\n */\nexport function createFetch(factoryOptions: CreateFetchOptions = {}): {\n  $fetch: typeof $fetch;\n  api: typeof api;\n} {\n  const defaults: FetchDefaults = {\n    baseURL: factoryOptions.baseURL ?? \"\",\n    headers: factoryOptions.headers,\n    throwOnFetchError: factoryOptions.throwOnFetchError ?? true,\n    throwOnValidationError: factoryOptions.throwOnValidationError ?? true,\n  };\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    resource: string,\n    schema: TSchema,\n    options?: ExtendedRequestInit\n  ): Promise<\n    | StandardSchemaV1.InferOutput<TSchema>\n    | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n  >;\n\n  async function customFetch(\n    resource: string,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  async function customFetch(\n    resource: string,\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(resource, schema, options, defaults);\n  }\n\n  const customApi = {\n    get: createMethod(customFetch, \"GET\"),\n    post: createMethod(customFetch, \"POST\"),\n    put: createMethod(customFetch, \"PUT\"),\n    patch: createMethod(customFetch, \"PATCH\"),\n    delete: createMethod(customFetch, \"DELETE\"),\n  };\n\n  return {\n    $fetch: customFetch,\n    api: customApi,\n  };\n}\n"],"mappings":";;;;;;;AAKA,MAAa,kBAAkB;CAC7B,SAAS;CACT,SAAS;CACT,mBAAmB;CACnB,wBAAwB;CACzB;;;;;;;;;;;;;;;;;;;;ACYD,SAAgB,aACd,MACA,UACqB;AACrB,KAAI,EAAE,QAAQ,UACZ;CAGF,MAAM,SAAS,IAAI,QAAQ,KAAK;AAChC,KAAI,UAAU;EACZ,MAAM,kBAAkB,IAAI,QAAQ,SAAS;AAC7C,OAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB,SAAS,CAClD,QAAO,IAAI,KAAK,MAAM;;AAG1B,QAAO;;AAGT,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;;;;AAK7B,SAAS,cAAc,KAAsB;AAC3C,QAAO,qBAAqB,KAAK,IAAI;;;;;AAMvC,eAAsB,cACpB,UACA,QACA,SACA,UACkB;CAClB,MAAM,EACJ,yBAAyB,SAAS,wBAClC,oBAAoB,SAAS,mBAC7B,SAAS,gBACT,GAAG,SACD,WAAW,EAAE;CAEjB,MAAM,gBAAgB,aAAa,SAAS,SAAS,eAAe;CACpE,MAAM,OAAO;EAAE,GAAG;EAAM,SAAS;EAAe;AAGhD,KAAI,UAAU,KAAK,MAAM;AACvB,OAAK,OAAO,KAAK,UAAU,KAAK,KAAK;EAErC,MAAM,kBAAkB,IAAI,QAAQ,KAAK,QAAQ;AACjD,MAAI,CAAC,gBAAgB,IAAI,eAAe,CACtC,iBAAgB,IAAI,gBAAgB,mBAAmB;AAGzD,OAAK,UAAU;;CAIjB,IAAIA;AACJ,KAAI,cAAc,SAAS,CACzB,OAAM;MACD;EAEL,MAAM,OAAO,SAAS,QAAQ,QAAQ,kBAAkB,GAAG;EAC3D,MAAM,OAAO,SAAS,QAAQ,iBAAiB,GAAG;AAClD,QAAM,OAAO,GAAG,KAAK,GAAG,SAAS;;CAGnC,MAAM,WAAW,MAAM,MAAM,KAAK,KAAK;AAEvC,KAAI,qBAAqB,CAAC,SAAS,GACjC,OAAM,IAAI,WACR,QAAQ,SAAS,OAAO,IAAI,SAAS,cACrC,SACD;AAIH,KAAI,OAEF,QAAO,iBAAiB,QADZ,MAAM,SAAS,MAAM,EACI,uBAAuB;AAI9D,QAAO;;;;;AAMT,SAAgB,aACd,SACA,QACA;AACA,SACE,UACA,QACA,YACG,QAAQ,UAAU,QAAQ;EAAE,GAAG;EAAS;EAAQ,CAAC;;;;;AC/DxD,eAAsB,OACpB,UACA,iBACA,oBACkB;CAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,QAAW,gBAAgB;AAEhC,QAAO,MAAM,cAAc,UAAU,QAAQ,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;AAwBxE,MAAa,MAAM;CACjB,KAAK,aAAa,QAAQ,MAAM;CAChC,MAAM,aAAa,QAAQ,OAAO;CAClC,KAAK,aAAa,QAAQ,MAAM;CAChC,OAAO,aAAa,QAAQ,QAAQ;CACpC,QAAQ,aAAa,QAAQ,SAAS;CACvC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,SAAgB,YAAY,iBAAqC,EAAE,EAGjE;CACA,MAAMC,WAA0B;EAC9B,SAAS,eAAe,WAAW;EACnC,SAAS,eAAe;EACxB,mBAAmB,eAAe,qBAAqB;EACvD,wBAAwB,eAAe,0BAA0B;EAClE;CAgBD,eAAe,YACb,UACA,iBACA,oBACkB;EAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,QAAW,gBAAgB;AAEhC,SAAO,MAAM,cAAc,UAAU,QAAQ,SAAS,SAAS;;AAWjE,QAAO;EACL,QAAQ;EACR,KAVgB;GAChB,KAAK,aAAa,aAAa,MAAM;GACrC,MAAM,aAAa,aAAa,OAAO;GACvC,KAAK,aAAa,aAAa,MAAM;GACrC,OAAO,aAAa,aAAa,QAAQ;GACzC,QAAQ,aAAa,aAAa,SAAS;GAC5C;EAKA"}

package/dist/types-C0Uhh2KM.d.mts

@@ -0,0 +1,52 @@
+//#region src/types.d.ts
+/**
+ * Extended RequestInit type to include custom fetch options
+ */
+type ExtendedRequestInit = Omit<RequestInit, "body"> & {
+  /**
+   * Request body - can be a BodyInit value or an object that will be JSON-stringified
+   */
+  body?: BodyInit | Record<string, unknown>;
+  /**
+   * 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;
+};
+/**
+ * Internal defaults used by fetchInternal
+ */
+type FetchDefaults = {
+  /**
+   * Base URL to prepend to all requests
+   * @default ""
+   */
+  baseURL: string;
+  /**
+   * Default headers to include in all requests
+   * @default undefined
+   */
+  headers: HeadersInit | undefined;
+  /**
+   * 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;
+};
+/**
+ * Options for creating a custom fetch instance with `createFetch`
+ */
+type CreateFetchOptions = Partial<FetchDefaults>;
+//#endregion
+export { ExtendedRequestInit as n, FetchDefaults as r, CreateFetchOptions as t };
+//# sourceMappingURL=types-C0Uhh2KM.d.mts.map

package/dist/types-C0Uhh2KM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-C0Uhh2KM.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAGA;;AAAkC,KAAtB,mBAAA,GAAsB,IAAA,CAAK,WAAL,EAAA,MAAA,CAAA,GAAA;EAIzB;;;EAgBG,IAAA,CAAA,EAhBH,QAgBG,GAhBQ,MAgBK,CAAA,MAUd,EAAA,OAAW,CAAA;EAgBV;;;;;;;;;;;;;;KA1BA,aAAA;;;;;;;;;;WAUD;;;;;;;;;;;;;;;KAgBC,kBAAA,GAAqB,QAAQ"}

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { n as ExtendedRequestInit, r as FetchDefaults, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
+export { CreateFetchOptions, ExtendedRequestInit, FetchDefaults };

package/dist/validator-BGjWrM4d.mjs

@@ -0,0 +1,44 @@
+import { n as ValidationError } from "./errors-DKxnbFHZ.mjs";
+
+//#region src/validator.ts
+/**
+* Type guard to check if a value is a Standard Schema schema
+*/
+function isStandardSchema(value) {
+	return !!value && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+}
+/**
+* Helper function to validate data using Standard Schema
+*
+* @throws {ValidationError} When `throwOnError` is true and validation fails
+*
+* @example
+* import { standardValidate } from "@zap-studio/fetch/validator";
+* import { z } from "zod";
+*
+* const UserSchema = z.object({ id: z.number(), name: z.string() });
+*
+* // Basic usage
+* const user = await standardValidate(UserSchema, data);
+*
+* // Non-throwing usage
+* const result = await standardValidate(UserSchema, data, false);
+* if (result.issues) {
+*   console.error("Validation failed:", result.issues);
+* } else {
+*   console.log("Success:", result.value);
+* }
+*/
+async function standardValidate(schema, input, throwOnError) {
+	let result = schema["~standard"].validate(input);
+	if (result instanceof Promise) result = await result;
+	if (result.issues) {
+		if (throwOnError) throw new ValidationError([...result.issues]);
+		return result;
+	}
+	return throwOnError ? result.value : result;
+}
+
+//#endregion
+export { standardValidate as n, isStandardSchema as t };
+//# sourceMappingURL=validator-BGjWrM4d.mjs.map

package/dist/validator-BGjWrM4d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator-BGjWrM4d.mjs","names":[],"sources":["../src/validator.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { ValidationError } from \"./errors\";\n\n/**\n * Type guard to check if a value is a Standard Schema schema\n */\nexport function isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  return (\n    !!value &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    \"~standard\" in value\n  );\n}\n\n/**\n * Helper function to validate data using Standard Schema\n *\n * @throws {ValidationError} When `throwOnError` is true and validation fails\n *\n * @example\n * import { standardValidate } from \"@zap-studio/fetch/validator\";\n * import { z } from \"zod\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage\n * const user = await standardValidate(UserSchema, data);\n *\n * // Non-throwing usage\n * const result = await standardValidate(UserSchema, data, false);\n * if (result.issues) {\n *   console.error(\"Validation failed:\", result.issues);\n * } else {\n *   console.log(\"Success:\", result.value);\n * }\n */\nexport async function standardValidate<TSchema extends StandardSchemaV1>(\n  schema: TSchema,\n  input: unknown,\n  throwOnError: boolean\n): Promise<\n  | StandardSchemaV1.InferOutput<TSchema>\n  | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>\n> {\n  let result = schema[\"~standard\"].validate(input);\n  if (result instanceof Promise) {\n    result = await result;\n  }\n\n  if (result.issues) {\n    if (throwOnError) {\n      throw new ValidationError([...result.issues]);\n    }\n    return result;\n  }\n\n  return throwOnError ? result.value : result;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,iBAAiB,OAA2C;AAC1E,QACE,CAAC,CAAC,UACD,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;AA0BnB,eAAsB,iBACpB,QACA,OACA,cAIA;CACA,IAAI,SAAS,OAAO,aAAa,SAAS,MAAM;AAChD,KAAI,kBAAkB,QACpB,UAAS,MAAM;AAGjB,KAAI,OAAO,QAAQ;AACjB,MAAI,aACF,OAAM,IAAI,gBAAgB,CAAC,GAAG,OAAO,OAAO,CAAC;AAE/C,SAAO;;AAGT,QAAO,eAAe,OAAO,QAAQ"}

package/dist/validator.d.mts

@@ -0,0 +1,34 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/validator.d.ts
+
+/**
+ * Type guard to check if a value is a Standard Schema schema
+ */
+declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+/**
+ * Helper function to validate data using Standard Schema
+ *
+ * @throws {ValidationError} When `throwOnError` is true and validation fails
+ *
+ * @example
+ * import { standardValidate } from "@zap-studio/fetch/validator";
+ * import { z } from "zod";
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Basic usage
+ * const user = await standardValidate(UserSchema, data);
+ *
+ * // Non-throwing usage
+ * const result = await standardValidate(UserSchema, data, false);
+ * if (result.issues) {
+ *   console.error("Validation failed:", result.issues);
+ * } else {
+ *   console.log("Success:", result.value);
+ * }
+ */
+declare function standardValidate<TSchema extends StandardSchemaV1>(schema: TSchema, input: unknown, throwOnError: boolean): Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+//#endregion
+export { isStandardSchema, standardValidate };
+//# sourceMappingURL=validator.d.mts.map

package/dist/validator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.mts","names":[],"sources":["../src/validator.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;AA8BsB,iBA9BN,gBAAA,CA8BsB,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA9BqB,gBA8BrB;;;;;;;;;;;;;;;;;;;;;;;iBAAhB,iCAAiC,0BAC7C,iDAGP,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY"}

package/dist/validator.mjs

@@ -0,0 +1,4 @@
+import "./errors-DKxnbFHZ.mjs";
+import { n as standardValidate, t as isStandardSchema } from "./validator-BGjWrM4d.mjs";
+
+export { isStandardSchema, standardValidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "type": "module",
   "private": false,
   "publishConfig": {
@@ -12,24 +12,27 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "zod": "^4.1.12"
+    "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
-    "@types/node": "latest",
-    "@vitest/coverage-v8": "^4.0.13",
-    "jsdom": "latest",
-    "tsdown": "latest",
-    "typescript": "latest",
-    "vitest": "latest",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.14",
+    "arktype": "^2.1.27",
+    "jsdom": "^27.2.0",
+    "tsdown": "^0.17.0-beta.4",
+    "typescript": "^5.9.3",
+    "valibot": "^1.2.0",
+    "vitest": "^4.0.14",
+    "zod": "^4.1.13",
+    "@zap-studio/vitest-config": "0.0.0",
     "@zap-studio/tsdown-config": "0.0.0",
-    "@zap-studio/typescript-config": "0.0.0",
-    "@zap-studio/vitest-config": "0.0.0"
+    "@zap-studio/typescript-config": "0.0.0"
   },
   "exports": {
     ".": "./dist/index.mjs",
-    "./errors": "./dist/errors/index.mjs",
-    "./types": "./dist/types/index.mjs",
-    "./utils": "./dist/utils/index.mjs",
+    "./errors": "./dist/errors.mjs",
+    "./types": "./dist/types.mjs",
+    "./validator": "./dist/validator.mjs",
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",

package/dist/errors/index.d.mts

@@ -1,10 +0,0 @@
-//#region src/errors/index.d.ts
-declare class FetchError extends Error {
-  status: number;
-  statusText: string;
-  response: Response;
-  constructor(message: string, status: number, statusText: string, response: Response);
-}
-//#endregion
-export { FetchError };
-//# sourceMappingURL=index.d.mts.map

package/dist/errors/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/errors/index.ts"],"sourcesContent":[],"mappings":";cAAa,UAAA,SAAmB,KAAA;EAAnB,MAAA,EAAA,MAAW;EAGZ,UAAA,EAAA,MAAA;EAME,QAAA,EANF,QAME;EATkB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,QAAA,EASlB,QATkB"}

package/dist/errors/index.mjs

@@ -1,3 +0,0 @@
-import { t as FetchError } from "../errors-BCMOymYz.mjs";
-
-export { FetchError };

package/dist/errors-BCMOymYz.mjs

@@ -1,17 +0,0 @@
-//#region src/errors/index.ts
-var FetchError = class extends Error {
-	status;
-	statusText;
-	response;
-	constructor(message, status, statusText, response) {
-		super(message);
-		this.name = "FetchError";
-		this.status = status;
-		this.statusText = statusText;
-		this.response = response;
-	}
-};
-
-//#endregion
-export { FetchError as t };
-//# sourceMappingURL=errors-BCMOymYz.mjs.map

package/dist/errors-BCMOymYz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-BCMOymYz.mjs","names":[],"sources":["../src/errors/index.ts"],"sourcesContent":["export class FetchError extends Error {\n  status: number;\n  statusText: string;\n  response: Response;\n\n  constructor(\n    message: string,\n    status: number,\n    statusText: string,\n    response: Response\n  ) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = status;\n    this.statusText = statusText;\n    this.response = response;\n  }\n}\n"],"mappings":";AAAA,IAAa,aAAb,cAAgC,MAAM;CACpC;CACA;CACA;CAEA,YACE,SACA,QACA,YACA,UACA;AACA,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS;AACd,OAAK,aAAa;AAClB,OAAK,WAAW"}

package/dist/index-Dz58_HD6.d.mts

@@ -1,18 +0,0 @@
-//#region src/types/index.d.ts
-type FetchConfig<TBody> = Omit<RequestInit, "body"> & {
-  body?: TBody;
-  throwOnValidationError?: boolean;
-};
-type ResponseType = "arrayBuffer" | "blob" | "bytes" | "clone" | "formData" | "json" | "text";
-type ResponseTypeMap = {
-  arrayBuffer: ArrayBuffer;
-  blob: Blob;
-  bytes: Uint8Array;
-  clone: Response;
-  formData: FormData;
-  json: unknown;
-  text: string;
-};
-//#endregion
-export { ResponseType as n, ResponseTypeMap as r, FetchConfig as t };
-//# sourceMappingURL=index-Dz58_HD6.d.mts.map

package/dist/index-Dz58_HD6.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Dz58_HD6.d.mts","names":[],"sources":["../src/types/index.ts"],"sourcesContent":[],"mappings":";KAAY,qBAAqB,KAAK;EAA1B,IAAA,CAAA,EACH,KADG;EAA0B,sBAAA,CAAA,EAAA,OAAA;CAAL;AACxB,KAIG,YAAA,GAJH,aAAA,GAAA,MAAA,GAAA,OAAA,GAAA,OAAA,GAAA,UAAA,GAAA,MAAA,GAAA,MAAA;AAAK,KAaF,eAAA,GAbE;EAIF,WAAA,EAUG,WAVS;EASZ,IAAA,EAEJ,IAFI;EACG,KAAA,EAEN,UAFM;EACP,KAAA,EAEC,QAFD;EACC,QAAA,EAEG,QAFH;EACA,IAAA,EAAA,OAAA;EACG,IAAA,EAAA,MAAA;CAAQ"}

package/dist/types/index.d.mts

@@ -1,2 +0,0 @@
-import { n as ResponseType, r as ResponseTypeMap, t as FetchConfig } from "../index-Dz58_HD6.mjs";
-export { FetchConfig, ResponseType, ResponseTypeMap };

package/dist/utils/index.d.mts

@@ -1,11 +0,0 @@
-import { n as ResponseType, r as ResponseTypeMap } from "../index-Dz58_HD6.mjs";
-
-//#region src/utils/index.d.ts
-declare function parseResponse<TResponseType extends ResponseType>(response: Response, responseType: TResponseType): Promise<ResponseTypeMap[TResponseType]>;
-declare function prepareHeadersAndBody<TBody = unknown>(body: TBody, headers: HeadersInit | undefined): {
-  body: BodyInit | null;
-  headers: HeadersInit | undefined;
-};
-//#endregion
-export { parseResponse, prepareHeadersAndBody };
-//# sourceMappingURL=index.d.mts.map

package/dist/utils/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":[],"mappings":";;;iBAGgB,oCAAoC,wBACxC,wBACI,gBACb,QAAQ,gBAAgB;iBAmEX,6CACR,gBACG;EAxEK,IAAA,EAyEL,QAzEK,GAAa,IAAA;EAAuB,OAAA,EAyEf,WAzEe,GAAA,SAAA;CACxC"}

package/dist/utils/index.mjs

@@ -1,4 +0,0 @@
-import "../errors-BCMOymYz.mjs";
-import { n as prepareHeadersAndBody, t as parseResponse } from "../utils-CZ-1Z2-1.mjs";
-
-export { parseResponse, prepareHeadersAndBody };

package/dist/utils-CZ-1Z2-1.mjs

@@ -1,53 +0,0 @@
-import { t as FetchError } from "./errors-BCMOymYz.mjs";
-
-//#region src/utils/index.ts
-function parseResponse(response, responseType) {
-	const contentType = response.headers.get("content-type");
-	const parser = {
-		json: async () => {
-			if (!contentType?.includes("application/json")) throw new FetchError(contentType ? `Expected JSON response but received content type: ${contentType}` : "Expected JSON response but received no content type", response.status, response.statusText, response);
-			return await response.json();
-		},
-		arrayBuffer: async () => response.arrayBuffer(),
-		blob: async () => response.blob(),
-		bytes: async () => {
-			const buffer = await response.arrayBuffer();
-			return new Uint8Array(buffer);
-		},
-		clone: async () => response.clone(),
-		formData: async () => {
-			if (!contentType?.includes("multipart/form-data")) throw new FetchError("Expected FormData response but received different content type", response.status, response.statusText, response);
-			return await response.formData();
-		},
-		text: async () => {
-			if (!contentType?.includes("text/")) throw new FetchError("Expected text response but received different content type", response.status, response.statusText, response);
-			return await response.text();
-		}
-	}[responseType];
-	if (!parser) return Promise.reject(new FetchError(`Unsupported response type: ${responseType}`, response.status, response.statusText, response));
-	return parser();
-}
-function prepareHeadersAndBody(body, headers) {
-	let preparedBody = null;
-	let preparedHeaders = headers;
-	if (body === null || body === void 0) return {
-		body: null,
-		headers: preparedHeaders
-	};
-	if (body instanceof FormData || body instanceof URLSearchParams || body instanceof Blob || body instanceof ArrayBuffer || body instanceof ReadableStream || typeof body === "string") preparedBody = body;
-	else if (typeof body === "object") {
-		preparedBody = JSON.stringify(body);
-		preparedHeaders = {
-			"Content-Type": "application/json",
-			...headers
-		};
-	} else preparedBody = String(body);
-	return {
-		body: preparedBody,
-		headers: preparedHeaders
-	};
-}
-
-//#endregion
-export { prepareHeadersAndBody as n, parseResponse as t };
-//# sourceMappingURL=utils-CZ-1Z2-1.mjs.map

package/dist/utils-CZ-1Z2-1.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils-CZ-1Z2-1.mjs","names":["preparedBody: BodyInit | null"],"sources":["../src/utils/index.ts"],"sourcesContent":["import { FetchError } from \"../errors\";\nimport type { ResponseType, ResponseTypeMap } from \"../types\";\n\nexport function parseResponse<TResponseType extends ResponseType>(\n  response: Response,\n  responseType: TResponseType\n): Promise<ResponseTypeMap[TResponseType]> {\n  const contentType = response.headers.get(\"content-type\");\n\n  const parsers: Record<\n    ResponseType,\n    () => Promise<ResponseTypeMap[ResponseType]>\n  > = {\n    json: async () => {\n      if (!contentType?.includes(\"application/json\")) {\n        const errorMessage = contentType\n          ? `Expected JSON response but received content type: ${contentType}`\n          : \"Expected JSON response but received no content type\";\n        throw new FetchError(\n          errorMessage,\n          response.status,\n          response.statusText,\n          response\n        );\n      }\n      return await response.json();\n    },\n    arrayBuffer: async () => response.arrayBuffer(),\n    blob: async () => response.blob(),\n    bytes: async () => {\n      const buffer = await response.arrayBuffer();\n      return new Uint8Array(buffer);\n    },\n    clone: async () => response.clone(),\n    formData: async () => {\n      if (!contentType?.includes(\"multipart/form-data\")) {\n        throw new FetchError(\n          \"Expected FormData response but received different content type\",\n          response.status,\n          response.statusText,\n          response\n        );\n      }\n      return await response.formData();\n    },\n    text: async () => {\n      if (!contentType?.includes(\"text/\")) {\n        throw new FetchError(\n          \"Expected text response but received different content type\",\n          response.status,\n          response.statusText,\n          response\n        );\n      }\n      return await response.text();\n    },\n  };\n\n  const parser = parsers[responseType];\n  if (!parser) {\n    return Promise.reject(\n      new FetchError(\n        `Unsupported response type: ${responseType}`,\n        response.status,\n        response.statusText,\n        response\n      )\n    ) as Promise<ResponseTypeMap[TResponseType]>;\n  }\n\n  return parser() as Promise<ResponseTypeMap[TResponseType]>;\n}\n\nexport function prepareHeadersAndBody<TBody = unknown>(\n  body: TBody,\n  headers: HeadersInit | undefined\n): { body: BodyInit | null; headers: HeadersInit | undefined } {\n  let preparedBody: BodyInit | null = null;\n  let preparedHeaders = headers;\n\n  // Handle null/undefined body\n  if (body === null || body === undefined) {\n    return { body: null, headers: preparedHeaders };\n  }\n\n  // Check if body is already a valid BodyInit type\n  if (\n    body instanceof FormData ||\n    body instanceof URLSearchParams ||\n    body instanceof Blob ||\n    body instanceof ArrayBuffer ||\n    body instanceof ReadableStream ||\n    typeof body === \"string\"\n  ) {\n    preparedBody = body as BodyInit;\n  } else if (typeof body === \"object\") {\n    // If body is a plain object, stringify it and set Content-Type\n    preparedBody = JSON.stringify(body);\n    preparedHeaders = {\n      \"Content-Type\": \"application/json\",\n      ...headers,\n    };\n  } else {\n    // Handle other primitive types by converting to string\n    preparedBody = String(body);\n  }\n\n  return { body: preparedBody, headers: preparedHeaders };\n}\n"],"mappings":";;;AAGA,SAAgB,cACd,UACA,cACyC;CACzC,MAAM,cAAc,SAAS,QAAQ,IAAI,eAAe;CAmDxD,MAAM,SA9CF;EACF,MAAM,YAAY;AAChB,OAAI,CAAC,aAAa,SAAS,mBAAmB,CAI5C,OAAM,IAAI,WAHW,cACjB,qDAAqD,gBACrD,uDAGF,SAAS,QACT,SAAS,YACT,SACD;AAEH,UAAO,MAAM,SAAS,MAAM;;EAE9B,aAAa,YAAY,SAAS,aAAa;EAC/C,MAAM,YAAY,SAAS,MAAM;EACjC,OAAO,YAAY;GACjB,MAAM,SAAS,MAAM,SAAS,aAAa;AAC3C,UAAO,IAAI,WAAW,OAAO;;EAE/B,OAAO,YAAY,SAAS,OAAO;EACnC,UAAU,YAAY;AACpB,OAAI,CAAC,aAAa,SAAS,sBAAsB,CAC/C,OAAM,IAAI,WACR,kEACA,SAAS,QACT,SAAS,YACT,SACD;AAEH,UAAO,MAAM,SAAS,UAAU;;EAElC,MAAM,YAAY;AAChB,OAAI,CAAC,aAAa,SAAS,QAAQ,CACjC,OAAM,IAAI,WACR,8DACA,SAAS,QACT,SAAS,YACT,SACD;AAEH,UAAO,MAAM,SAAS,MAAM;;EAE/B,CAEsB;AACvB,KAAI,CAAC,OACH,QAAO,QAAQ,OACb,IAAI,WACF,8BAA8B,gBAC9B,SAAS,QACT,SAAS,YACT,SACD,CACF;AAGH,QAAO,QAAQ;;AAGjB,SAAgB,sBACd,MACA,SAC6D;CAC7D,IAAIA,eAAgC;CACpC,IAAI,kBAAkB;AAGtB,KAAI,SAAS,QAAQ,SAAS,OAC5B,QAAO;EAAE,MAAM;EAAM,SAAS;EAAiB;AAIjD,KACE,gBAAgB,YAChB,gBAAgB,mBAChB,gBAAgB,QAChB,gBAAgB,eAChB,gBAAgB,kBAChB,OAAO,SAAS,SAEhB,gBAAe;UACN,OAAO,SAAS,UAAU;AAEnC,iBAAe,KAAK,UAAU,KAAK;AACnC,oBAAkB;GAChB,gBAAgB;GAChB,GAAG;GACJ;OAGD,gBAAe,OAAO,KAAK;AAG7B,QAAO;EAAE,MAAM;EAAc,SAAS;EAAiB"}