@zap-studio/fetch 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @zap-studio/fetch
 
+## 0.2.2
+
+### Patch Changes
+
+- 5c3abbf: Prepare JSR publish and isolatedDeclarations support with new explicit types for `$Fetch` and `ApiMethods`
+
 ## 0.2.1
 
 ### Patch Changes

package/dist/errors.d.mts

@@ -3,16 +3,16 @@ import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/errors.d.ts
 
 /**
- * Error thrown for HTTP errors (non-2xx responses)
- */
+* 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
- */
+* Error thrown for validation errors
+*/
 declare class ValidationError extends Error {
   issues: StandardSchemaV1.Issue[];
   constructor(issues: StandardSchemaV1.Issue[]);

package/dist/errors.d.mts.map

@@ -1 +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"}
+{"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;EAAA,MAAA,EAC3B,gBAAA,CAAiB,KADU,EAAA;sBAGf,gBAAA,CAAiB"}

package/dist/index.d.mts

@@ -1,101 +1,95 @@
-import { n as ExtendedRequestInit, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
+import { i as ExtendedRequestInit, n as ApiMethods, r as CreateFetchOptions, t as $Fetch } from "./types-BB4ejGeA.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/index.d.ts
 
 /**
- * Type-safe fetch wrapper with Standard Schema validation.
- *
- * - When `throwOnValidationError: true`: validated data of type `TSchema`
- * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`
- * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses
- *
- * If no schema is provided, returns the raw `Response` object.
- *
- * @throws {FetchError} When `throwOnFetchError: 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() });
- *
- * // Basic usage (schema validation)
- * const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
- * console.log("Validated user:", user);
- *
- * // Raw usage (no schema validation and typed Response object)
- * const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
- * const json = await result.json() as ResultType;
- * console.log("Raw response data:", json);
- *
- * // Usage with validation errors returned instead of thrown
- * const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
- *
- * if (result.issues) {
- *   console.error("Validation errors:", result.issues);
- * } else {
- *   console.log("Validated user:", result.value);
- * }
- */
+* 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() });
+*
+* // Basic usage (schema validation)
+* const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
+* console.log("Validated user:", user);
+*
+* // Raw usage (no schema validation and typed Response object)
+* const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
+* const json = await result.json() as ResultType;
+* console.log("Raw response data:", json);
+*
+* // Usage with validation errors returned instead of thrown
+* const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
+*
+* if (result.issues) {
+*   console.error("Validation errors:", result.issues);
+* } else {
+*   console.log("Validated user:", result.value);
+* }
+*/
 declare function $fetch<TSchema extends StandardSchemaV1>(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.
- *
- * These methods always require a schema for validation.
- * For raw responses without validation, use `$fetch` directly.
- *
- * @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: <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>>>;
-};
+* 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";
+* import { api } from "@zap-studio/fetch";
+*
+* const PostSchema = z.object({
+*   id: z.number(),
+*   title: z.string(),
+*   content: z.string(),
+* });
+*
+* async function fetchPost(postId: number) {
+*   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+*   return post; // post is typed as { id: number; title: string; content: string; }
+* }
+*/
+declare const api: ApiMethods;
 /**
- * Creates a custom fetch instance with pre-configured defaults.
- *
- * Use this factory to create API clients with a base URL, default headers,
- * and other shared configuration. Each instance is independent.
- *
- * @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" } });
- */
+* 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;
+  $fetch: $Fetch;
+  api: ApiMethods;
 };
 //#endregion
 export { $fetch, api, createFetch };

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.mts","names":["api: ApiMethods"],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgDA;;;;;;;;;;;AASA;;;;;AAsCA;AAgCA;;;;;;;;;;;;;;;;;iBA/EsB,uBAAuB,4CAEnC,mBACE,sBACT,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;iBAGnC,MAAA,6BAEV,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAmCEA,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCF,WAAA,kBAA4B;UAClC;OACH"}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"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\n/**\n * Removes trailing slashes from a string\n */\nfunction trimTrailingSlashes(str: string): string {\n  let end = str.length;\n  while (end > 0 && str[end - 1] === \"/\") {\n    end -= 1;\n  }\n  return str.slice(0, end);\n}\n\n/**\n * Removes leading slashes from a string\n */\nfunction trimLeadingSlashes(str: string): string {\n  let start = 0;\n  while (start < str.length && str[start] === \"/\") {\n    start += 1;\n  }\n  return str.slice(start);\n}\n\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 = trimTrailingSlashes(defaults.baseURL);\n    const path = trimLeadingSlashes(resource);\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":"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"}
+{"version":3,"file":"index.mjs","names":["GLOBAL_DEFAULTS: FetchDefaults","url: string","api: ApiMethods","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: FetchDefaults = {\n  baseURL: \"\",\n  headers: undefined,\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n};\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { FetchError } from \"../errors\";\nimport type { $Fetch, 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\n/**\n * Removes trailing slashes from a string\n */\nfunction trimTrailingSlashes(str: string): string {\n  let end = str.length;\n  while (end > 0 && str[end - 1] === \"/\") {\n    end -= 1;\n  }\n  return str.slice(0, end);\n}\n\n/**\n * Removes leading slashes from a string\n */\nfunction trimLeadingSlashes(str: string): string {\n  let start = 0;\n  while (start < str.length && str[start] === \"/\") {\n    start += 1;\n  }\n  return str.slice(start);\n}\n\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 = trimTrailingSlashes(defaults.baseURL);\n    const path = trimLeadingSlashes(resource);\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 $Fetch>(\n  fetchFn: TFetch,\n  method: string\n): $Fetch {\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  $Fetch,\n  ApiMethods,\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: ApiMethods = {\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: $Fetch;\n  api: ApiMethods;\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,MAAaA,kBAAiC;CAC5C,SAAS;CACT,SAAS;CACT,mBAAmB;CACnB,wBAAwB;CACzB;;;;;;;;;;;;;;;;;;;;ACWD,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;;;;;AAMT,SAAS,oBAAoB,KAAqB;CAChD,IAAI,MAAM,IAAI;AACd,QAAO,MAAM,KAAK,IAAI,MAAM,OAAO,IACjC,QAAO;AAET,QAAO,IAAI,MAAM,GAAG,IAAI;;;;;AAM1B,SAAS,mBAAmB,KAAqB;CAC/C,IAAI,QAAQ;AACZ,QAAO,QAAQ,IAAI,UAAU,IAAI,WAAW,IAC1C,UAAS;AAEX,QAAO,IAAI,MAAM,MAAM;;AAGzB,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,IAAIC;AACJ,KAAI,cAAc,SAAS,CACzB,OAAM;MACD;EAEL,MAAM,OAAO,oBAAoB,SAAS,QAAQ;EAClD,MAAM,OAAO,mBAAmB,SAAS;AACzC,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,QACQ;AACR,SACE,UACA,QACA,YACG,QAAQ,UAAU,QAAQ;EAAE,GAAG;EAAS;EAAQ,CAAC;;;;;AChFxD,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,MAAaC,MAAkB;CAC7B,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-BB4ejGeA.d.mts

@@ -0,0 +1,100 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#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>;
+/**
+* Type-safe fetch function with Standard Schema validation support
+*/
+type $Fetch = {
+  /**
+  * Fetch with schema validation
+  * @param resource - URL or path to fetch
+  * @param schema - Standard Schema for response validation
+  * @param options - Extended request options
+  * @returns Validated data or Standard Schema Result based on throwOnValidationError option
+  */
+  <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: ExtendedRequestInit): Promise<StandardSchemaV1.InferOutput<TSchema> | StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  /**
+  * Fetch without schema validation
+  * @param resource - URL or path to fetch
+  * @param options - Extended request options
+  * @returns Raw Response object
+  */
+  (resource: string, options?: ExtendedRequestInit): Promise<Response>;
+};
+/**
+* API HTTP method-specific fetch functions
+*/
+type ApiMethods = {
+  /**
+  * GET method fetch function
+  */
+  get: $Fetch;
+  /**
+  * POST method fetch function
+  */
+  post: $Fetch;
+  /**
+  * PUT method fetch function
+  */
+  put: $Fetch;
+  /**
+  * DELETE method fetch function
+  */
+  delete: $Fetch;
+  /**
+  * PATCH method fetch function
+  */
+  patch: $Fetch;
+};
+//#endregion
+export { FetchDefaults as a, ExtendedRequestInit as i, ApiMethods as n, CreateFetchOptions as r, $Fetch as t };
+//# sourceMappingURL=types-BB4ejGeA.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-BB4ejGeA.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAAuC,KAA3B,mBAAA,GAAsB,IAAK,CAAA,WAAA,EAAA,MAAA,CAAA,GAAA;EAAL;;;EAId,IAAA,CAAA,EAAX,QAAW,GAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA;EAgBpB;AA0BA;AAKA;;EAUY,iBAAA,CAAA,EAAA,OAAA;EACE;;;;EAGgB,sBAAiB,CAAA,EAAA,OAAA;CAAzC;;;;AAS+C,KAtDzC,aAAA,GAsDyC;EAAA;AAMrD;;;EAYO,OAAA,EAAA,MAAA;EAIG;;;;WAlEC;;;;;;;;;;;;;;;KAgBC,kBAAA,GAAqB,QAAQ;;;;KAK7B,MAAA;;;;;;;;mBAQO,4CAEP,mBACE,sBACT,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;;;;;;;+BAS5B,sBAAsB,QAAQ;;;;;KAMjD,UAAA;;;;OAIL;;;;QAIC;;;;OAID;;;;UAIG;;;;SAID"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { n as ExtendedRequestInit, r as FetchDefaults, t as CreateFetchOptions } from "./types-C0Uhh2KM.mjs";
-export { CreateFetchOptions, ExtendedRequestInit, FetchDefaults };
+import { a as FetchDefaults, i as ExtendedRequestInit, n as ApiMethods, r as CreateFetchOptions, t as $Fetch } from "./types-BB4ejGeA.mjs";
+export { $Fetch, ApiMethods, CreateFetchOptions, ExtendedRequestInit, FetchDefaults };

package/dist/validator.d.mts

@@ -3,31 +3,31 @@ import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/validator.d.ts
 
 /**
- * Type guard to check if a value is a Standard Schema schema
- */
+* 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);
- * }
- */
+* 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 };

package/dist/validator.d.mts.map

@@ -1 +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"}
+{"version":3,"file":"validator.d.mts","names":[],"sources":["../src/validator.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;AA8BsB,iBA9BN,gBAAA,CA8BM,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA9BqC,gBA8BrC;;;;;;;;;;;;;;;;;;;;;;;iBAAA,iCAAiC,0BAC7C,iDAGP,QACC,gBAAA,CAAiB,YAAY,WAC7B,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
+  "license": "MIT",
   "private": false,
   "publishConfig": {
     "access": "public"

package/dist/types-C0Uhh2KM.d.mts

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

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