@unshared/client 0.2.0

package/dist/chunks/B0duX_ls.d.ts

@@ -0,0 +1,204 @@
+import { MaybeArray, MaybeLiteral, Override } from '@unshared/types';
+import { H as HttpHeader } from './8BFCFxqa.js';
+
+declare enum HttpMethod {
+    /**
+     * The **`CONNECT`** HTTP method requests that a [proxy](https://developer.mozilla.org/en-US/docs/Glossary/Proxy_server) establish a HTTP tunnel to a destination server, and if successful, blindly forward data in both directions until the tunnel is closed.
+     *
+     * The request target is unique to this method in that it consists of only the host and port number of the tunnel destination, separated by a colon (see [Syntax](#syntax) for details).
+     * Any [2XX successful response status code](/en-US/docs/Web/HTTP/Status#successful_responses) means that the proxy will switch to 'tunnel mode' and any data in the success response body is from the server identified by the request target.
+     *
+     * If a website is behind a proxy and it's enforced via network rules that all external traffic must pass through the proxy, the `CONNECT` method allows you to establish a [TLS](https://developer.mozilla.org/en-US/docs/Glossary/TLS) ([HTTPS](https://developer.mozilla.org/en-US/docs/Glossary/HTTPS)) connection with that website:
+     *
+     * - The client asks the proxy to tunnel the [TCP](https://developer.mozilla.org/en-US/docs/Glossary/TCP) connection to the desired destination.
+     * - The proxy server makes a secure connection to the server on behalf of the client.
+     * - Once the connection is established, the proxy server continues to relay the TCP stream to and from the client.
+     *
+     * Aside from enabling secure access to websites behind proxies, a HTTP tunnel provides a way to allow traffic that would otherwise be restricted (SSH or FTP) over the HTTP(S) protocol.
+     *
+     * `CONNECT` is a hop-by-hop method, meaning proxies will only forward the `CONNECT` request if there is another inbound proxy in front of the origin server since most origin servers do not implement `CONNECT`.
+     *
+     * > [!WARNING]
+     * > If you are running a proxy that supports `CONNECT`, restrict its use to a set of known ports or a configurable list of safe request targets.
+     * > There are significant risks in establishing a tunnel to arbitrary servers, particularly when the destination is a well-known or reserved TCP port that is not intended for Web traffic.
+     * > A loosely-configured proxy may be abused to forward traffic such as SMTP to relay spam email, for example.
+     */
+    CONNECT = "CONNECT",
+    /**
+     * The **`DELETE`** HTTP method asks the server to delete a specified resource.
+     *
+     * The `DELETE` method has no defined semantics for the message body, so this should be empty.
+     */
+    DELETE = "DELETE",
+    /**
+     * The **`GET`** HTTP method requests a representation of the specified resource.
+     * Requests using `GET` should only be used to request data and shouldn't contain a body.
+     *
+     * > [!NOTE]
+     * > The semantics of sending a message body in `GET` requests are undefined.
+     * > Some servers may reject the request with a [4XX client error](/en-US/docs/Web/HTTP/Status#client_error_responses) response.
+     */
+    GET = "GET",
+    /**
+     * The **`HEAD`** HTTP method requests the metadata of a resource in the form of [headers](/en-US/docs/Web/HTTP/Headers) that the server would have sent if the [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/GET) method was used instead.
+     * This method can be used in cases where a URL might produce a large download, for example, a `HEAD` request can read the [Content-Length](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length) header to check the file size before downloading the file with a `GET`.
+     *
+     * If the response to a `HEAD` request shows that a cached URL response is now outdated, the cached copy is invalidated even if no `GET` request was made.
+     *
+     * > [!WARNING]
+     * > If a response to a `HEAD` request has a body, the response body must be ignored.
+     * > Any [representation headers](https://developer.mozilla.org/en-US/docs/glossary/Representation_header) that describe the erroneous body are assumed to describe the response body that a `GET` request would have received.
+     */
+    HEAD = "HEAD",
+    /**
+     * The **`OPTIONS`** HTTP method requests permitted communication options for a given URL or server.
+     * This can be used to test the allowed HTTP methods for a request, or to determine whether a request would succeed when making a CORS preflighted request.
+     * A client can specify a URL with this method, or an asterisk (`*`) to refer to the entire server.
+     */
+    OPTIONS = "OPTIONS",
+    /**
+     * The **`PATCH`** HTTP method applies partial modifications to a resource.
+     *
+     * `PATCH` is somewhat analogous to the "update" concept found in [CRUD](https://developer.mozilla.org/en-US/docs/Glossary/CRUD) (in general, HTTP is different than [CRUD](https://developer.mozilla.org/en-US/docs/Glossary/CRUD), and the two should not be confused).
+     *
+     * In comparison with [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/PUT), a `PATCH` serves as a set of instructions for modifying a resource, whereas `PUT` represents a complete replacement of the resource.
+     * A `PUT` request is always [idempotent](https://developer.mozilla.org/en-US/docs/Glossary/idempotent) (repeating the same request multiple times results in the resource remaining in the same state), whereas a `PATCH` request may not always be idempotent.
+     * For instance, if a resource includes an auto-incrementing counter, a `PUT` request will overwrite the counter (since it replaces the entire resource), but a `PATCH` request may not.
+     *
+     * Like [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/POST), a `PATCH` request can potentially have side effects on other resources.
+     *
+     * A server can advertise support for `PATCH` by adding it to the list in the [Allow](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Allow) or [Access-Control-Allow-Methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods) (for [CORS](/en-US/docs/Web/HTTP/CORS)) response headers.
+     * Another implicit indication that `PATCH` is supported is the [Accept-Patch](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Patch) header (usually after an [OPTIONS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/OPTIONS) request on a resource), which lists the media-types the server is able to understand in a `PATCH` request for a resource.
+     */
+    PATCH = "PATCH",
+    /**
+     * The **`POST`** HTTP method sends data to the server. The type of the body of the request is indicated by the [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) header.
+     *
+     * The difference between [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/PUT) and `POST` is that `PUT` is [idempotent](https://developer.mozilla.org/en-US/docs/Glossary/idempotent): calling it once is no different from calling it several times successively (there are no _side_ effects).
+     * Successive identical `POST` requests may have additional effects, such as creating the same order several times.
+     *
+     * [HTML forms](/en-US/docs/Learn/Forms) typically send data using `POST` and this usually results in a change on the server.
+     * For HTML forms the format/encoding of the body content is determined by the [`enctype`](/en-US/docs/Web/HTML/Element/form#enctype) attribute of the [form](https://developer.mozilla.org/en-US/docs/HTMLElement/form) element or the [`formenctype`](/en-US/docs/Web/HTML/Element/input#formenctype) attribute of the [input") }} or _or_{{HTMLElement("button) elements.
+     * The encoding may be one of the following:
+     *
+     * - `application/x-www-form-urlencoded`: the keys and values are encoded in key-value tuples separated by an ampersand (`&`), with an equals symbol (`=`) between the key and the value (e.g., `first-name=Frida&last-name=Kahlo`).
+     * Non-alphanumeric characters in both keys and values are [percent-encoded](https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding): this is the reason why this type is not suitable to use with binary data and you should use `multipart/form-data` for this purpose instead.
+     * - `multipart/form-data`: each value is sent as a block of data ("body part"), with a user agent-defined delimiter (for example, `boundary="delimiter12345"`) separating each part.
+     * The keys are described in the [Content-Disposition](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) header of each part or block of data.
+     * - `text/plain`
+     *
+     * When the `POST` request is sent following a [fetch()](https://developer.mozilla.org/en-US/docs/domxref/Window/fetch) call, or for any other reason than an HTML form, the body can be any type.
+     * As described in the HTTP 1.1 specification, `POST` is designed to allow a uniform method to cover the following functions:
+     *
+     * - Annotation of existing resources
+     * - Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles
+     * - Adding a new user through a signup form
+     * - Providing a block of data, such as the result of submitting a form, to a data-handling process
+     * - Extending a database through an append operation
+     */
+    POST = "POST",
+    /**
+     * The **`PUT`** HTTP method creates a new resource or replaces a representation of the target resource with the request [content](https://developer.mozilla.org/en-US/docs/Glossary/HTTP_Content).
+     *
+     * The difference between `PUT` and [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Method/POST) is that `PUT` is [idempotent](https://developer.mozilla.org/en-US/docs/Glossary/idempotent): calling it once is no different from calling it several times successively (there are no _side_ effects).
+     */
+    PUT = "PUT",
+    /**
+     * The **`TRACE`** HTTP method performs a message loop-back test along the path to the target resource.
+     *
+     * The final recipient of the request should reflect the message as received (excluding any fields that might include sensitive data) back to the client as the message body of a [200 OK](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/200) response with a [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) of `message/http`.
+     * The final recipient is either the origin server or the first server to receive a [Max-Forwards](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Max-Forwards) value of `0` in the request.
+     *
+     * The client must not send [content](https://developer.mozilla.org/en-US/docs/Glossary/HTTP_Content) in the request, or generate headers that might include sensitive data such as user credentials or cookies.
+     * Not all servers implement the `TRACE` method, and some server owners have historically disallowed the use of the `TRACE` method due to security concerns.
+     * In such cases, a [405 Method Not Allowed](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405) [client error response](/en-US/docs/Web/HTTP/Status#client_error_responses) will be sent.
+     */
+    TRACE = "TRACE"
+}
+
+/** An object that can be converted to a query string. */
+type SearchParamsObject = Record<string, MaybeArray<boolean | number | string> | undefined>;
+/** The search array format options. */
+type SearchArrayFormat = 'brackets' | 'comma' | 'flat' | 'indices' | 'path';
+/** Options for the query string conversion. */
+interface ToSearchParamsOptions {
+    /**
+     * Defines how to handle arrays in the object. There is no standard way to
+     * represent arrays in query strings, so this option allows you to choose
+     * how to handle them. Additionally, you can provide a custom function to
+     * handle it yourself.
+     *
+     * - `brackets` (default): Convert arrays to `key[]=value&key[]=value` format.
+     * - `indices`: Convert arrays to `key[0]=value&key[1]=value` format.
+     * - `comma`: Convert arrays to `key=value1,value2` format.
+     * - `path`: Convert arrays to `key.0=value&key.1=value` format.
+     * - `flat`: Convert arrays to `key=value1&key=value2` format.
+     *
+     * @default 'flat'
+     */
+    searchArrayFormat?: SearchArrayFormat;
+}
+/**
+ * Convert object to query string parameters. Converting all values to strings
+ * and arrays to `key[0]=value&key[1]=value` format.
+ *
+ * @param object The object to convert to a query string.
+ * @param options The query string options.
+ * @returns The `URLSearchParams` object.
+ */
+declare function toSearchParams(object: SearchParamsObject, options?: ToSearchParamsOptions): URLSearchParams;
+
+/** Headers to include in the request. */
+type RequestHeaders = Partial<Record<MaybeLiteral<HttpHeader>, string>>;
+type RequestOptions = Override<RequestInit, {
+    /**
+     * The method to use for the request.
+     *
+     * @example 'GET'
+     */
+    method?: Lowercase<keyof typeof HttpMethod> | Uppercase<keyof typeof HttpMethod>;
+    /**
+     * The base URL to use for the request. This URL will be used to resolve the
+     * path and query parameters of the request.
+     *
+     * @example 'https://api.example.com'
+     */
+    baseUrl?: string;
+    /**
+     * The data to pass to the request. This data will be used to fill the path
+     * parameters, query parameters, body, and form data of the request based on
+     * the route method.
+     */
+    data?: Blob | File | FileList | FormData | ReadableStream | Record<string, unknown> | string;
+    /**
+     * The headers to include in the request.
+     */
+    headers?: RequestHeaders;
+    /**
+     * Query parameters to include in the request.
+     */
+    query?: SearchParamsObject;
+    /**
+     * The format to use when serializing the query parameters.
+     */
+    searchArrayFormat?: SearchArrayFormat;
+    /**
+     * The path parameters to include in the request.
+     */
+    parameters?: Record<string, number | string>;
+}>;
+interface RequestContext {
+    url?: URL;
+    init: RequestInit;
+}
+/**
+ * Resolves the request body and/or query parameters based on the method type. This function
+ * will mutate the `init` object to include the request body and headers based on the data type.
+ *
+ * @param route The name of the route to fetch.
+ * @param options The options to pass to the request.
+ * @returns The URL and the `RequestInit` object.
+ */
+declare function parseRequest(route: string, options?: RequestOptions): RequestContext;
+
+export { HttpMethod as H, type RequestHeaders as R, type SearchParamsObject as S, type ToSearchParamsOptions as T, type RequestOptions as a, type RequestContext as b, type SearchArrayFormat as c, parseRequest as p, toSearchParams as t };

