@zimic/fetch 0.1.0-canary.0

package/LICENSE.md

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2023 Diego Aquino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,230 @@
+<p align="center">
+  <img src="../../docs/zimic.png" align="center" width="100px" height="100px">
+</p>
+
+<h1 align="center">
+  Zimic
+</h1>
+
+<p align="center">
+  TypeScript-first HTTP request mocking
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/zimic">npm</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/zimicjs/zimic/wiki">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="#examples">Examples</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/zimicjs/zimic/issues">Issues</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/orgs/zimicjs/projects/1/views/5">Roadmap</a>
+</p>
+
+<div align="center">
+
+[![CI](https://github.com/zimicjs/zimic/actions/workflows/ci.yaml/badge.svg?branch=canary)](https://github.com/zimicjs/zimic/actions/workflows/ci.yaml)&nbsp;
+[![Coverage](https://img.shields.io/badge/Coverage-100%25-31C654?labelColor=353C43)](https://github.com/zimicjs/zimic/actions)&nbsp;
+[![License](https://img.shields.io/github/license/zimicjs/zimic?color=0E69BE&label=License&labelColor=353C43)](https://github.com/zimicjs/zimic/blob/canary/LICENSE.md)
+[![NPM Downloads](https://img.shields.io/npm/dm/zimic?style=flat&logo=npm&color=0E69BE&label=Downloads&labelColor=353C43)](https://www.npmjs.com/package/zimic)&nbsp;
+[![Stars](https://img.shields.io/github/stars/zimicjs/zimic)](https://github.com/zimicjs/zimic)&nbsp;
+
+</div>
+
+---
+
+Zimic is a lightweight, thoroughly tested, TypeScript-first HTTP request mocking library, inspired by
+[Zod](https://github.com/colinhacks/zod)'s type inference and using [MSW](https://github.com/mswjs/msw) under the hood.
+
+## Features
+
+Zimic provides a flexible and type-safe way to mock HTTP requests.
+
+- :zap: **Statically-typed mocks**: Declare the
+  [schema](https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas) of your HTTP endpoints and create
+  fully typed mocks. If you have an [OpenAPI v3](https://swagger.io/specification) schema, use
+  [`zimic typegen`](https://github.com/zimicjs/zimic/wiki/cli‐zimic‐typegen) to automatically generate types and keep
+  your mocks in sync with your API.
+- :link: **Network-level intercepts**: Internally, Zimic combines [MSW](https://github.com/mswjs/msw) and
+  [interceptor servers](https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server) to act on real HTTP requests. From you
+  application's point of view, the mocked responses are indistinguishable from the real ones.
+- :wrench: **Flexibility**: Mock external services and reliably test how your application behaves. Simulate success,
+  loading, and error states with ease using [standard web APIs](https://developer.mozilla.org/docs/Web/API).
+- :bulb: **Simplicity**: Zimic was designed to encourage clarity, simplicity, and robustness in your mocks. Check our
+  [getting started guide](https://github.com/zimicjs/zimic/wiki/getting‐started) and starting mocking!
+
+```ts
+import { type HttpSchema } from '@zimic/http';
+import { httpInterceptor } from 'zimic/interceptor/http';
+
+// 1. Declare your types:
+interface User {
+  username: string;
+}
+
+interface RequestError {
+  code: string;
+  message: string;
+}
+
+// 2. Declare your HTTP schema:
+// https://bit.ly/zimic-interceptor-http-schemas
+type MySchema = HttpSchema<{
+  '/users': {
+    POST: {
+      request: { body: User };
+      response: {
+        201: { body: User };
+        400: { body: RequestError };
+        409: { body: RequestError };
+      };
+    };
+
+    GET: {
+      request: {
+        headers: { authorization: string };
+        searchParams: {
+          username?: string;
+          limit?: `${number}`;
+        };
+      };
+      response: {
+        200: { body: User[] };
+        400: { body: RequestError };
+        401: { body: RequestError };
+      };
+    };
+  };
+
+  '/users/:userId': {
+    PATCH: {
+      request: {
+        headers: { authorization: string };
+        body: Partial<User>;
+      };
+      response: {
+        204: {};
+        400: { body: RequestError };
+      };
+    };
+  };
+}>;
+
+// 3. Create your interceptor:
+// https://bit.ly/zimic-interceptor-http#httpinterceptorcreateoptions
+const myInterceptor = httpInterceptor.create<MySchema>({
+  type: 'local',
+  baseURL: 'http://localhost:3000',
+  saveRequests: true, // Allow access to `handler.requests()`
+});
+
+// 4. Manage your interceptor lifecycle:
+// https://bit.ly/zimic-guides-testing
+beforeAll(async () => {
+  // 4.1. Start intercepting requests:
+  // https://bit.ly/zimic-interceptor-http#http-interceptorstart
+  await myInterceptor.start();
+});
+
+beforeEach(() => {
+  // 4.2. Clear interceptors so that no tests affect each other:
+  // https://bit.ly/zimic-interceptor-http#http-interceptorclear
+  myInterceptor.clear();
+});
+
+afterEach(() => {
+  // 4.3. Check that all expected requests were made:
+  // https://bit.ly/zimic-interceptor-http#http-interceptorchecktimes
+  myInterceptor.checkTimes();
+});
+
+afterAll(async () => {
+  // 4.4. Stop intercepting requests:
+  // https://bit.ly/zimic-interceptor-http#http-interceptorstop
+  await myInterceptor.stop();
+});
+
+// Enjoy mocking!
+test('example', async () => {
+  const users: User[] = [{ username: 'my-user' }];
+
+  // 5. Declare your mocks:
+  // https://bit.ly/zimic-interceptor-http#http-interceptormethodpath
+  const myHandler = myInterceptor
+    .get('/users')
+    // 5.1. Use restrictions to make declarative assertions and narrow down your mocks:
+    // https://bit.ly/zimic-interceptor-http#http-handlerwithrestriction
+    .with({
+      headers: { authorization: 'Bearer my-token' },
+      searchParams: { username: 'my' },
+    })
+    // 5.2. Respond with your mock data:
+    // https://bit.ly/zimic-interceptor-http#http-handlerresponddeclaration
+    .respond({
+      status: 200,
+      body: users,
+    })
+    // 5.3. Define how many requests you expect your application to make:
+    // https://bit.ly/zimic-interceptor-http#http-handlertimes
+    .times(1);
+
+  // 6. Run your application and make requests:
+  // ...
+
+  // 7. Check the requests you expect:
+  // https://bit.ly/zimic-interceptor-http#http-handlerrequests
+  //
+  // NOTE: The code below checks the requests manually. This is optional in this
+  // example because the `with` and `times` calls act as a declarative validation,
+  // meaning that exactly one request is expected with specific data. If fewer or
+  // more requests are received, the test will fail when `myInterceptor.checkTimes()`
+  // is called in the `afterEach` hook.
+  const requests = myHandler.requests();
+  expect(requests).toHaveLength(1);
+
+  expect(requests[0].headers.get('authorization')).toBe('Bearer my-token');
+
+  expect(requests[0].searchParams.size).toBe(1);
+  expect(requests[0].searchParams.get('username')).toBe('my');
+
+  expect(requests[0].body).toBe(null);
+});
+```
+
+## Documentation
+
+- [Introduction](https://github.com/zimicjs/zimic/wiki)
+- [Getting started](https://github.com/zimicjs/zimic/wiki/getting‐started)
+- [API reference](https://github.com/zimicjs/zimic/wiki/api‐zimic)
+- [CLI reference](https://github.com/zimicjs/zimic/wiki/cli‐zimic)
+- Guides
+  - [Testing](https://github.com/zimicjs/zimic/wiki/guides‐testing)
+
+> [!NOTE]
+>
+> Zimic has gone a long way in v0, but we're not yet v1!
+>
+> Reviews and improvements to the public API are possible, so breaking changes may **_exceptionally_** land without a
+> major release during v0. Despite of that, we do not expect big mental model shifts. Usually, migrating to a new Zimic
+> release requires minimal to no refactoring. During v0, we will follow these guidelines:
+>
+> - Breaking changes, if any, will be delivered in the next **_minor_** version.
+> - Breaking changes, if any, will be documented in the [version release](https://github.com/zimicjs/zimic/releases),
+>   along with a migration guide detailing the introduced changes and suggesting steps to migrate.
+>
+> From v0.8 onwards, we expect Zimic's public API to become more stable. If you'd like to share any feedback, please
+> feel free to [open an issue](https://github.com/zimicjs/zimic/issues) or
+> [create a discussion](https://github.com/zimicjs/zimic/discussions/new/choose)!
+
+## Examples
+
+Visit our [examples](../../examples/README.md) to see how to use Zimic with popular frameworks, libraries, and use cases!
+
+## Changelog
+
+The changelog is available on our [GitHub Releases](https://github.com/zimicjs/zimic/releases) page.
+
+## Contributing
+
+Interested in contributing to Zimic? Check out our [contributing guide](../../CONTRIBUTING.md) to get started!

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import { HttpSchema, HttpSchemaPath, HttpSchemaMethod, HttpMethod, HttpSearchParams, HttpMethodSchema, HttpRequest, HttpRequestHeadersSchema, AllowAnyStringInPathParams, LiteralHttpSchemaPathFromNonLiteral, HttpRequestSchema, HttpStatusCode, HttpResponse, HttpResponseBodySchema, HttpResponseHeadersSchema, HttpHeaders, JSONValue, HttpResponseSchemaStatusCode } from '@zimic/http';
+
+type Default<Type, IfEmpty = never> = [undefined | void] extends [Type] ? IfEmpty : Exclude<Type, undefined | void>;
+type DefaultNoExclude<Type, IfEmpty = never> = [undefined | void] extends Type ? IfEmpty : Type;
+type IfNever<Type, Yes, No = Type> = [Type] extends [never] ? Yes : No;
+type PossiblePromise<Type> = Type | PromiseLike<Type>;
+type ReplaceBy<Type, Source, Target> = Type extends Source ? Target : Type;
+
+declare const value: unique symbol;
+type JSONStringified<Value> = string & {
+    [value]: Value;
+};
+declare global {
+    interface JSON {
+        stringify<Value>(value: Value, replacer?: ((this: any, key: string, value: Value) => any) | (number | string)[] | null, space?: string | number): JSONStringified<Value>;
+    }
+}
+
+type FetchRequestInitWithHeaders<RequestSchema extends HttpRequestSchema> = [RequestSchema['headers']] extends [never] ? {
+    headers?: undefined;
+} : undefined extends RequestSchema['headers'] ? {
+    headers?: RequestSchema['headers'] | HttpHeaders<Default<RequestSchema['headers']>>;
+} : {
+    headers: RequestSchema['headers'] | HttpHeaders<Default<RequestSchema['headers']>>;
+};
+type FetchRequestInitWithSearchParams<RequestSchema extends HttpRequestSchema> = [
+    RequestSchema['searchParams']
+] extends [never] ? {
+    searchParams?: undefined;
+} : undefined extends RequestSchema['searchParams'] ? {
+    searchParams?: RequestSchema['searchParams'] | HttpSearchParams<Default<RequestSchema['searchParams']>>;
+} : {
+    searchParams: RequestSchema['searchParams'] | HttpSearchParams<Default<RequestSchema['searchParams']>>;
+};
+type FetchRequestInitWithBody<RequestSchema extends HttpRequestSchema> = [RequestSchema['body']] extends [never] ? {
+    body?: null;
+} : undefined extends RequestSchema['body'] ? {
+    body?: ReplaceBy<RequestSchema['body'], undefined, null>;
+} : RequestSchema['body'] extends string ? {
+    body: RequestSchema['body'];
+} : RequestSchema['body'] extends JSONValue ? {
+    body: JSONStringified<RequestSchema['body']>;
+} : {
+    body: RequestSchema['body'];
+};
+type FetchRequestInitPerPath<RequestSchema extends HttpRequestSchema> = FetchRequestInitWithHeaders<RequestSchema> & FetchRequestInitWithSearchParams<RequestSchema> & FetchRequestInitWithBody<RequestSchema>;
+type FetchRequestInit<Schema extends HttpSchema, Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>> = RequestInit & {
+    baseURL?: string;
+    method: Method;
+} & (Path extends Path ? FetchRequestInitPerPath<Default<Default<Schema[Path][Method]>['request']>> : never);
+declare namespace FetchRequestInit {
+    interface Defaults extends RequestInit {
+        baseURL: string;
+        method?: HttpMethod;
+        searchParams?: HttpSearchParams;
+    }
+}
+type AllFetchResponseStatusCode<MethodSchema extends HttpMethodSchema> = HttpResponseSchemaStatusCode<Default<MethodSchema['response']>>;
+type FetchResponseStatusCode<MethodSchema extends HttpMethodSchema, ErrorOnly extends boolean> = ErrorOnly extends true ? AllFetchResponseStatusCode<MethodSchema> & (HttpStatusCode.ClientError | HttpStatusCode.ServerError) : AllFetchResponseStatusCode<MethodSchema>;
+type HttpRequestBodySchema<MethodSchema extends HttpMethodSchema> = ReplaceBy<ReplaceBy<IfNever<DefaultNoExclude<Default<MethodSchema['request']>['body']>, null>, undefined, null>, ArrayBuffer, Blob>;
+interface FetchRequest<Path extends string = string, Method extends HttpMethod = HttpMethod, MethodSchema extends HttpMethodSchema = HttpMethodSchema> extends HttpRequest<HttpRequestBodySchema<MethodSchema>, HttpRequestHeadersSchema<MethodSchema>> {
+    path: AllowAnyStringInPathParams<Path>;
+    method: Method;
+}
+declare namespace FetchRequest {
+    interface Loose extends Request {
+        path: string;
+        method: HttpMethod;
+        clone: () => Loose;
+    }
+}
+interface FetchResponsePerStatusCode<Path extends string = string, Method extends HttpMethod = HttpMethod, MethodSchema extends HttpMethodSchema = HttpMethodSchema, StatusCode extends HttpStatusCode = HttpStatusCode> extends HttpResponse<HttpResponseBodySchema<MethodSchema, StatusCode>, StatusCode, HttpResponseHeadersSchema<MethodSchema, StatusCode>> {
+    request: FetchRequest<Path, Method, MethodSchema>;
+    error: StatusCode extends HttpStatusCode.ClientError | HttpStatusCode.ServerError ? FetchResponseError<Path, Method, MethodSchema> : null;
+}
+type FetchResponse<Path extends string = string, Method extends HttpMethod = HttpMethod, MethodSchema extends HttpMethodSchema = HttpMethodSchema, ErrorOnly extends boolean = false, StatusCode extends FetchResponseStatusCode<MethodSchema, ErrorOnly> = FetchResponseStatusCode<MethodSchema, ErrorOnly>> = StatusCode extends StatusCode ? FetchResponsePerStatusCode<Path, Method, MethodSchema, StatusCode> : never;
+declare namespace FetchResponse {
+    interface Loose extends Response {
+        request: FetchRequest.Loose;
+        error: AnyFetchRequestError | null;
+        clone: () => Loose;
+    }
+}
+type FetchRequestConstructor<Schema extends HttpSchema> = new <Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(input: FetchInput<Schema, Path, Method>, init: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>) => FetchRequest<LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method, Default<Schema[LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>][Method]>>;
+
+declare class FetchResponseError<Path extends string = string, Method extends HttpMethod = HttpMethod, MethodSchema extends HttpMethodSchema = HttpMethodSchema> extends Error {
+    request: FetchRequest<Path, Method, MethodSchema>;
+    response: FetchResponse<Path, Method, MethodSchema, true>;
+    constructor(request: FetchRequest<Path, Method, MethodSchema>, response: FetchResponse<Path, Method, MethodSchema, true>);
+    get cause(): FetchResponse<Path, Method, MethodSchema, true>;
+}
+type AnyFetchRequestError = FetchResponseError<any, any, any>;
+
+type FetchInput<Schema extends HttpSchema, Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Method extends HttpSchemaMethod<Schema>> = Path | URL | FetchRequest<LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method, Default<Schema[LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>][Method]>>;
+interface FetchFunction<Schema extends HttpSchema> {
+    <Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(input: Path | URL, init: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>): Promise<FetchResponse<LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method, Default<Schema[LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>][Method]>>>;
+    <Path extends HttpSchemaPath.NonLiteral<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(input: FetchRequest<LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method, Default<Schema[LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>][Method]>>, init?: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>): Promise<FetchResponse<LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method, Default<Schema[LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>][Method]>>>;
+}
+interface FetchOptions<Schema extends HttpSchema> extends Omit<FetchRequestInit.Defaults, 'method'> {
+    onRequest?: (request: FetchRequest.Loose, fetch: Fetch<Schema>) => PossiblePromise<Request>;
+    onResponse?: (response: FetchResponse.Loose, fetch: Fetch<Schema>) => PossiblePromise<Response>;
+}
+interface FetchClient<Schema extends HttpSchema> {
+    defaults: FetchRequestInit.Defaults;
+    Request: FetchRequestConstructor<Schema>;
+    onRequest?: FetchOptions<Schema>['onRequest'];
+    onResponse?: FetchOptions<Schema>['onResponse'];
+    isRequest: <Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(request: unknown, path: Path, method: Method) => request is FetchRequest<Path, Method, Default<Schema[Path][Method]>>;
+    isResponse: <Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(response: unknown, path: Path, method: Method) => response is FetchResponse<Path, Method, Default<Schema[Path][Method]>>;
+    isResponseError: <Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(error: unknown, path: Path, method: Method) => error is FetchResponseError<Path, Method, Default<Schema[Path][Method]>>;
+}
+type Fetch<Schema extends HttpSchema> = FetchFunction<Schema> & FetchClient<Schema>;
+
+declare function createFetch<Schema extends HttpSchema>(options: FetchOptions<HttpSchema<Schema>>): Fetch<HttpSchema<Schema>>;
+
+export { type Fetch, type FetchClient, type FetchOptions as FetchClientOptions, type FetchFunction, type FetchInput, FetchRequest, type FetchRequestConstructor, FetchRequestInit, FetchResponse, FetchResponseError, createFetch };

package/dist/index.js

@@ -0,0 +1,191 @@
+'use strict';
+
+var http = require('@zimic/http');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client/errors/FetchResponseError.ts
+var FetchResponseError = class extends Error {
+  constructor(request, response) {
+    super(`${request.method} ${request.url} failed with status ${response.status}: ${response.statusText}`);
+    this.request = request;
+    this.response = response;
+    this.name = "FetchResponseError";
+  }
+  static {
+    __name(this, "FetchResponseError");
+  }
+  get cause() {
+    return this.response;
+  }
+};
+var FetchResponseError_default = FetchResponseError;
+
+// src/utils/urls.ts
+function excludeNonPathParams(url) {
+  url.hash = "";
+  url.search = "";
+  url.username = "";
+  url.password = "";
+  return url;
+}
+__name(excludeNonPathParams, "excludeNonPathParams");
+function prepareURLForRegex(url) {
+  const encodedURL = encodeURI(url);
+  return encodedURL.replace(/([.()*?+$\\])/g, "\\$1");
+}
+__name(prepareURLForRegex, "prepareURLForRegex");
+var URL_PATH_PARAM_REGEX = /\/:([^/]+)/g;
+function createRegexFromURL(url) {
+  const urlWithReplacedPathParams = prepareURLForRegex(url).replace(URL_PATH_PARAM_REGEX, "/(?<$1>[^/]+)").replace(/(\/+)$/, "(?:/+)?");
+  return new RegExp(`^${urlWithReplacedPathParams}$`);
+}
+__name(createRegexFromURL, "createRegexFromURL");
+function joinURL(...parts) {
+  return parts.map((part, index) => {
+    const isFirstPart = index === 0;
+    const isLastPart = index === parts.length - 1;
+    let partAsString = part.toString();
+    if (!isFirstPart) {
+      partAsString = partAsString.replace(/^\//, "");
+    }
+    if (!isLastPart) {
+      partAsString = partAsString.replace(/\/$/, "");
+    }
+    return partAsString;
+  }).filter((part) => part.length > 0).join("/");
+}
+__name(joinURL, "joinURL");
+
+// src/client/FetchClient.ts
+var FetchClient = class {
+  static {
+    __name(this, "FetchClient");
+  }
+  fetch;
+  constructor({ onRequest, onResponse, ...defaults }) {
+    this.fetch = this.createFetchFunction();
+    this.fetch.defaults = defaults;
+    this.fetch.Request = this.createRequestClass(defaults);
+    this.fetch.onRequest = onRequest;
+    this.fetch.onResponse = onResponse;
+  }
+  createFetchFunction() {
+    const fetch = /* @__PURE__ */ __name(async (input, init) => {
+      const request = await this.createFetchRequest(input, init);
+      const requestClone = request.clone();
+      const rawResponse = await globalThis.fetch(
+        // Optimize type checking by narrowing the type of request
+        requestClone
+      );
+      const response = await this.createFetchResponse(request, rawResponse);
+      return response;
+    }, "fetch");
+    Object.setPrototypeOf(fetch, this);
+    return fetch;
+  }
+  async createFetchRequest(input, init) {
+    let request = input instanceof Request ? input : new this.fetch.Request(input, init);
+    if (this.fetch.onRequest) {
+      const requestAfterInterceptor = await this.fetch.onRequest(
+        // Optimize type checking by narrowing the type of request
+        request,
+        this.fetch
+      );
+      if (requestAfterInterceptor !== request) {
+        const isFetchRequest = requestAfterInterceptor instanceof this.fetch.Request;
+        request = isFetchRequest ? requestAfterInterceptor : new this.fetch.Request(requestAfterInterceptor, init);
+      }
+    }
+    return request;
+  }
+  async createFetchResponse(fetchRequest, rawResponse) {
+    let response = this.defineFetchResponseProperties(fetchRequest, rawResponse);
+    if (this.fetch.onResponse) {
+      const responseAfterInterceptor = await this.fetch.onResponse(
+        // Optimize type checking by narrowing the type of response
+        response,
+        this.fetch
+      );
+      const isFetchResponse = responseAfterInterceptor instanceof Response && "request" in responseAfterInterceptor && responseAfterInterceptor.request instanceof this.fetch.Request;
+      response = isFetchResponse ? responseAfterInterceptor : this.defineFetchResponseProperties(fetchRequest, responseAfterInterceptor);
+    }
+    return response;
+  }
+  defineFetchResponseProperties(fetchRequest, response) {
+    const fetchResponse = response;
+    Object.defineProperty(fetchResponse, "request", {
+      value: fetchRequest,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    const responseError = fetchResponse.ok ? null : new FetchResponseError_default(fetchRequest, fetchResponse);
+    Object.defineProperty(fetchResponse, "error", {
+      value: responseError,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    return fetchResponse;
+  }
+  createRequestClass(defaults) {
+    class Request2 extends globalThis.Request {
+      static {
+        __name(this, "Request");
+      }
+      path;
+      constructor(input, rawInit) {
+        const init = { ...defaults, ...rawInit };
+        let url;
+        if (input instanceof globalThis.Request) {
+          super(
+            // Optimize type checking by narrowing the type of input
+            input,
+            init
+          );
+          url = new URL(input.url);
+        } else {
+          url = input instanceof URL ? new URL(input) : new URL(joinURL(init.baseURL, input));
+          if (init.searchParams) {
+            url.search = new http.HttpSearchParams(init.searchParams).toString();
+          }
+          super(url, init);
+        }
+        this.path = excludeNonPathParams(url).toString().replace(init.baseURL, "");
+      }
+      clone() {
+        const rawClone = super.clone();
+        return new Request2(
+          rawClone,
+          rawClone
+        );
+      }
+    }
+    return Request2;
+  }
+  isRequest(request, path, method) {
+    return request instanceof Request && request.method === method && "path" in request && typeof request.path === "string" && createRegexFromURL(path).test(request.path);
+  }
+  isResponse(response, path, method) {
+    return response instanceof Response && "request" in response && "error" in response && this.isRequest(response.request, path, method);
+  }
+  isResponseError(error, path, method) {
+    return error instanceof FetchResponseError_default && error.request.method === method && typeof error.request.path === "string" && createRegexFromURL(path).test(error.request.path);
+  }
+};
+var FetchClient_default = FetchClient;
+
+// src/client/factory.ts
+function createFetch(options) {
+  const { fetch } = new FetchClient_default(options);
+  return fetch;
+}
+__name(createFetch, "createFetch");
+var factory_default = createFetch;
+
+exports.FetchResponseError = FetchResponseError_default;
+exports.createFetch = factory_default;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/errors/FetchResponseError.ts","../src/utils/urls.ts","../src/client/FetchClient.ts","../src/client/factory.ts"],"names":["Request","HttpSearchParams"],"mappings":";;;;;;;;AAIA,IAAM,kBAAA,GAAN,cAIU,KAAM,CAAA;AAAA,EACd,WAAA,CACS,SACA,QACP,EAAA;AACA,IAAA,KAAA,CAAM,CAAG,EAAA,OAAA,CAAQ,MAAM,CAAA,CAAA,EAAI,OAAQ,CAAA,GAAG,CAAuB,oBAAA,EAAA,QAAA,CAAS,MAAM,CAAA,EAAA,EAAK,QAAS,CAAA,UAAU,CAAE,CAAA,CAAA;AAH/F,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AACA,IAAA,IAAA,CAAA,QAAA,GAAA,QAAA;AAGP,IAAA,IAAA,CAAK,IAAO,GAAA,oBAAA;AAAA;AACd,EAfF;AAQgB,IAAA,MAAA,CAAA,IAAA,EAAA,oBAAA,CAAA;AAAA;AAAA,EASd,IAAI,KAAQ,GAAA;AACV,IAAA,OAAO,IAAK,CAAA,QAAA;AAAA;AAEhB,CAAA;AAKA,IAAO,0BAAQ,GAAA;;;ACzBR,SAAS,qBAAqB,GAAU,EAAA;AAC7C,EAAA,GAAA,CAAI,IAAO,GAAA,EAAA;AACX,EAAA,GAAA,CAAI,MAAS,GAAA,EAAA;AACb,EAAA,GAAA,CAAI,QAAW,GAAA,EAAA;AACf,EAAA,GAAA,CAAI,QAAW,GAAA,EAAA;AACf,EAAO,OAAA,GAAA;AACT;AANgB,MAAA,CAAA,oBAAA,EAAA,sBAAA,CAAA;AAQhB,SAAS,mBAAmB,GAAa,EAAA;AACvC,EAAM,MAAA,UAAA,GAAa,UAAU,GAAG,CAAA;AAChC,EAAO,OAAA,UAAA,CAAW,OAAQ,CAAA,gBAAA,EAAkB,MAAM,CAAA;AACpD;AAHS,MAAA,CAAA,kBAAA,EAAA,oBAAA,CAAA;AAKT,IAAM,oBAAuB,GAAA,aAAA;AAEtB,SAAS,mBAAmB,GAAa,EAAA;AAC9C,EAAM,MAAA,yBAAA,GAA4B,kBAAmB,CAAA,GAAG,CACrD,CAAA,OAAA,CAAQ,sBAAsB,eAAe,CAAA,CAC7C,OAAQ,CAAA,QAAA,EAAU,SAAS,CAAA;AAE9B,EAAA,OAAO,IAAI,MAAA,CAAO,CAAI,CAAA,EAAA,yBAAyB,CAAG,CAAA,CAAA,CAAA;AACpD;AANgB,MAAA,CAAA,kBAAA,EAAA,oBAAA,CAAA;AAQT,SAAS,WAAW,KAAyB,EAAA;AAClD,EAAA,OAAO,KACJ,CAAA,GAAA,CAAI,CAAC,IAAA,EAAM,KAAU,KAAA;AACpB,IAAA,MAAM,cAAc,KAAU,KAAA,CAAA;AAC9B,IAAM,MAAA,UAAA,GAAa,KAAU,KAAA,KAAA,CAAM,MAAS,GAAA,CAAA;AAE5C,IAAI,IAAA,YAAA,GAAe,KAAK,QAAS,EAAA;AAEjC,IAAA,IAAI,CAAC,WAAa,EAAA;AAChB,MAAe,YAAA,GAAA,YAAA,CAAa,OAAQ,CAAA,KAAA,EAAO,EAAE,CAAA;AAAA;AAE/C,IAAA,IAAI,CAAC,UAAY,EAAA;AACf,MAAe,YAAA,GAAA,YAAA,CAAa,OAAQ,CAAA,KAAA,EAAO,EAAE,CAAA;AAAA;AAG/C,IAAO,OAAA,YAAA;AAAA,GACR,CACA,CAAA,MAAA,CAAO,CAAC,IAAA,KAAS,KAAK,MAAS,GAAA,CAAC,CAChC,CAAA,IAAA,CAAK,GAAG,CAAA;AACb;AAnBgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA;;;ACRhB,IAAM,cAAN,MAA6C;AAAA,EAf7C;AAe6C,IAAA,MAAA,CAAA,IAAA,EAAA,aAAA,CAAA;AAAA;AAAA,EAC3C,KAAA;AAAA,EAEA,YAAY,EAAE,SAAA,EAAW,UAAY,EAAA,GAAG,UAAkC,EAAA;AACxE,IAAK,IAAA,CAAA,KAAA,GAAQ,KAAK,mBAAoB,EAAA;AACtC,IAAA,IAAA,CAAK,MAAM,QAAW,GAAA,QAAA;AACtB,IAAA,IAAA,CAAK,KAAM,CAAA,OAAA,GAAU,IAAK,CAAA,kBAAA,CAAmB,QAAQ,CAAA;AACrD,IAAA,IAAA,CAAK,MAAM,SAAY,GAAA,SAAA;AACvB,IAAA,IAAA,CAAK,MAAM,UAAa,GAAA,UAAA;AAAA;AAC1B,EAEQ,mBAAsB,GAAA;AAC5B,IAAM,MAAA,KAAA,mBAIJ,MAAA,CAAA,OAAA,KAAA,EACA,IACG,KAAA;AACH,MAAA,MAAM,OAAU,GAAA,MAAM,IAAK,CAAA,kBAAA,CAAiC,OAAO,IAAI,CAAA;AACvE,MAAM,MAAA,YAAA,GAAe,QAAQ,KAAM,EAAA;AAEnC,MAAM,MAAA,WAAA,GAAc,MAAM,UAAW,CAAA,KAAA;AAAA;AAAA,QAEnC;AAAA,OACF;AACA,MAAA,MAAM,QAAW,GAAA,MAAM,IAAK,CAAA,mBAAA,CAG1B,SAAS,WAAW,CAAA;AAEtB,MAAO,OAAA,QAAA;AAAA,KAnBK,EAAA,OAAA,CAAA;AAsBd,IAAO,MAAA,CAAA,cAAA,CAAe,OAAO,IAAI,CAAA;AAEjC,IAAO,OAAA,KAAA;AAAA;AACT,EAEA,MAAc,kBAIZ,CAAA,KAAA,EACA,IACA,EAAA;AACA,IAAI,IAAA,OAAA,GAAU,iBAAiB,OAAU,GAAA,KAAA,GAAQ,IAAI,IAAK,CAAA,KAAA,CAAM,OAAQ,CAAA,KAAA,EAAO,IAAI,CAAA;AAEnF,IAAI,IAAA,IAAA,CAAK,MAAM,SAAW,EAAA;AACxB,MAAM,MAAA,uBAAA,GAA0B,MAAM,IAAA,CAAK,KAAM,CAAA,SAAA;AAAA;AAAA,QAE/C,OAAA;AAAA,QACA,IAAK,CAAA;AAAA,OACP;AAEA,MAAA,IAAI,4BAA4B,OAAS,EAAA;AACvC,QAAM,MAAA,cAAA,GAAiB,uBAAmC,YAAA,IAAA,CAAK,KAAM,CAAA,OAAA;AAErE,QAAA,OAAA,GAAU,iBACL,uBACD,GAAA,IAAI,KAAK,KAAM,CAAA,OAAA,CAAQ,yBAA6D,IAAI,CAAA;AAAA;AAC9F;AAGF,IAAO,OAAA,OAAA;AAAA;AACT,EAEA,MAAc,mBAGZ,CAAA,YAAA,EAAyE,WAAuB,EAAA;AAChG,IAAA,IAAI,QAAW,GAAA,IAAA,CAAK,6BAA4C,CAAA,YAAA,EAAc,WAAW,CAAA;AAEzF,IAAI,IAAA,IAAA,CAAK,MAAM,UAAY,EAAA;AACzB,MAAM,MAAA,wBAAA,GAA2B,MAAM,IAAA,CAAK,KAAM,CAAA,UAAA;AAAA;AAAA,QAEhD,QAAA;AAAA,QACA,IAAK,CAAA;AAAA,OACP;AAEA,MAAM,MAAA,eAAA,GACJ,oCAAoC,QACpC,IAAA,SAAA,IAAa,4BACb,wBAAyB,CAAA,OAAA,YAAmB,KAAK,KAAM,CAAA,OAAA;AAEzD,MAAA,QAAA,GAAW,eACN,GAAA,wBAAA,GACD,IAAK,CAAA,6BAAA,CAA4C,cAAc,wBAAwB,CAAA;AAAA;AAG7F,IAAO,OAAA,QAAA;AAAA;AACT,EAEQ,6BAAA,CAGN,cAAyE,QAAoB,EAAA;AAC7F,IAAA,MAAM,aAAgB,GAAA,QAAA;AAEtB,IAAO,MAAA,CAAA,cAAA,CAAe,eAAe,SAAW,EAAA;AAAA,MAC9C,KAAO,EAAA,YAAA;AAAA,MACP,QAAU,EAAA,KAAA;AAAA,MACV,UAAY,EAAA,IAAA;AAAA,MACZ,YAAc,EAAA;AAAA,KACf,CAAA;AAED,IAAA,MAAM,gBACJ,aAAc,CAAA,EAAA,GAAK,OAAO,IAAI,0BAAA,CAAmB,cAAc,aAAa,CAAA;AAG9E,IAAO,MAAA,CAAA,cAAA,CAAe,eAAe,OAAS,EAAA;AAAA,MAC5C,KAAO,EAAA,aAAA;AAAA,MACP,QAAU,EAAA,KAAA;AAAA,MACV,UAAY,EAAA,IAAA;AAAA,MACZ,YAAc,EAAA;AAAA,KACf,CAAA;AAED,IAAO,OAAA,aAAA;AAAA;AACT,EAEQ,mBAAmB,QAAqC,EAAA;AAAA,IAC9D,MAAMA,QAGI,SAAA,UAAA,CAAW,OAAQ,CAAA;AAAA,MA3IjC;AA2IiC,QAAA,MAAA,CAAA,IAAA,EAAA,SAAA,CAAA;AAAA;AAAA,MAC3B,IAAA;AAAA,MAEA,WAAA,CACE,OACA,OACA,EAAA;AACA,QAAA,MAAM,IAAO,GAAA,EAAE,GAAG,QAAA,EAAU,GAAG,OAAQ,EAAA;AAEvC,QAAI,IAAA,GAAA;AAEJ,QAAI,IAAA,KAAA,YAAiB,WAAW,OAAS,EAAA;AACvC,UAAA,KAAA;AAAA;AAAA,YAEE,KAAA;AAAA,YACA;AAAA,WACF;AAEA,UAAM,GAAA,GAAA,IAAI,GAAI,CAAA,KAAA,CAAM,GAAG,CAAA;AAAA,SAClB,MAAA;AACL,UAAA,GAAA,GAAM,KAAiB,YAAA,GAAA,GAAM,IAAI,GAAA,CAAI,KAAK,CAAA,GAAI,IAAI,GAAA,CAAI,OAAQ,CAAA,IAAA,CAAK,OAAS,EAAA,KAAK,CAAC,CAAA;AAElF,UAAA,IAAI,KAAK,YAAc,EAAA;AACrB,YAAA,GAAA,CAAI,SAAS,IAAIC,qBAAA,CAAiB,IAAK,CAAA,YAAY,EAAE,QAAS,EAAA;AAAA;AAGhE,UAAA,KAAA,CAAM,KAAK,IAAI,CAAA;AAAA;AAGjB,QAAK,IAAA,CAAA,IAAA,GAAO,qBAAqB,GAAG,CAAA,CACjC,UACA,CAAA,OAAA,CAAQ,IAAK,CAAA,OAAA,EAAS,EAAE,CAAA;AAAA;AAC7B,MAEA,KAA+B,GAAA;AAC7B,QAAM,MAAA,QAAA,GAAW,MAAM,KAAM,EAAA;AAE7B,QAAA,OAAO,IAAID,QAAAA;AAAA,UACT,QAAA;AAAA,UACA;AAAA,SAKF;AAAA;AACF;AAGF,IAAOA,OAAAA,QAAAA;AAAA;AACT,EAEA,SAAA,CACE,OACA,EAAA,IAAA,EACA,MACsE,EAAA;AACtE,IAAA,OACE,mBAAmB,OACnB,IAAA,OAAA,CAAQ,MAAW,KAAA,MAAA,IACnB,UAAU,OACV,IAAA,OAAO,OAAQ,CAAA,IAAA,KAAS,YACxB,kBAAmB,CAAA,IAAI,CAAE,CAAA,IAAA,CAAK,QAAQ,IAAI,CAAA;AAAA;AAE9C,EAEA,UAAA,CACE,QACA,EAAA,IAAA,EACA,MACwE,EAAA;AACxE,IACE,OAAA,QAAA,YAAoB,QACpB,IAAA,SAAA,IAAa,QACb,IAAA,OAAA,IAAW,QACX,IAAA,IAAA,CAAK,SAAU,CAAA,QAAA,CAAS,OAAS,EAAA,IAAA,EAAM,MAAM,CAAA;AAAA;AAEjD,EAEA,eAAA,CACE,KACA,EAAA,IAAA,EACA,MAC0E,EAAA;AAC1E,IAAA,OACE,iBAAiB,0BACjB,IAAA,KAAA,CAAM,OAAQ,CAAA,MAAA,KAAW,UACzB,OAAO,KAAA,CAAM,OAAQ,CAAA,IAAA,KAAS,YAC9B,kBAAmB,CAAA,IAAI,EAAE,IAAK,CAAA,KAAA,CAAM,QAAQ,IAAI,CAAA;AAAA;AAGtD,CAAA;AAEA,IAAO,mBAAQ,GAAA,WAAA;;;AClOf,SAAS,YACP,OACiC,EAAA;AACjC,EAAA,MAAM,EAAE,KAAA,EAAU,GAAA,IAAI,oBAAgC,OAAO,CAAA;AAC7D,EAAO,OAAA,KAAA;AACT;AALS,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA;AAOT,IAAO,eAAQ,GAAA","file":"index.js","sourcesContent":["import { HttpMethod, HttpMethodSchema } from '@zimic/http';\n\nimport { FetchRequest, FetchResponse } from '../types/requests';\n\nclass FetchResponseError<\n  Path extends string = string,\n  Method extends HttpMethod = HttpMethod,\n  MethodSchema extends HttpMethodSchema = HttpMethodSchema,\n> extends Error {\n  constructor(\n    public request: FetchRequest<Path, Method, MethodSchema>,\n    public response: FetchResponse<Path, Method, MethodSchema, true>,\n  ) {\n    super(`${request.method} ${request.url} failed with status ${response.status}: ${response.statusText}`);\n    this.name = 'FetchResponseError';\n  }\n\n  get cause() {\n    return this.response;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFetchRequestError = FetchResponseError<any, any, any>;\n\nexport default FetchResponseError;\n","export function excludeNonPathParams(url: URL) {\n  url.hash = '';\n  url.search = '';\n  url.username = '';\n  url.password = '';\n  return url;\n}\n\nfunction prepareURLForRegex(url: string) {\n  const encodedURL = encodeURI(url);\n  return encodedURL.replace(/([.()*?+$\\\\])/g, '\\\\$1');\n}\n\nconst URL_PATH_PARAM_REGEX = /\\/:([^/]+)/g;\n\nexport function createRegexFromURL(url: string) {\n  const urlWithReplacedPathParams = prepareURLForRegex(url)\n    .replace(URL_PATH_PARAM_REGEX, '/(?<$1>[^/]+)')\n    .replace(/(\\/+)$/, '(?:/+)?');\n\n  return new RegExp(`^${urlWithReplacedPathParams}$`);\n}\n\nexport function joinURL(...parts: (string | URL)[]) {\n  return parts\n    .map((part, index) => {\n      const isFirstPart = index === 0;\n      const isLastPart = index === parts.length - 1;\n\n      let partAsString = part.toString();\n\n      if (!isFirstPart) {\n        partAsString = partAsString.replace(/^\\//, '');\n      }\n      if (!isLastPart) {\n        partAsString = partAsString.replace(/\\/$/, '');\n      }\n\n      return partAsString;\n    })\n    .filter((part) => part.length > 0)\n    .join('/');\n}\n","import {\n  HttpSchemaPath,\n  HttpSchemaMethod,\n  HttpSearchParams,\n  LiteralHttpSchemaPathFromNonLiteral,\n  HttpSchema,\n} from '@zimic/http';\n\nimport { Default } from '@/types/utils';\nimport { createRegexFromURL, excludeNonPathParams, joinURL } from '@/utils/urls';\n\nimport FetchResponseError from './errors/FetchResponseError';\nimport { FetchInput, FetchOptions, Fetch } from './types/public';\nimport { FetchRequestConstructor, FetchRequestInit, FetchRequest, FetchResponse } from './types/requests';\n\nclass FetchClient<Schema extends HttpSchema> {\n  fetch: Fetch<Schema>;\n\n  constructor({ onRequest, onResponse, ...defaults }: FetchOptions<Schema>) {\n    this.fetch = this.createFetchFunction();\n    this.fetch.defaults = defaults;\n    this.fetch.Request = this.createRequestClass(defaults);\n    this.fetch.onRequest = onRequest;\n    this.fetch.onResponse = onResponse;\n  }\n\n  private createFetchFunction() {\n    const fetch = async <\n      Path extends HttpSchemaPath.NonLiteral<Schema, Method>,\n      Method extends HttpSchemaMethod<Schema>,\n    >(\n      input: FetchInput<Schema, Path, Method>,\n      init: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>,\n    ) => {\n      const request = await this.createFetchRequest<Path, Method>(input, init);\n      const requestClone = request.clone();\n\n      const rawResponse = await globalThis.fetch(\n        // Optimize type checking by narrowing the type of request\n        requestClone as Request,\n      );\n      const response = await this.createFetchResponse<\n        LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>,\n        Method\n      >(request, rawResponse);\n\n      return response;\n    };\n\n    Object.setPrototypeOf(fetch, this);\n\n    return fetch as Fetch<Schema>;\n  }\n\n  private async createFetchRequest<\n    Path extends HttpSchemaPath.NonLiteral<Schema, Method>,\n    Method extends HttpSchemaMethod<Schema>,\n  >(\n    input: FetchInput<Schema, Path, Method>,\n    init: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>,\n  ) {\n    let request = input instanceof Request ? input : new this.fetch.Request(input, init);\n\n    if (this.fetch.onRequest) {\n      const requestAfterInterceptor = await this.fetch.onRequest(\n        // Optimize type checking by narrowing the type of request\n        request as FetchRequest.Loose,\n        this.fetch,\n      );\n\n      if (requestAfterInterceptor !== request) {\n        const isFetchRequest = requestAfterInterceptor instanceof this.fetch.Request;\n\n        request = isFetchRequest\n          ? (requestAfterInterceptor as Request as typeof request)\n          : new this.fetch.Request(requestAfterInterceptor as FetchInput<Schema, Path, Method>, init);\n      }\n    }\n\n    return request;\n  }\n\n  private async createFetchResponse<\n    Path extends HttpSchemaPath<Schema, Method>,\n    Method extends HttpSchemaMethod<Schema>,\n  >(fetchRequest: FetchRequest<Path, Method, Default<Schema[Path][Method]>>, rawResponse: Response) {\n    let response = this.defineFetchResponseProperties<Path, Method>(fetchRequest, rawResponse);\n\n    if (this.fetch.onResponse) {\n      const responseAfterInterceptor = await this.fetch.onResponse(\n        // Optimize type checking by narrowing the type of response\n        response as FetchResponse.Loose,\n        this.fetch,\n      );\n\n      const isFetchResponse =\n        responseAfterInterceptor instanceof Response &&\n        'request' in responseAfterInterceptor &&\n        responseAfterInterceptor.request instanceof this.fetch.Request;\n\n      response = isFetchResponse\n        ? (responseAfterInterceptor as typeof response)\n        : this.defineFetchResponseProperties<Path, Method>(fetchRequest, responseAfterInterceptor);\n    }\n\n    return response;\n  }\n\n  private defineFetchResponseProperties<\n    Path extends HttpSchemaPath<Schema, Method>,\n    Method extends HttpSchemaMethod<Schema>,\n  >(fetchRequest: FetchRequest<Path, Method, Default<Schema[Path][Method]>>, response: Response) {\n    const fetchResponse = response as FetchResponse<Path, Method, Default<Schema[Path][Method]>>;\n\n    Object.defineProperty(fetchResponse, 'request', {\n      value: fetchRequest satisfies FetchResponse.Loose['request'],\n      writable: false,\n      enumerable: true,\n      configurable: false,\n    });\n\n    const responseError = (\n      fetchResponse.ok ? null : new FetchResponseError(fetchRequest, fetchResponse)\n    ) satisfies FetchResponse.Loose['error'];\n\n    Object.defineProperty(fetchResponse, 'error', {\n      value: responseError,\n      writable: false,\n      enumerable: true,\n      configurable: false,\n    });\n\n    return fetchResponse;\n  }\n\n  private createRequestClass(defaults: FetchRequestInit.Defaults) {\n    class Request<\n      Path extends HttpSchemaPath.NonLiteral<Schema, Method>,\n      Method extends HttpSchemaMethod<Schema>,\n    > extends globalThis.Request {\n      path: LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>;\n\n      constructor(\n        input: FetchInput<Schema, Path, Method>,\n        rawInit: FetchRequestInit<Schema, LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>, Method>,\n      ) {\n        const init = { ...defaults, ...rawInit };\n\n        let url: URL;\n\n        if (input instanceof globalThis.Request) {\n          super(\n            // Optimize type checking by narrowing the type of input\n            input as globalThis.Request,\n            init,\n          );\n\n          url = new URL(input.url);\n        } else {\n          url = input instanceof URL ? new URL(input) : new URL(joinURL(init.baseURL, input));\n\n          if (init.searchParams) {\n            url.search = new HttpSearchParams(init.searchParams).toString();\n          }\n\n          super(url, init);\n        }\n\n        this.path = excludeNonPathParams(url)\n          .toString()\n          .replace(init.baseURL, '') as LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>;\n      }\n\n      clone(): Request<Path, Method> {\n        const rawClone = super.clone();\n\n        return new Request<Path, Method>(\n          rawClone as unknown as FetchInput<Schema, Path, Method>,\n          rawClone as unknown as FetchRequestInit<\n            Schema,\n            LiteralHttpSchemaPathFromNonLiteral<Schema, Method, Path>,\n            Method\n          >,\n        );\n      }\n    }\n\n    return Request as FetchRequestConstructor<Schema>;\n  }\n\n  isRequest<Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(\n    request: unknown,\n    path: Path,\n    method: Method,\n  ): request is FetchRequest<Path, Method, Default<Schema[Path][Method]>> {\n    return (\n      request instanceof Request &&\n      request.method === method &&\n      'path' in request &&\n      typeof request.path === 'string' &&\n      createRegexFromURL(path).test(request.path)\n    );\n  }\n\n  isResponse<Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(\n    response: unknown,\n    path: Path,\n    method: Method,\n  ): response is FetchResponse<Path, Method, Default<Schema[Path][Method]>> {\n    return (\n      response instanceof Response &&\n      'request' in response &&\n      'error' in response &&\n      this.isRequest(response.request, path, method)\n    );\n  }\n\n  isResponseError<Path extends HttpSchemaPath<Schema, Method>, Method extends HttpSchemaMethod<Schema>>(\n    error: unknown,\n    path: Path,\n    method: Method,\n  ): error is FetchResponseError<Path, Method, Default<Schema[Path][Method]>> {\n    return (\n      error instanceof FetchResponseError &&\n      error.request.method === method &&\n      typeof error.request.path === 'string' &&\n      createRegexFromURL(path).test(error.request.path)\n    );\n  }\n}\n\nexport default FetchClient;\n","import { HttpSchema } from '@zimic/http';\n\nimport FetchClient from './FetchClient';\nimport { FetchOptions, Fetch as PublicFetch } from './types/public';\n\nfunction createFetch<Schema extends HttpSchema>(\n  options: FetchOptions<HttpSchema<Schema>>,\n): PublicFetch<HttpSchema<Schema>> {\n  const { fetch } = new FetchClient<HttpSchema<Schema>>(options);\n  return fetch;\n}\n\nexport default createFetch;\n"]}