@zap-studio/fetch 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zap-studio/fetch
 
+## 0.1.2
+
+### Patch Changes
+
+- 69c2b21: Change `safeFetch` to `$fetch` syntax and make sure `safeFetch` can also be used for legacy
+
+## 0.1.1
+
+### Patch Changes
+
+- 5f1812b: Change files field in package.json to distribute only necessary artifacts
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -0,0 +1,169 @@
+# @zap-studio/fetch
+
+A type-safe fetch wrapper with Zod validation for TypeScript.
+
+## Features
+
+- 🎯 **Type-safe requests** with automatic type inference
+- 🛡️ **Runtime validation** using Zod schemas
+- 🔄 **Automatic content-type** detection and handling
+- ⚡️ **Convenient API methods** (GET, POST, PUT, PATCH, DELETE)
+- 📦 **Multiple response types** (JSON, text, blob, arrayBuffer)
+- 🚨 **Custom error handling** with FetchError class
+- 📘 **Full TypeScript support** with zero configuration
+
+## Installation
+
+```bash
+pnpm add @zap-studio/fetch
+#or
+npm install @zap-studio/fetch
+```
+
+## Quick Start
+
+```typescript
+import { z } from "zod";
+import { api } from "@zap-studio/fetch";
+
+// Define your schema
+const UserSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.email(),
+});
+
+// Make a type-safe request
+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
+```
+
+## API
+
+### `api.get(url, schema, options?)`
+
+```typescript
+const user = await api.get("/api/users/1", UserSchema);
+```
+
+### `api.post(url, schema, body?, options?)`
+
+```typescript
+const newUser = await api.post("/api/users", UserSchema, {
+  name: "John Doe",
+  email: "john@example.com",
+});
+```
+
+### `api.put(url, schema, body?, options?)`
+
+```typescript
+const updated = await api.put("/api/users/1", UserSchema, {
+  name: "Jane Doe",
+});
+```
+
+### `api.patch(url, schema, body?, options?)`
+
+```typescript
+const patched = await api.patch("/api/users/1", UserSchema, {
+  email: "newemail@example.com",
+});
+```
+
+### `api.delete(url, schema, options?)`
+
+```typescript
+const deleted = await api.delete("/api/users/1", UserSchema);
+```
+
+## Advanced Usage
+
+### Using `$fetch` directly
+
+```typescript
+import { $fetch } from "@zap-studio/fetch";
+
+const result = await $fetch(
+  "https://api.example.com/users/1",
+  UserSchema,
+  {
+    method: "GET",
+    headers: {
+      "Authorization": "Bearer token",
+    },
+  }
+);
+```
+
+### Custom response types
+
+```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" }
+);
+```
+
+### Error handling
+
+```typescript
+import { FetchError } 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}`);
+  }
+}
+```
+
+### Flexible validation
+
+```typescript
+// Throw on validation error (default)
+const user = await $fetch(url, UserSchema, {
+  throwOnValidationError: true,
+});
+
+// Return validation result without throwing
+const result = await $fetch(url, UserSchema, {
+  throwOnValidationError: false,
+});
+
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.error(result.error);
+}
+```
+
+## 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/index.d.mts

@@ -0,0 +1,10 @@
+//#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

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

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

package/dist/errors-BCMOymYz.mjs

@@ -0,0 +1,17 @@
+//#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

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

@@ -0,0 +1,18 @@
+//#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

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

@@ -0,0 +1,60 @@
+import { n as ResponseType, t as FetchConfig } from "./index-Dz58_HD6.mjs";
+import { z } from "zod";
+
+//#region src/index.d.ts
+
+/**
+ * Type-safe fetch wrapper with Zod validation
+ *
+ * @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(),
+ * });
+ *
+ * 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; }
+ * }
+ */
+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;
+/**
+ * Convenience methods for common HTTP verbs
+ *
+ * @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: {
+  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>>;
+};
+//#endregion
+export { $fetch, api, safeFetch };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

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

package/dist/index.mjs

@@ -0,0 +1,86 @@
+import { t as FetchError } from "./errors-BCMOymYz.mjs";
+import { n as prepareHeadersAndBody, t as parseResponse } from "./utils-CZ-1Z2-1.mjs";
+
+//#region src/index.ts
+/**
+* Type-safe fetch wrapper with Zod validation
+*
+* @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(),
+* });
+*
+* 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; }
+* }
+*/
+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, {
+		...rest,
+		body: preparedBody,
+		headers: preparedHeaders
+	});
+	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;
+/**
+* Convenience methods for common HTTP verbs
+*
+* @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 = {
+	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"
+	})
+};
+
+//#endregion
+export { $fetch, api, safeFetch };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/dist/types/index.d.mts

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

package/dist/types/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/utils/index.d.mts

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

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

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

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

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

package/package.json

@@ -1,33 +1,40 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
     "zod": "^4.1.12"
   },
   "devDependencies": {
     "@types/node": "latest",
+    "@vitest/coverage-v8": "^4.0.13",
     "jsdom": "latest",
     "tsdown": "latest",
     "typescript": "latest",
     "vitest": "latest",
+    "@zap-studio/tsdown-config": "0.0.0",
     "@zap-studio/typescript-config": "0.0.0",
-    "@zap-studio/vitest-config": "0.0.0",
-    "@zap-studio/tsdown-config": "0.0.0"
+    "@zap-studio/vitest-config": "0.0.0"
   },
   "exports": {
-    ".": "./dist/index.js",
-    "./errors": "./dist/errors/index.js",
-    "./types": "./dist/types/index.js",
+    ".": "./dist/index.mjs",
+    "./errors": "./dist/errors/index.mjs",
+    "./types": "./dist/types/index.mjs",
+    "./utils": "./dist/utils/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "scripts": {
     "build": "tsdown --config tsdown.config.ts",
     "check-types": "tsc --noEmit",

package/src/errors/index.ts

@@ -1,11 +0,0 @@
-export class FetchError extends Error {
-	constructor(
-		message: string,
-		public status: number,
-		public statusText: string,
-		public response: Response,
-	) {
-		super(message);
-		this.name = "FetchError";
-	}
-}