package/dist/chunks/BIx2AaJH.d.ts

@@ -0,0 +1,188 @@
+import { MaybeArray, Pretty, UnionMerge, Override, CollectKey, StringSplit, LooseDeep } from '@unshared/types';
+import { H as HttpHeader } from './8BFCFxqa.js';
+
+declare namespace OpenAPIV2 {
+    type ServerUrl<T> = T extends {
+        host: infer Host extends string;
+        basePath?: infer BasePath extends string;
+        schemes?: Array<infer Scheme extends string>;
+    } ? `${Scheme}://${Host}${BasePath}` : string;
+    /*************************************************************************/
+    /*************************************************************************/
+    type InferSchemaObject<T> = T extends {
+        properties: infer P extends Record<string, any>;
+        required: Array<infer R extends string>;
+    } ? ({
+        [K in keyof P as K extends R ? K : never]: InferSchema<P[K]>;
+    } & {
+        [K in keyof P as K extends R ? never : K]?: InferSchema<P[K]>;
+    }) : T extends {
+        properties: infer P extends Record<string, any>;
+    } ? {
+        [K in keyof P]?: InferSchema<P[K]>;
+    } : Record<string, unknown>;
+    type InferSchemaArray<T> = T extends {
+        items: MaybeArray<infer U>;
+        additionalItems: MaybeArray<infer V>;
+    } ? Array<InferSchema<U | V>> : T extends {
+        items: MaybeArray<infer U>;
+    } ? Array<InferSchema<U>> : T extends {
+        additionalItems: MaybeArray<infer U>;
+    } ? Array<InferSchema<U>> : unknown[];
+    type InferSchema<T> = Pretty<(T extends {
+        anyOf: Array<infer U>;
+    } ? InferSchema<U> : T extends {
+        oneOf: Array<infer U>;
+    } ? InferSchema<U> : T extends {
+        allOf: Array<infer U>;
+    } ? UnionMerge<InferSchema<U>> : T extends {
+        schema: infer U;
+    } ? InferSchema<U> : T extends {
+        type: 'array';
+    } ? InferSchemaArray<T> : T extends {
+        type: 'object';
+    } ? InferSchemaObject<T> : T extends {
+        type: 'string';
+    } ? T extends {
+        enum: Array<infer U>;
+    } ? U : string : T extends {
+        type: 'integer' | 'number';
+    } ? number : T extends {
+        type: 'boolean';
+    } ? boolean : never) | (T extends {
+        nullable: true;
+    } ? undefined : never)>;
+    /*************************************************************************/
+    /*************************************************************************/
+    type Parameters<T, I extends string> = UnionMerge<T extends {
+        parameters: Array<infer U>;
+    } ? U extends {
+        in: I;
+        name: infer N extends string;
+    } ? Record<N, InferSchema<U> | (U extends {
+        required: true;
+    } ? never : undefined)> : never : never>;
+    type RequestBody<T> = Parameters<T, 'body'> extends Record<string, infer U> ? U : never;
+    type RequestHeaders<T> = UnionMerge<Parameters<T, 'header'> | Partial<Record<HttpHeader, string | undefined>> | (T extends {
+        consumes: Array<infer C>;
+    } ? {
+        'Content-Type'?: C;
+    } : never)>;
+    type RequestData<T> = Pretty<NonNullable<Parameters<T, 'path'>> & NonNullable<Parameters<T, 'query'>> & NonNullable<RequestBody<T>>>;
+    type RequestInit<T> = Pretty<Override<globalThis.RequestInit, {
+        body?: RequestBody<T>;
+        query?: Parameters<T, 'query'>;
+        headers?: RequestHeaders<T>;
+        parameters?: Parameters<T, 'path'>;
+        data?: RequestData<T>;
+    }>>;
+    /*************************************************************************/
+    /*************************************************************************/
+    type ResponseBody<T> = T extends {
+        responses: Record<200, {
+            schema: infer S;
+        }>;
+    } ? InferSchema<S> : never;
+    type Response<T> = T extends {
+        responses: infer R;
+    } ? ({
+        [P in keyof R]: Override<globalThis.Response, {
+            status: P extends 'default' ? number : P;
+            json: InferSchema<R[P]> extends infer V ? [never] extends V ? never : () => Promise<V> : never;
+        }>;
+    }) extends infer Result ? Result[keyof Result] : never : never;
+    /*************************************************************************/
+    /*************************************************************************/
+    type OperationId<T> = T extends {
+        paths: infer P;
+    } ? P extends Record<string, infer R> ? R extends Record<string, infer O> ? O extends {
+        operationId: infer N;
+    } ? N : string : string : string : string;
+    type Route<T> = T extends {
+        paths: infer P;
+    } ? CollectKey<P> extends Record<string, infer R> ? CollectKey<R> extends Record<string, infer O> ? O extends {
+        $key: [infer P extends string, infer M extends string];
+    } ? `${Uppercase<M>} ${P}` : string : string : string : string;
+    type OperationById<T, U extends OperationId<T>> = T extends {
+        paths: infer P;
+    } ? CollectKey<P> extends Record<string, infer R> ? CollectKey<R> extends Record<string, infer O> ? O extends {
+        $key: [infer P extends string, infer M extends string];
+        operationId: U;
+    } ? Pretty<{
+        method: M;
+        path: P;
+    } & Omit<O, '$key'>> : never : never : never : never;
+    type OperationByRoute<T, U extends Route<T>> = StringSplit<U, ' '> extends [infer M extends string, infer P extends string] ? T extends {
+        paths: infer U;
+    } ? U extends Record<P, infer R> ? R extends Record<Lowercase<M>, infer O> ? Pretty<{
+        method: Lowercase<M>;
+        path: P;
+    } & O> : never : never : never : never;
+}
+
+declare namespace OpenAPIV3 {
+    type ServerUrl<T> = T extends {
+        servers: Array<{
+            url: infer U extends string;
+        }>;
+    } ? U : string;
+    type ServerHeaders<T> = T extends {
+        servers: Array<{
+            variables: infer V;
+        }>;
+    } ? V extends {
+        [K in keyof V]: {
+            enum: Array<infer U>;
+        };
+    } ? {
+        [K in keyof V]: U;
+    } : string : never;
+    type ServerQuery<T> = T extends {
+        components: {
+            securitySchemes: {
+                api_key: {
+                    in: 'query';
+                    name: infer U extends string;
+                };
+            };
+        };
+    } ? Partial<Record<U, string>> : never;
+    /*************************************************************************/
+    /*************************************************************************/
+    type RequestBody<T> = T extends {
+        requestBody: {
+            content: infer C;
+        };
+    } ? C extends Record<string, {
+        schema: infer S;
+    }> ? OpenAPIV2.InferSchema<S> : object : object;
+    type RequestData<T, U> = Pretty<OpenAPIV2.Parameters<U, 'path'> & OpenAPIV2.Parameters<U, 'query'> & RequestBody<U> & ServerQuery<T>>;
+    type RequestInit<T, U> = Pretty<Override<globalThis.RequestInit, {
+        body?: RequestBody<U>;
+        query?: OpenAPIV2.Parameters<U, 'query'> & ServerQuery<T>;
+        headers?: OpenAPIV2.RequestHeaders<U>;
+        parameters?: OpenAPIV2.Parameters<U, 'path'>;
+        data?: LooseDeep<RequestData<T, U>>;
+    }>>;
+    /*************************************************************************/
+    /*************************************************************************/
+    type ResponseBody<U> = U extends {
+        responses: Record<200, {
+            content: Record<string, {
+                schema: infer Schema;
+            }>;
+        }>;
+    } ? OpenAPIV2.InferSchema<Schema> : never;
+    type Response<U> = U extends {
+        responses: infer Responses;
+    } ? ({
+        [Status in keyof Responses]: Responses[Status] extends {
+            content: Record<'application/json', infer Schema>;
+        } ? Pretty<Override<globalThis.Response, {
+            status: Status;
+            json: OpenAPIV2.InferSchema<Schema> extends infer V ? [never] extends V ? never : () => Promise<V> : never;
+        }>> : never;
+    }) extends infer Result ? Result[keyof Result] : never : never;
+}
+
+export { OpenAPIV2 as O, OpenAPIV3 as a };

