@zap-studio/fetch 0.4.6 → 0.5.0

package/dist/types.d.mts

@@ -1,55 +1,56 @@
-import { StandardSchemaV1 } from "@standard-schema/spec";
+import { StandardSchemaV1 } from "@zap-studio/validation";
 
 //#region src/types.d.ts
-
-/**
-* Type representing various formats for search parameters
-* that can be used in requests.
-* Can be a URLSearchParams object, a record of string pairs,
-* a query string, or an array of tuples.
-*/
-type SearchParams = URLSearchParams | Record<string, string> | string | [string, string][];
-/**
-* JSON-serializable value used for request bodies.
-*/
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
+type FetchInput = Parameters<typeof fetch>[0];
+type URLSearchParamsInput = ConstructorParameters<typeof URLSearchParams>[0];
+type RequestBodyInit = RequestInit & {
+  json?: never;
 };
-/**
-* Request body type accepted by the fetch wrapper.
-*/
-type RequestBody = BodyInit | JsonValue;
-/**
-* Base extended request options without throwOnValidationError
-*/
-type BaseExtendedRequestInit = Omit<RequestInit, "body"> & {
+type JsonBodyInit = Omit<RequestInit, "body"> & {
   /**
-  * Request body - can be a BodyInit value or an object that will be JSON-stringified
+  * JSON body convenience. When provided, this is JSON-stringified into `body`.
+  * @default undefined
   */
-  body?: RequestBody;
+  json: unknown;
+  body?: never;
+};
+type CustomRequestInit = {
   /**
   * Per-request query/search params
   * @default undefined
   */
-  searchParams?: SearchParams;
+  searchParams?: URLSearchParamsInput | undefined;
   /**
   * Whether to throw a FetchError on HTTP errors (non-2xx responses)
   * @default true
   */
-  throwOnFetchError?: boolean;
-};
-/**
-* Extended RequestInit type to include custom fetch options
-*/
-type ExtendedRequestInit<TThrowOnValidationError extends boolean | undefined = boolean | undefined> = BaseExtendedRequestInit & {
+  throwOnFetchError?: boolean | undefined;
   /**
   * Whether to throw a ValidationError on validation errors
   * @default true
   */
-  throwOnValidationError?: TThrowOnValidationError;
+  throwOnValidationError?: boolean | undefined;
 };
 /**
+* Extended RequestInit type to include custom fetch options
+*
+* @example
+* const options: ExtendedRequestInit = {
+*   method: "POST",
+*   json: { name: "Ada" },
+*   throwOnFetchError: true,
+* };
+*/
+type ExtendedRequestInit = (RequestBodyInit | JsonBodyInit) & CustomRequestInit;
+/**
 * Internal defaults used by fetchInternal
+*
+* @example
+* const defaults: FetchDefaults = {
+*   baseURL: "https://api.example.com",
+*   throwOnFetchError: true,
+*   throwOnValidationError: true,
+* };
 */
 interface FetchDefaults {
   /**
@@ -61,12 +62,12 @@ interface FetchDefaults {
   * Default headers to include in all requests (can be overridden per request)
   * @default undefined
   */
-  headers?: HeadersInit;
+  headers?: HeadersInit | undefined;
   /**
   * Default query/search params applied to every request (can be overridden per request)
   * @default undefined
   */
-  searchParams?: SearchParams;
+  searchParams?: URLSearchParamsInput | undefined;
   /**
   * Whether to throw a `FetchError` on HTTP errors (non-2xx responses)
   * @default true
@@ -79,39 +80,64 @@ interface FetchDefaults {
   throwOnValidationError: boolean;
 }
 /**
-* Options for creating a custom fetch instance with `createFetch`
-*/
-type CreateFetchOptions = Partial<FetchDefaults>;
-/**
 * Type-safe fetch function with Standard Schema validation support
 */
 interface $Fetch {
   /**
   * Fetch with schema validation and throwOnValidationError: false
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param schema - Standard Schema for response validation
   * @param options - Extended request options with throwOnValidationError: false
   * @returns Standard Schema Result object with value or issues
-  */
-  <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options: ExtendedRequestInit<false>): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, native `fetch`, or `response.json()` body reading fail with a
+  *   `TypeError`.
+  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+  *   request/body read as an `AbortError` DOMException.
+  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+  * @throws Any error thrown or rejected by the provided Standard Schema validator.
+  */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
+    throwOnValidationError: false;
+  }): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
   /**
   * Fetch with schema validation and throwOnValidationError: true or undefined (default)
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param schema - Standard Schema for response validation
   * @param options - Extended request options
   * @returns Validated data of type TSchema
-  */
-  <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: ExtendedRequestInit<true | undefined>): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {ValidationError} When validation returns issues.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, native `fetch`, or `response.json()` body reading fail with a
+  *   `TypeError`.
+  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+  *   request/body read as an `AbortError` DOMException.
+  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+  * @throws Any error thrown or rejected by the provided Standard Schema validator.
+  */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options?: ExtendedRequestInit & {
+    throwOnValidationError?: true | undefined;
+  }): Promise<StandardSchemaV1.InferOutput<TSchema>>;
   /**
   * Fetch without schema validation
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param options - Extended request options
   * @returns Raw Response object
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, or native `fetch` fail with a `TypeError`.
+  * @throws {DOMException} When native `fetch` rejects an aborted request as an
+  *   `AbortError` DOMException.
   */
-  (resource: string, options?: ExtendedRequestInit): Promise<Response>;
+  (input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
 }
 /**
 * API HTTP method-specific fetch functions
+*
+* @example
+* const user = await api.get("/users/1", UserSchema);
 */
 interface ApiMethods {
   /**
@@ -136,5 +162,5 @@ interface ApiMethods {
   put: $Fetch;
 }
 //#endregion
-export { $Fetch, ApiMethods, CreateFetchOptions, ExtendedRequestInit, FetchDefaults, JsonValue, RequestBody, SearchParams };
+export { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;AASA;AAWA;AAAqC;AAKD,KAzBxB,YAAA,GACR,eAwBgC,GAvBhC,MAuBgC,CAAA,MAAA,EAAA,MAAA,CAAA,GAAA,MAAA,GAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EAAA;;;;AASnB,KAzBL,SAAA,GAyBK,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GApBb,SAoBa,EAAA,GAAA;EAWjB,CAAA,GAAY,EAAA,MAAA,CAAA,EA9BS,SA8BT;AAaZ,CAAA;AA+BA;AAKA;;AAUY,KApFA,WAAA,GAAc,QAoFd,GApFyB,SAoFzB;;;;KA/EP,uBAAA,GAA0B,IAiFD,CAjFM,WAiFN,EAAA,MAAA,CAAA,GAAA;EAAzB;;;EAYS,IAAA,CAAA,EAzFL,WAyFK;EAC4B;;;;EAQmB,YAAA,CAAA,EA7F5C,YA6F4C;EAAR;;AAMrD;;EAQO,iBAAA,CAAA,EAAA,OAAA;CAIE;;;;KApGG,iGAER;;;;;2BAKuB;;;;;UAMV,aAAA;;;;;;;;;;YAUL;;;;;iBAKK;;;;;;;;;;;;;;;KAgBL,kBAAA,GAAqB,QAAQ;;;;UAKxB,MAAA;;;;;;;;mBAQE,4CAEP,kBACC,6BACR,QAAQ,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;;;;;;;;mBAS/C,4CAEP,mBACE,wCACT,QAAQ,gBAAA,CAAiB,YAAY;;;;;;;+BAQX,sBAAsB,QAAQ;;;;;UAM5C,UAAA;;;;UAIP;;;;OAIH;;;;SAIE;;;;QAID;;;;OAID"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAQY,UAAA,GAAa,UAAA,QAAkB,KAAA;AAAA,KAEtC,oBAAA,GAAuB,qBAAA,QAA6B,eAAA;AAAA,KAEpD,eAAA,GAAkB,WAAA;EACrB,IAAA;AAAA;AAAA,KAGG,YAAA,GAAe,IAAA,CAAK,WAAA;EANgC;AAAA;;;EAWvD,IAAA;EACA,IAAA;AAAA;AAAA,KAGG,iBAAA;;;;;EAKH,YAAA,GAAe,oBAAA;;;;AARf;EAaA,iBAAA;;;;;EAKA,sBAAA;AAAA;;;AAaF;;;;;;;;KAAY,mBAAA,IAAuB,eAAA,GAAkB,YAAA,IAAgB,iBAAA;;;;;AAYrE;;;;;;UAAiB,aAAA;;;;;EAKf,OAAA;EAoBA;AAMF;;;EArBE,OAAA,GAAU,WAAA;;;;;EAKV,YAAA,GAAe,oBAAA;;;;;EAKf,iBAAA;;;;;EAKA,sBAAA;AAAA;;;;UAMe,MAAA;;;;;;;;;;;;;;;;mBAgBE,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,EAAS,mBAAA;IAAwB,sBAAA;EAAA,IAChC,OAAA,CAAQ,gBAAA,CAAiB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,OAAA;;;;;;;;;;;;;;;;;mBAkB/C,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,GAAU,mBAAA;IACR,sBAAA;EAAA,IAED,OAAA,CAAQ,gBAAA,CAAiB,WAAA,CAAY,OAAA;EAsBzB;;;;;;;;;;;EAAA,CATd,KAAA,EAAO,UAAA,EAAY,OAAA,GAAU,mBAAA,GAAsB,OAAA,CAAQ,QAAA;AAAA;;;;;;;UAS7C,UAAA;EAoBV;;;EAhBL,MAAA,EAAQ,MAAA;;;;EAIR,GAAA,EAAK,MAAA;;;;EAIL,KAAA,EAAO,MAAA;;;;EAIP,IAAA,EAAM,MAAA;;;;EAIN,GAAA,EAAK,MAAA;AAAA"}

package/dist/types.mjs

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

package/dist/url.d.mts

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

package/dist/url.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.mts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBA4BgB,iBAAA,CACd,WAAA,UACA,QAAA,EAAU,aAAA,EACV,YAAA,EAAc,mBAAA"}

package/dist/url.mjs

@@ -0,0 +1,56 @@
+//#region src/url.ts
+/**
+* Resolves final request URL by applying baseURL and layered search params.
+*
+* Search param precedence:
+* 1. `defaults.searchParams`
+* 2. search params already present in `resourceUrl`
+* 3. per-request `searchParams`
+*
+* @example
+* const finalUrl = resolveRequestUrl(
+*   "/users?page=2",
+*   { ...defaults, baseURL: "https://api.example.com", searchParams: { locale: "en" } },
+*   { page: "3" },
+* );
+* // https://api.example.com/users?locale=en&page=3
+*
+* @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by
+*   `URL`, or when default/per-request search params cannot be converted by
+*   `URLSearchParams`.
+*/
+function resolveRequestUrl(resourceUrl, defaults, searchParams) {
+	return resolveSearchParams(defaults.baseURL ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString() : resourceUrl, defaults.searchParams, searchParams);
+}
+/**
+* Resolves search params by applying default params, URL params, then request params.
+*/
+function resolveSearchParams(url, defaultSearchParams, searchParams) {
+	const hasFragment = url.includes("#");
+	const [urlWithoutHash = "", hash = ""] = url.split("#", 2);
+	const [pathname = "", urlSearchParams] = urlWithoutHash.split("?", 2);
+	const resolvedSearchParams = new URLSearchParams();
+	mergeSearchParams(resolvedSearchParams, defaultSearchParams);
+	mergeSearchParams(resolvedSearchParams, urlSearchParams);
+	mergeSearchParams(resolvedSearchParams, searchParams);
+	const resolvedSearch = resolvedSearchParams.toString();
+	const fragmentSuffix = hasFragment ? `#${hash}` : "";
+	if (!resolvedSearch) return `${pathname}${fragmentSuffix}`;
+	return `${pathname}?${resolvedSearch}${fragmentSuffix}`;
+}
+/**
+* Ensures a URL has a trailing slash for relative URL resolution.
+*/
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+/**
+* Copies search params into target, overriding duplicate keys.
+*/
+function mergeSearchParams(target, source) {
+	for (const [key, value] of new URLSearchParams(source)) target.set(key, value);
+}
+//#endregion
+export { resolveRequestUrl };
+
+//# sourceMappingURL=url.mjs.map

package/dist/url.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.mjs","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * URL resolution and query merging utilities.\n *\n * @module\n */\n\nimport type { ExtendedRequestInit, FetchDefaults } from \"./types.js\";\n\n/**\n * Resolves final request URL by applying baseURL and layered search params.\n *\n * Search param precedence:\n * 1. `defaults.searchParams`\n * 2. search params already present in `resourceUrl`\n * 3. per-request `searchParams`\n *\n * @example\n * const finalUrl = resolveRequestUrl(\n *   \"/users?page=2\",\n *   { ...defaults, baseURL: \"https://api.example.com\", searchParams: { locale: \"en\" } },\n *   { page: \"3\" },\n * );\n * // https://api.example.com/users?locale=en&page=3\n *\n * @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by\n *   `URL`, or when default/per-request search params cannot be converted by\n *   `URLSearchParams`.\n */\nexport function resolveRequestUrl(\n  resourceUrl: string,\n  defaults: FetchDefaults,\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined,\n): string {\n  const url = defaults.baseURL\n    ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString()\n    : resourceUrl;\n\n  return resolveSearchParams(url, defaults.searchParams, searchParams);\n}\n\n/**\n * Resolves search params by applying default params, URL params, then request params.\n */\nfunction resolveSearchParams(\n  url: string,\n  defaultSearchParams: FetchDefaults[\"searchParams\"] | undefined,\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined,\n): string {\n  const hasFragment = url.includes(\"#\");\n  const [urlWithoutHash = \"\", hash = \"\"] = url.split(\"#\", 2);\n  const [pathname = \"\", urlSearchParams] = urlWithoutHash.split(\"?\", 2);\n  const resolvedSearchParams = new URLSearchParams();\n\n  mergeSearchParams(resolvedSearchParams, defaultSearchParams);\n  mergeSearchParams(resolvedSearchParams, urlSearchParams);\n  mergeSearchParams(resolvedSearchParams, searchParams);\n\n  const resolvedSearch = resolvedSearchParams.toString();\n  const fragmentSuffix = hasFragment ? `#${hash}` : \"\";\n\n  if (!resolvedSearch) {\n    return `${pathname}${fragmentSuffix}`;\n  }\n\n  return `${pathname}?${resolvedSearch}${fragmentSuffix}`;\n}\n\n/**\n * Ensures a URL has a trailing slash for relative URL resolution.\n */\nfunction ensureTrailingSlash(url: string): string {\n  return url.endsWith(\"/\") ? url : `${url}/`;\n}\n\n/**\n * Copies search params into target, overriding duplicate keys.\n */\nfunction mergeSearchParams(\n  target: URLSearchParams,\n  source: ExtendedRequestInit[\"searchParams\"] | undefined,\n): void {\n  for (const [key, value] of new URLSearchParams(source)) {\n    target.set(key, value);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,kBACd,aACA,UACA,cACQ;AAKR,QAAO,oBAJK,SAAS,UACjB,IAAI,IAAI,aAAa,oBAAoB,SAAS,QAAQ,CAAC,CAAC,UAAU,GACtE,aAE4B,SAAS,cAAc,aAAa;;;;;AAMtE,SAAS,oBACP,KACA,qBACA,cACQ;CACR,MAAM,cAAc,IAAI,SAAS,IAAI;CACrC,MAAM,CAAC,iBAAiB,IAAI,OAAO,MAAM,IAAI,MAAM,KAAK,EAAE;CAC1D,MAAM,CAAC,WAAW,IAAI,mBAAmB,eAAe,MAAM,KAAK,EAAE;CACrE,MAAM,uBAAuB,IAAI,iBAAiB;AAElD,mBAAkB,sBAAsB,oBAAoB;AAC5D,mBAAkB,sBAAsB,gBAAgB;AACxD,mBAAkB,sBAAsB,aAAa;CAErD,MAAM,iBAAiB,qBAAqB,UAAU;CACtD,MAAM,iBAAiB,cAAc,IAAI,SAAS;AAElD,KAAI,CAAC,eACH,QAAO,GAAG,WAAW;AAGvB,QAAO,GAAG,SAAS,GAAG,iBAAiB;;;;;AAMzC,SAAS,oBAAoB,KAAqB;AAChD,QAAO,IAAI,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI;;;;;AAM1C,SAAS,kBACP,QACA,QACM;AACN,MAAK,MAAM,CAAC,KAAK,UAAU,IAAI,gBAAgB,OAAO,CACpD,QAAO,IAAI,KAAK,MAAM"}