package/dist/chunks/BzqHK4CV.cjs

@@ -0,0 +1,71 @@
+"use strict";
+const methods = ["get", "put", "post", "delete", "options", "head", "patch"];
+function getOperationById(specification, operationId) {
+  if (!specification || typeof specification != "object" || specification === null || !("paths" in specification) || typeof specification.paths != "object" || specification.paths === null)
+    throw new Error("Missing paths object in the OpenAPI specification.");
+  const paths = specification.paths;
+  for (const path in paths) {
+    const route = paths[path];
+    if (!(typeof route != "object" || route === null))
+      for (const method of methods) {
+        const operation = route[method];
+        if (!(!(method in route) || typeof operation != "object" || operation === null || !("operationId" in operation) || operation.operationId !== operationId))
+          return { ...route[method], method, path };
+      }
+  }
+  throw new Error(`Operation "${operationId}" not found in specification.`);
+}
+function getBaseUrl(specification) {
+  if ("servers" in specification && Array.isArray(specification.servers) && specification.servers.length > 0)
+    return specification.servers[0].url;
+  if ("host" in specification && typeof specification.host == "string") {
+    const scheme = specification.schemes && specification.schemes.length > 0 ? specification.schemes[0] : "https", basePath = specification.basePath && typeof specification.basePath == "string" ? specification.basePath : "/";
+    return `${scheme}://${specification.host}${basePath}`;
+  }
+  throw new Error("No base URL found in the OpenAPI specification.");
+}
+function getOperationByRoute(specification, name) {
+  if (!specification || typeof specification != "object" || specification === null || !("paths" in specification) || typeof specification.paths != "object" || specification.paths === null)
+    throw new Error("Missing paths object in the OpenAPI specification.");
+  const match = /^(get|post|put|patch|delete|head|options) (\/.+)$/i.exec(name);
+  if (!match) throw new Error("Could not resolve the path and method from the route name.");
+  const [, routeMethod, routePath] = match, method = routeMethod.toLowerCase(), path = specification.paths[routePath];
+  if (!path) throw new Error(`Route "${name}" not found in specification.`);
+  if (typeof path != "object" || path === null) throw new Error("Invalid path object in the OpenAPI specification.");
+  if (!(method in path)) throw new Error(`Method "${method}" not found in path "${routePath}".`);
+  return { ...path[method], method, path: routePath };
+}
+function isReferenceObject(value) {
+  return typeof value == "object" && value !== null && "$ref" in value && typeof value.$ref == "string";
+}
+function resolveReference(reference, document) {
+  if (!isReferenceObject(reference))
+    throw new TypeError("Expected value to be an OpenAPI reference object.");
+  if (typeof document != "object" || document === null)
+    throw new TypeError("Expected OpenAPI specification to be an object.");
+  const referenceParts = reference.$ref.replace(/^#\//, "").split("/");
+  let result = document;
+  for (const part of referenceParts) {
+    if (result === void 0 || typeof result != "object" || result === null) break;
+    const key = part.replaceAll("~1", "/").replaceAll("~0", "~");
+    result = result[key];
+  }
+  if (result === void 0)
+    throw new Error(`Could not resolve OpenAPI component: ${reference.$ref}`);
+  return result;
+}
+function resolveDocument(value, document = value) {
+  return new Proxy(value, {
+    get(target, property) {
+      let value2 = target[property];
+      return document ? (isReferenceObject(value2) && (value2 = resolveReference(value2, document)), typeof value2 == "object" && value2 !== null ? resolveDocument(value2, document) : value2) : value2;
+    }
+  });
+}
+exports.getBaseUrl = getBaseUrl;
+exports.getOperationById = getOperationById;
+exports.getOperationByRoute = getOperationByRoute;
+exports.isReferenceObject = isReferenceObject;
+exports.resolveDocument = resolveDocument;
+exports.resolveReference = resolveReference;
+//# sourceMappingURL=BzqHK4CV.cjs.map

package/dist/chunks/BzqHK4CV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BzqHK4CV.cjs","sources":["../../openapi/getOperationById.ts","../../openapi/getBaseUrl.ts","../../openapi/getOperationByRoute.ts","../../openapi/isReferenceObject.ts","../../openapi/resolveReference.ts","../../openapi/resolveDocument.ts"],"sourcesContent":["import type { OpenAPI } from 'openapi-types'\nimport type { OpenAPIV2 } from './OpenApiV2'\n\n/** The HTTP methods supported by OpenAPI. */\nconst methods = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch'] as const\n\n/**\n * Given an OpenAPI specification, find an operation by its operationId.\n *\n * @param specification The OpenAPI specification.\n * @param operationId The operationId of the operation to resolve.\n * @returns The resolved operation.\n * @example openapiGetOperation(specification, 'getUser') // { method: 'get', path: '/users/{username}', ... }\n */\nexport function getOperationById<T, U extends OpenAPIV2.OperationId<T>>(\n  specification: T,\n  operationId: U,\n): OpenAPIV2.OperationById<T, U> {\n\n  // --- Validate the specification.\n  if (!specification\n    || typeof specification !== 'object'\n    || specification === null\n    || 'paths' in specification === false\n    || typeof specification.paths !== 'object'\n    || specification.paths === null)\n    throw new Error('Missing paths object in the OpenAPI specification.')\n\n  // --- Search for the operation in the specification's paths.\n  const paths = specification.paths as OpenAPI.Document['paths']\n  for (const path in paths) {\n    const route = paths[path]\n    if (typeof route !== 'object' || route === null) continue\n\n    // --- Search in each method for the operation.\n    for (const method of methods) {\n      const operation = route[method]\n      if (method in route === false\n        || typeof operation !== 'object'\n        || operation === null\n        || 'operationId' in operation === false\n        || operation.operationId !== operationId) continue\n\n      // --- Route was found, return the operation.\n      return { ...route[method], method, path } as OpenAPIV2.OperationById<T, U>\n    }\n  }\n\n  // --- Throw an error if the operation was not found.\n  throw new Error(`Operation \"${operationId}\" not found in specification.`)\n}\n","import type { OpenAPI } from 'openapi-types'\n\n/**\n * Given an OpenAPI specification, get the first base URL.\n *\n * @param specification The OpenAPI specification.\n * @returns The first base URL.\n * @example getBaseUrl(specification) // 'https://api.example.com/v1'\n */\nexport function getBaseUrl(specification: OpenAPI.Document): string {\n\n  // --- Handle OpenAPI 3.0 specifications.\n  if ('servers' in specification && Array.isArray(specification.servers) && specification.servers.length > 0)\n    return specification.servers[0].url\n\n  // --- Handle OpenAPI 2.0 specifications.\n  if ('host' in specification && typeof specification.host === 'string') {\n    const scheme = specification.schemes && specification.schemes.length > 0 ? specification.schemes[0] : 'https'\n    const basePath = specification.basePath && typeof specification.basePath === 'string' ? specification.basePath : '/'\n    return `${scheme}://${specification.host}${basePath}`\n  }\n\n  throw new Error('No base URL found in the OpenAPI specification.')\n}\n","import type { OpenAPI } from 'openapi-types'\nimport type { OpenAPIV2 } from './OpenApiV2'\n\n/**\n * Given an OpenAPI specification, find a route by its name.\n *\n * @param specification The OpenAPI specification.\n * @param name The name of the route to resolve.\n * @returns The resolved route.\n * @example getOperationByRoute(specification, 'GET /users') // { method: 'get', path: '/users', ... }\n */\nexport function getOperationByRoute<\n  T extends object,\n  U extends OpenAPIV2.Route<T>,\n>(\n  specification: Readonly<T>,\n  name: U,\n): OpenAPIV2.OperationByRoute<T, U> {\n\n  // --- Assert the specification has a paths object.\n  if (!specification\n    || typeof specification !== 'object'\n    || specification === null\n    || 'paths' in specification === false\n    || typeof specification.paths !== 'object'\n    || specification.paths === null)\n    throw new Error('Missing paths object in the OpenAPI specification.')\n\n  // --- Extract the path and method from the name.\n  const match = /^(get|post|put|patch|delete|head|options) (\\/.+)$/i.exec(name)\n  if (!match) throw new Error('Could not resolve the path and method from the route name.')\n  const [, routeMethod, routePath] = match\n  const method = routeMethod.toLowerCase()\n\n  // --- Search for the route in the specification's paths.\n  const paths = specification.paths as Record<string, OpenAPI.Operation>\n  const path = paths[routePath]\n  if (!path) throw new Error(`Route \"${name}\" not found in specification.`)\n  if (typeof path !== 'object' || path === null) throw new Error('Invalid path object in the OpenAPI specification.')\n  if (method in path === false) throw new Error(`Method \"${method}\" not found in path \"${routePath}\".`)\n  const operation = path[method as keyof typeof path] as OpenAPI.Operation\n  return { ...operation, method, path: routePath } as OpenAPIV2.OperationByRoute<T, U>\n}\n","import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'\n\nexport type OpenAPIReference =\n  | OpenAPIV2.ReferenceObject\n  | OpenAPIV3.ReferenceObject\n  | OpenAPIV3_1.ReferenceObject\n\n/**\n * Check if a value is an {@linkcode OpenAPIReference}.\n *\n * @param value The value to check.\n * @returns `true` if the value is a reference object.\n * @example isReferenceObject({ $ref: '#/components/schemas/MySchema' }) // true\n */\nexport function isReferenceObject<T extends OpenAPIReference>(value: unknown): value is T {\n  return typeof value === 'object'\n    && value !== null\n    && '$ref' in value\n    && typeof value.$ref === 'string'\n}\n","import type { StringJoin, StringReplace, WriteableDeep } from '@unshared/types'\nimport type { OpenAPIReference } from './isReferenceObject'\nimport { isReferenceObject } from './isReferenceObject'\n\n/**\n * Decode an OpenAPI reference path by replacing the encoded characters with\n * their original values. This function will replace `~0` with `~` and `~1`\n * with `/`.\n *\n * @example DecodeReference<'#/foo~1bar~0baz'> // '#/foo/bar~baz'\n */\nexport type OpenAPIReferenceDecoded<T extends string> =\n  StringReplace<StringReplace<T, '~0', '~'>, '~1', '/'>\n\n/**\n * Extract the parts of a reference path as a tuple.\n *\n * @example OpenAPIV3ReferencePath<'#/paths/~1users~1{username}'> // ['paths', '/users/{username}']\n */\nexport type OpenAPIReferencePath<T extends string> =\n  T extends `#/${infer P}/${infer Rest}` ? [P, ...OpenAPIReferencePath<Rest>]\n    : T extends `#/${infer P}` ? [P]\n      : T extends `${infer P}/${infer Rest}` ? [P, ...OpenAPIReferencePath<Rest>]\n        : T extends `${infer P}` ? [P]\n          : []\n\n/**\n * Resolve a type to the type it references. If the source is not a reference,\n * the source will be returned.\n *\n * @template T The type to resolve.\n * @returns The result type.\n * @example Resolved<{ $ref: '#/info' }, { info: { title: string } }> // { title: string }\n */\nexport type OpenAPIReferenceResolved<\n  T extends OpenAPIReference,\n  D extends object,\n> =\n  D extends object\n    ? T extends { $ref: infer R extends string }\n\n      // --- Match last part of the reference.\n      ? OpenAPIReferencePath<R> extends [infer P extends string]\n        ? OpenAPIReferenceDecoded<P> extends keyof D\n          ? D[OpenAPIReferenceDecoded<P>] extends object\n            ? WriteableDeep<Omit<D[OpenAPIReferenceDecoded<P>], keyof T>>\n            : never\n          : never\n\n        // --- Match middle part of the reference.\n        : OpenAPIReferencePath<R> extends [infer P extends string, ...infer Rest extends string[]]\n          ? OpenAPIReferenceDecoded<P> extends keyof D\n            ? D[OpenAPIReferenceDecoded<P>] extends object\n              ? OpenAPIReferenceResolved<{ $ref: StringJoin<Rest, '/'> }, D[OpenAPIReferenceDecoded<P>]>\n              : never\n            : never\n          : never\n      : never\n    : never\n\n/**\n * Resolve an OpenAPI `ReferenceObject` to the component it references. If the\n * source is not a reference, the source will be returned.\n *\n * @private\n * @param reference The reference object to resolve.\n * @param document The OpenAPI document to resolve the reference from.\n * @returns The result component.\n * @example resolveReference({ $ref: '#/components/schemas/User' }, document)\n */\nexport function resolveReference<\n  T extends OpenAPIReference,\n  D extends object,\n>(reference: Readonly<T>, document: Readonly<D>): OpenAPIReferenceResolved<T, D> {\n\n  // --- Return the source if it is not a reference.\n  if (!isReferenceObject(reference))\n    throw new TypeError('Expected value to be an OpenAPI reference object.')\n\n  // --- Assert that the parameters are valid.\n  if (typeof document !== 'object' || document === null)\n    throw new TypeError('Expected OpenAPI specification to be an object.')\n\n  // --- Resolve the component with it's reference path.\n  const referenceParts = reference.$ref.replace(/^#\\//, '').split('/')\n  let result = document\n  for (const part of referenceParts) {\n    if (result === undefined) break\n    if (typeof result !== 'object' || result === null) break\n    const key = part.replaceAll('~1', '/').replaceAll('~0', '~')\n    // @ts-expect-error: assume the part is a key of the object.\n    result = result[key] as unknown\n  }\n\n  // --- Throw an error if the component could not be result.\n  if (result === undefined)\n    throw new Error(`Could not resolve OpenAPI component: ${reference.$ref}`)\n\n  // --- Return the result component.\n  return result as OpenAPIReferenceResolved<T, D>\n}\n","import type { ObjectLike } from '@unshared/types'\nimport type { OpenAPIReference } from './isReferenceObject'\nimport type { OpenAPIReferenceResolved } from './resolveReference'\nimport { isReferenceObject } from './isReferenceObject'\nimport { resolveReference as resolveReference } from './resolveReference'\n\n/**\n * Resolve a type to the type it references. If the source is not a reference,\n * the source will be returned.\n *\n * @template T The type to resolve.\n * @returns The resolved type.\n * @example\n * type Resolved = OpenAPIResolved<{\n *   ...\n *   paths: {\n *     '/users': {\n *       get: { $ref: '#/components/routes/getUsers' }\n *     }\n *   }\n * }>\n */\nexport type OpenAPIResolved<T, D = T> =\n  T extends OpenAPIReference\n    ? D extends object ? OpenAPIResolved<OpenAPIReferenceResolved<T, D>, D> : never\n    : T extends object ? { -readonly [K in keyof T]: OpenAPIResolved<T[K], D> } : T\n\n/**\n * Recursively resolve all references in an OpenAPI specification. This function\n * will return a `Proxy` object that will resolve references on the fly.\n *\n * @param value The OpenAPI specification.\n * @returns The resolved OpenAPI specification.\n * @example\n * const resolved = resolveReferences({\n *   ...\n *   paths: {\n *     '/users': {\n *       get: { $ref: '#/components/routes/getUsers' },\n *     },\n *   },\n * })\n */\nexport function resolveDocument<T extends object>(value: Readonly<T>): OpenAPIResolved<T>\nexport function resolveDocument<T extends object, D>(value: Readonly<T>, document: Readonly<D>): OpenAPIResolved<T, D>\nexport function resolveDocument(value: Readonly<ObjectLike>, document = value): unknown {\n  return new Proxy(value, {\n    get(target, property: string) {\n      let value = target[property]\n\n      // --- Abort if no document is provided.\n      if (!document) return value\n\n      // --- Resolve the reference if it is a reference object.\n      if (isReferenceObject(value))\n        value = resolveReference(value, document)\n\n      // --- Recursively resolve references in objects.\n      if (typeof value === 'object' && value !== null)\n        return resolveDocument(value as ObjectLike, document)\n\n      // --- Return the value as is.\n      return value\n    },\n  })\n}\n"],"names":["value"],"mappings":"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"}

package/dist/chunks/C3RyfPUw.cjs

@@ -0,0 +1,103 @@
+"use strict";
+function isFormDataLike(value) {
+  return typeof value != "object" || value === null ? !1 : value instanceof FormData ? !0 : Object.values(value).some((x) => x instanceof File ? !0 : Array.isArray(x) ? x.some((item) => item instanceof File) : x instanceof Blob);
+}
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null && value.constructor === Object;
+}
+function toFormData(object) {
+  if (object instanceof FormData) return object;
+  const formData = new FormData();
+  for (const key in object) {
+    const value = object[key];
+    if (value !== void 0)
+      if (Array.isArray(value))
+        for (const item of value)
+          formData.append(key, item);
+      else
+        formData.append(key, value);
+  }
+  return formData;
+}
+function parseRequestBody(route, options, context) {
+  const { data, body } = options, { init } = context;
+  if (init.headers = init.headers ?? {}, body !== void 0) {
+    init.body = body;
+    return;
+  }
+  ["get", "head", "delete"].includes(init.method ?? "get") || data != null && (isFormDataLike(data) ? (init.body = toFormData(data), init.headers = { ...init.headers, "Content-Type": "multipart/form-data" }) : data instanceof ReadableStream ? init.body = data : data instanceof File ? (init.body = data.stream(), init.headers = { ...init.headers, "Content-Type": "application/octet-stream" }) : isObjectLike(data) && (init.body = JSON.stringify(data), init.headers = { ...init.headers, "Content-Type": "application/json" }));
+}
+function parseRequestHeaders(route, options, context) {
+  const { headers } = options, { init } = context;
+  if (init.headers = init.headers ?? {}, !!headers)
+    for (const key in headers) {
+      const value = headers[key];
+      value !== void 0 && typeof value == "string" && (init.headers = { ...init.headers, [key]: value });
+    }
+}
+const EXP_PATH_PARAMETER = /:([\w-]+)|%7B([\w-]+)%7D/g;
+function parseRequestParameters(route, options, context) {
+  const { url } = context, { data, parameters = {} } = options;
+  if (!url) throw new Error("Could not resolve the `RequestInit` object: the `url` is missing.");
+  const pathParameters = url.pathname.match(EXP_PATH_PARAMETER);
+  if (pathParameters) {
+    if (isObjectLike(data))
+      for (const key in data) {
+        const value = data[key];
+        value !== void 0 && typeof value == "string" && parameters[key] === void 0 && (parameters[key] = value, delete data[key]);
+      }
+    for (const parameter of pathParameters.values()) {
+      const key = parameter.replaceAll(EXP_PATH_PARAMETER, "$1$2"), value = parameters[key];
+      value !== void 0 && typeof value == "string" && (url.pathname = url.pathname.replace(parameter, value));
+    }
+  }
+}
+function toSearchParams(object, options = {}) {
+  const { searchArrayFormat = "flat" } = options, search = new URLSearchParams();
+  for (const key in object) {
+    const value = object[key];
+    if (value !== void 0)
+      if (Array.isArray(value)) {
+        if (searchArrayFormat === "brackets") for (const v of value) search.append(`${key}[]`, String(v));
+        else if (searchArrayFormat === "indices") for (const [i, v] of value.entries()) search.append(`${key}[${i}]`, String(v));
+        else if (searchArrayFormat === "comma") search.append(key, value.join(","));
+        else if (searchArrayFormat === "path") for (const [i, v] of value.entries()) search.append(`${key}.${i}`, String(v));
+        else if (searchArrayFormat === "flat") for (const v of value) search.append(key, String(v));
+      } else
+        search.append(key, value.toString());
+  }
+  return search;
+}
+function parseRequestQuery(route, options, context) {
+  const { url, init } = context, { data, query = {}, searchArrayFormat } = options;
+  if (!url) throw new Error("Could not resolve the `RequestInit` object: the `url` is missing.");
+  if (!["post", "put", "patch"].includes(init.method ?? "get") && isObjectLike(data))
+    for (const key in data)
+      data[key] !== void 0 && query[key] === void 0 && (query[key] = data[key], delete data[key]);
+  url.search = toSearchParams(query, { searchArrayFormat }).toString();
+}
+const EXP_REQUEST = /^((?<method>[a-z]+) )?(?<url>[^:]+?:\/{2}[^/]+)?(?<path>\/[^\s?]*)/i, METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
+function parseRequestUrl(route, options, context) {
+  const { method, baseUrl } = options, match = EXP_REQUEST.exec(route);
+  if (!match?.groups) throw new Error("Could not resolve the `RequestInit` object: Invalid route name.");
+  const routeMethod = method ?? match.groups.method ?? "get", routeBaseUrl = baseUrl ?? match.groups.url;
+  if (!routeBaseUrl) throw new Error("Could not resolve the `RequestInit` object: the `baseUrl` is missing.");
+  const methodLower = routeMethod.toLowerCase();
+  if (!METHODS.has(methodLower)) throw new Error(`Could not resolve the \`RequestInit\` object:, the method \`${routeMethod}\` is invalid.`);
+  context.init = context.init ?? {}, context.init.method = methodLower, context.url = new URL(routeBaseUrl), context.url.pathname += context.url.pathname.endsWith("/") ? match.groups.path.slice(1) : match.groups.path;
+}
+function parseRequest(route, options = {}) {
+  const { data, body, query, headers, parameters, baseUrl, method, searchArrayFormat, ...requestInit } = options, context = { init: requestInit };
+  return parseRequestUrl(route, { baseUrl, method }, context), parseRequestParameters(route, { data, parameters }, context), parseRequestQuery(route, { data, query, searchArrayFormat }, context), parseRequestBody(route, { body, data }, context), parseRequestHeaders(route, { headers }, context), context;
+}
+exports.isFormDataLike = isFormDataLike;
+exports.isObjectLike = isObjectLike;
+exports.parseRequest = parseRequest;
+exports.parseRequestBody = parseRequestBody;
+exports.parseRequestHeaders = parseRequestHeaders;
+exports.parseRequestParameters = parseRequestParameters;
+exports.parseRequestQuery = parseRequestQuery;
+exports.parseRequestUrl = parseRequestUrl;
+exports.toFormData = toFormData;
+exports.toSearchParams = toSearchParams;
+//# sourceMappingURL=C3RyfPUw.cjs.map