package/package.json

@@ -1,74 +1,73 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.4.6",
-  "type": "module",
-  "license": "MIT",
+  "version": "0.5.0",
   "private": false,
-  "homepage": "https://www.zapstudio.dev/packages/fetch",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zap-studio/monorepo.git",
-    "directory": "packages/fetch"
-  },
   "description": "A type-safe fetch wrapper for HTTP requests with runtime schema validation.",
   "keywords": [
-    "fetch",
-    "type-safe",
-    "validation",
-    "schema",
-    "typescript",
-    "http",
     "api",
-    "zod",
-    "valibot",
     "arktype",
-    "runtime validation",
     "error handling",
-    "standard schema",
+    "fetch",
+    "http",
     "request",
-    "response"
+    "response",
+    "runtime validation",
+    "schema",
+    "standard schema",
+    "type-safe",
+    "typescript",
+    "valibot",
+    "validation",
+    "zod"
   ],
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://www.zapstudio.dev/packages/fetch",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zap-studio/monorepo.git",
+    "directory": "packages/fetch"
   },
   "files": [
     "dist",
     "CHANGELOG.md",
-    "LICENSE.md",
+    "LICENSE",
     "README.md"
   ],
-  "dependencies": {
-    "@standard-schema/spec": "^1.1.0",
-    "@zap-studio/validation": "0.3.1"
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.2",
-    "@vitest/coverage-v8": "^4.0.15",
-    "arktype": "^2.1.29",
-    "tsdown": "^0.18.0",
-    "typescript": "^5.9.3",
-    "valibot": "^1.2.0",
-    "vitest": "^4.0.18",
-    "zod": "^4.2.0",
-    "@zap-studio/vitest-config": "0.0.0",
-    "@zap-studio/typescript-config": "0.0.0",
-    "@zap-studio/tsdown-config": "0.0.0"
-  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
     "./constants": "./dist/constants.mjs",
     "./errors": "./dist/errors.mjs",
+    "./headers": "./dist/headers.mjs",
+    "./internal": "./dist/internal.mjs",
+    "./methods": "./dist/methods.mjs",
+    "./request": "./dist/request.mjs",
     "./types": "./dist/types.mjs",
-    "./utils": "./dist/utils.mjs",
+    "./url": "./dist/url.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zap-studio/validation": "0.3.2"
+  },
+  "devDependencies": {
+    "arktype": "^2.2.0",
+    "typescript": "^6.0.3",
+    "valibot": "^1.3.1",
+    "vite-plus": "^0.1.19",
+    "zod": "^4.3.6",
+    "@zap-studio/typescript": "0.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
-    "build": "tsdown --config tsdown.config.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest --watch"
+    "build": "vp pack",
+    "test": "vp test run",
+    "test:watch": "vp test watch"
   }
 }

package/dist/errors-DQfwnwmz.mjs

@@ -1,18 +0,0 @@
-//#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;
-	}
-};
-
-//#endregion
-export { FetchError as t };
-//# sourceMappingURL=errors-DQfwnwmz.mjs.map

package/dist/errors-DQfwnwmz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-DQfwnwmz.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\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"],"mappings":";;;;AAGA,IAAa,aAAb,cAAgC,MAAM;CACpC;CACA;CAEA,YAAY,SAAiB,UAAoB;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW"}

package/dist/utils.d.mts

@@ -1,33 +0,0 @@
-import { $Fetch, ExtendedRequestInit, FetchDefaults } from "./types.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/utils.d.ts
-
-/**
-* Merges two HeadersInit objects, with the second one taking precedence
-*
-* @example
-* const baseHeaders = { "Authorization": "Bearer token", "Content-Type": "application/json" };
-* const overrideHeaders = { "Content-Type": "application/xml", "X-Custom-Header": "value" };
-*
-* const merged = mergeHeaders(baseHeaders, overrideHeaders);
-*
-* // Resulting headers:
-* // {
-* //   "Authorization": "Bearer token",
-* //   "Content-Type": "application/xml",
-* //   "X-Custom-Header": "value"
-* // }
-*/
-declare function mergeHeaders(base: HeadersInit | undefined, override: HeadersInit | undefined): Headers | undefined;
-/**
-* Internal fetch implementation used by both $fetch and createFetch
-*/
-declare function fetchInternal(resource: string, schema: StandardSchemaV1 | undefined, options: ExtendedRequestInit | undefined, defaults: FetchDefaults): Promise<unknown>;
-/**
-* Creates an HTTP method helper bound to a fetch function
-*/
-declare function createMethod<TFetch extends $Fetch>(fetchFn: TFetch, method: string): $Fetch;
-//#endregion
-export { createMethod, fetchInternal, mergeHeaders };
-//# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;AAyLA;;;;;;AAiFA;;;AAGG,iBA7Qa,YAAA,CA6Qb,IAAA,EA5QK,WA4QL,GAAA,SAAA,EAAA,QAAA,EA3QS,WA2QT,GAAA,SAAA,CAAA,EA1QA,OA0QA,GAAA,SAAA;;;;iBApFmB,aAAA,2BAEZ,uCACC,2CACC,gBACT;;;;iBA4Ea,4BAA4B,iBACjC,yBAER"}

package/dist/utils.mjs

@@ -1,180 +0,0 @@
-import { t as FetchError } from "./errors-DQfwnwmz.mjs";
-import { isStandardSchema, standardValidate } from "@zap-studio/validation";
-
-//#region src/utils.ts
-/**
-* Merges two HeadersInit objects, with the second one taking precedence
-*
-* @example
-* const baseHeaders = { "Authorization": "Bearer token", "Content-Type": "application/json" };
-* const overrideHeaders = { "Content-Type": "application/xml", "X-Custom-Header": "value" };
-*
-* const merged = mergeHeaders(baseHeaders, overrideHeaders);
-*
-* // Resulting headers:
-* // {
-* //   "Authorization": "Bearer token",
-* //   "Content-Type": "application/xml",
-* //   "X-Custom-Header": "value"
-* // }
-*/
-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;
-}
-/**
-* Removes trailing slashes from a string
-*/
-function trimTrailingSlashes(str) {
-	let end = str.length;
-	while (end > 0 && str[end - 1] === "/") end -= 1;
-	return str.slice(0, end);
-}
-/**
-* Removes leading slashes from a string
-*/
-function trimLeadingSlashes(str) {
-	let start = 0;
-	while (start < str.length && str[start] === "/") start += 1;
-	return str.slice(start);
-}
-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);
-}
-/**
-* Normalizes search parameters into a URLSearchParams object.
-*/
-function normalizeSearchParams(input) {
-	if (input === void 0 || input === null) return new URLSearchParams();
-	if (input instanceof URLSearchParams) return new URLSearchParams(input);
-	if (typeof input === "string") return new URLSearchParams(input);
-	if (Array.isArray(input)) return new URLSearchParams(input);
-	const params = new URLSearchParams();
-	for (const [k, v] of Object.entries(input)) params.set(k, v);
-	return params;
-}
-/**
-* Parses a URL string into its path, query, and hash components.
-* Handles both absolute URLs (using URL constructor) and relative paths.
-*/
-function parseUrlComponents(url) {
-	if (isAbsoluteURL(url)) try {
-		const parsed = new URL(url);
-		const pathOnly = `${parsed.origin}${parsed.pathname}`;
-		const existingQuery = parsed.search.startsWith("?") ? parsed.search.slice(1) : parsed.search;
-		let hash$1 = parsed.hash;
-		if (hash$1 === "" && url.endsWith("#")) hash$1 = "#";
-		return {
-			pathOnly,
-			existingQuery,
-			hash: hash$1
-		};
-	} catch {}
-	let hash = "";
-	let urlWithoutHash = url;
-	const hashIndex = url.indexOf("#");
-	if (hashIndex !== -1) {
-		hash = url.slice(hashIndex);
-		urlWithoutHash = url.slice(0, hashIndex);
-	}
-	const queryIndex = urlWithoutHash.indexOf("?");
-	if (queryIndex === -1) return {
-		pathOnly: urlWithoutHash,
-		existingQuery: "",
-		hash
-	};
-	return {
-		pathOnly: urlWithoutHash.slice(0, queryIndex),
-		existingQuery: urlWithoutHash.slice(queryIndex + 1),
-		hash
-	};
-}
-/**
-* Builds a URL with merged search parameters from factory defaults,
-* request options, and existing query parameters.
-*
-* This function takes a base URL, factory search parameters,
-* and request search parameters, and combines them into a single URL.
-*
-* Priority (highest to lowest):
-* 1. Request search parameters (highest priority, overwrites all others)
-* 2. Existing query parameters from the URL (overwrites factory defaults)
-* 3. Factory search parameters (lowest priority, overwritten by all others)
-*
-* If no search parameters are provided, the URL will not have a query string.
-* Any trailing hash/fragment is preserved.
-*/
-function buildUrlWithMergedSearchParams(url, factorySearch, requestSearch) {
-	const { pathOnly, existingQuery, hash } = parseUrlComponents(url);
-	if (!(factorySearch ?? requestSearch ?? existingQuery)) return url;
-	const mergedParams = new URLSearchParams();
-	const resourceParams = new URLSearchParams(existingQuery);
-	const factoryParams = normalizeSearchParams(factorySearch);
-	const reqParams = normalizeSearchParams(requestSearch);
-	for (const [k, v] of factoryParams.entries()) mergedParams.set(k, v);
-	for (const [k, v] of resourceParams.entries()) mergedParams.set(k, v);
-	for (const [k, v] of reqParams.entries()) mergedParams.set(k, v);
-	const queryString = mergedParams.toString();
-	if (queryString) return `${pathOnly}?${queryString}${hash}`;
-	return `${pathOnly}${hash}`;
-}
-/**
-* 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, searchParams: requestSearchParams, ...rest } = options || {};
-	const mergedHeaders = mergeHeaders(defaults.headers, requestHeaders);
-	const init = {
-		...rest,
-		headers: mergedHeaders
-	};
-	const isBodyInit = typeof init.body === "string" || init.body instanceof FormData || init.body instanceof URLSearchParams || init.body instanceof Blob || init.body instanceof ArrayBuffer || ArrayBuffer.isView(init.body) || init.body instanceof ReadableStream;
-	if (init.body != null && !isBodyInit) {
-		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 = trimTrailingSlashes(defaults.baseURL);
-		const path = trimLeadingSlashes(resource);
-		url = base ? `${base}/${path}` : resource;
-	}
-	url = buildUrlWithMergedSearchParams(url, defaults.searchParams, requestSearchParams);
-	const response = await fetch(url, init);
-	if (throwOnFetchError && !response.ok) throw new FetchError(`HTTP ${response.status}: ${response.statusText}`, response);
-	if (schema) {
-		const raw = await response.json();
-		if (throwOnValidationError) return standardValidate(schema, raw, { throwOnError: true });
-		return standardValidate(schema, raw, { throwOnError: false });
-	}
-	return response;
-}
-/**
-* Creates an HTTP method helper bound to a fetch function
-*/
-function createMethod(fetchFn, method) {
-	function methodFetch(resource, schemaOrOptions, optionsOrUndefined) {
-		const [schema, options] = isStandardSchema(schemaOrOptions) ? [schemaOrOptions, optionsOrUndefined] : [void 0, schemaOrOptions];
-		return fetchFn(resource, schema, {
-			...options,
-			method
-		});
-	}
-	return methodFetch;
-}
-
-//#endregion
-export { createMethod, fetchInternal, mergeHeaders };
-//# sourceMappingURL=utils.mjs.map