@unshared/client 0.3.3 → 0.4.0

package/dist/chunks/{Bs2VarsP.d.ts → 5p4H9ZaI.d.ts}

@@ -1,5 +1,5 @@
 import { Loose, UnionMerge, Override, Pretty, CollectKey, MaybeLiteral, StringSplit } from '@unshared/types';
-import { F as FetchMethod, R as RequestOptions } from './BZ5qrH6f.js';
+import { a as FetchMethod, R as RequestOptions } from './Nc32BOzg.js';
 import { OpenAPI } from 'openapi-types';
 
 /** Get the base URL of an OpenAPI specification. */
@@ -29,7 +29,7 @@ declare namespace OpenAPIV2 {
     } ? `${Scheme}://${Host}${BasePath}` : string;
     /*************************************************************************/
     /*************************************************************************/
-    type InferSchemaObject<T> = T extends {
+    type InferSchemaObject<T> = (T extends {
         properties: infer P extends Record<string, any>;
         required: Array<infer R extends string>;
     } ? ({
@@ -40,11 +40,15 @@ declare namespace OpenAPIV2 {
         properties: infer P extends Record<string, any>;
     } ? {
         [K in keyof P]?: InferSchema<P[K]>;
-    } : T extends {
+    } : object) & (T extends {
         additionalProperties: infer U extends Record<string, any>;
-    } ? Record<string, InferSchema<U>> : Record<string, unknown>;
+    } ? Record<string, InferSchema<U>> : T extends {
+        additionalProperties: true;
+    } ? Record<string, any> : T extends {
+        additionalProperties: false;
+    } ? object : Record<string, any>);
     type InferSchemaArray<T> = T extends {
-        items?: infer U;
+        items?: infer U extends object;
     } ? Array<InferSchema<U>> : unknown[];
     type InferSchema<T> = Loose<(T extends {
         anyOf: Array<infer U>;

package/dist/chunks/{BZ5qrH6f.d.ts → Nc32BOzg.d.ts}

@@ -161,4 +161,4 @@ interface RequestOptions<Method extends FetchMethod = FetchMethod, BaseUrl exten
  */
 declare function request(route: string, options?: RequestOptions): Promise<unknown>;
 
-export { type FetchMethod as F, type RequestOptions as R, type SearchParamsObject as S, type ToSearchParamsOptions as T, type FetchOptions as a, type RequestContext as b, type FetchHeaders as c, type SearchArrayFormat as d, parseRequest as p, request as r, toSearchParams as t };
+export { type FetchOptions as F, type RequestOptions as R, type SearchParamsObject as S, type ToSearchParamsOptions as T, type FetchMethod as a, type RequestContext as b, type FetchHeaders as c, type SearchArrayFormat as d, parseRequest as p, request as r, toSearchParams as t };

package/dist/createClient.cjs

@@ -14,70 +14,15 @@ class Client {
   constructor(options = {}) {
     this.options = options;
   }
-  /**
-   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns The response from the server.
-   */
   fetch(route, options) {
     return request.fetch(route, { ...this.options, ...options });
   }
-  /**
-   * Fetch a route from the API and return the data. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns The data from the API.
-   * @example
-   * // Declare the application type.
-   * type App = Application<[ModuleProduct]>
-   *
-   * // Create a type-safe client for the application.
-   * const request = createClient<App>()
-   *
-   * // Fetch the data from the API.
-   * const data = request('GET /api/product/:id', { data: { id: '1' } })
-   */
   request(route, options) {
     return request.request(route, { ...this.options, ...options });
   }
-  /**
-   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns A result object with either the data or an error.
-   * @example
-   * // Declare the application type.
-   * type App = Application<[ModuleProduct]>
-   *
-   * // Create a type-safe client for the application.
-   * const request = createClient<App>()
-   *
-   * // Fetch the data from the API.
-   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })
-   * if (error) console.error(error)
-   * else console.log(data)
-   */
   requestAttempt(route, options) {
     return attempt.attempt(() => this.request(route, options));
   }
-  /**
-   * Create a new WebSocket connection to the server with the given path. The connection will
-   * automatically reconnect if the connection is closed unexpectedly.
-   *
-   * @param channel The path to connect to.
-   * @param options The options to pass to the connection.
-   * @returns The WebSocket connection.
-   */
   connect(channel, options) {
     return connect.connect(channel, { baseUrl: this.options.baseUrl, ...options });
   }

package/dist/createClient.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createClient.cjs","sources":["../createClient.ts"],"sourcesContent":["import type { Awaitable } from '@unshared/functions'\nimport type { Result } from '@unshared/functions/attempt'\nimport type { ServiceOptions } from './createService'\nimport type { OpenAPILike, OpenAPIOptionsMap } from './openapi'\nimport type { RequestOptions } from './utils'\nimport type { ConnectOptions, WebSocketChannel } from './websocket'\nimport { attempt } from '@unshared/functions/attempt'\nimport { fetch } from './utils/fetch'\nimport { request } from './utils/request'\nimport { connect } from './websocket/connect'\n\ntype Data<T extends RequestOptions> = T extends RequestOptions<any, any, any, any, any, any, infer R, any> ? R : unknown\ntype Routes = Record<string, RequestOptions>\ntype Channels = Record<string, ConnectOptions>\n\nexport class Client<T extends Routes = Routes, U extends Channels = Channels> {\n\n  /**\n   * Create a new client for the application.\n   *\n   * @param options The options to pass to the client.\n   * @example new Client({ baseUrl: 'https://api.example.com' })\n   */\n  constructor(public options: RequestOptions = {}) {}\n\n  /**\n   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The response from the server.\n   */\n  public fetch<K extends keyof T & string>(route: K, options?: T[K]): Promise<Response & { json: () => Promise<Data<T[K]>> }> {\n    return fetch(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The data from the API.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const data = request('GET /api/product/:id', { data: { id: '1' } })\n   */\n  public request<K extends keyof T & string>(route: K, options?: T[K]): Promise<Data<T[K]>> {\n    return request(route, { ...this.options, ...options }) as Promise<Data<T[K]>>\n  }\n\n  /**\n   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns A result object with either the data or an error.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })\n   * if (error) console.error(error)\n   * else console.log(data)\n   */\n  public requestAttempt<K extends keyof T & string>(route: K, options?: T[K]): Promise<Result<Data<T[K]>>> {\n    return attempt(() => this.request(route, options))\n  }\n\n  /**\n   * Create a new WebSocket connection to the server with the given path. The connection will\n   * automatically reconnect if the connection is closed unexpectedly.\n   *\n   * @param channel The path to connect to.\n   * @param options The options to pass to the connection.\n   * @returns The WebSocket connection.\n   */\n  public connect<P extends keyof U & string>(channel: P, options?: U[P]): Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>> {\n    return connect(channel, { baseUrl: this.options.baseUrl, ...options }) as Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>>\n  }\n}\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends OpenAPILike>(options?: ServiceOptions<T>): Client<OpenAPIOptionsMap<T>>\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends Routes = Routes, V extends Channels = Channels>(options?: RequestOptions): Client<T, V>\nexport function createClient(options?: RequestOptions): Client {\n  return new Client(options)\n}\n"],"names":["fetch","request","attempt","connect"],"mappings":";;;;;;AAeO,MAAM,OAAiE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5E,YAAmB,UAA0B,IAAI;AAA9B,SAAA,UAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWZ,MAAkC,OAAU,SAAyE;AACnH,WAAAA,QAAAA,MAAM,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqB9C,QAAoC,OAAU,SAAqC;AACjF,WAAAC,QAAAA,QAAQ,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBhD,eAA2C,OAAU,SAA6C;AACvG,WAAOC,QAAAA,QAAQ,MAAM,KAAK,QAAQ,OAAO,OAAO,CAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,QAAoC,SAAY,SAA2E;AACzH,WAAAC,QAAA,QAAQ,SAAS,EAAE,SAAS,KAAK,QAAQ,SAAS,GAAG,SAAS;AAAA,EAAA;AAEzE;AAqCO,SAAS,aAAa,SAAkC;AACtD,SAAA,IAAI,OAAO,OAAO;AAC3B;;;"}
+{"version":3,"file":"createClient.cjs","sources":["../createClient.ts"],"sourcesContent":["import type { Awaitable } from '@unshared/functions'\nimport type { Result } from '@unshared/functions/attempt'\nimport type { ServiceOptions } from './createService'\nimport type { OpenAPILike, OpenAPIOptionsMap } from './openapi'\nimport type { FetchOptions, RequestOptions } from './utils'\nimport type { ConnectOptions, WebSocketChannel } from './websocket'\nimport { attempt } from '@unshared/functions/attempt'\nimport { fetch } from './utils/fetch'\nimport { request } from './utils/request'\nimport { connect } from './websocket/connect'\n\ntype Data<T extends RequestOptions> = T extends RequestOptions<any, any, any, any, any, any, infer R, any> ? R : unknown\ntype Routes = Record<string, RequestOptions>\ntype Channels = Record<string, ConnectOptions>\n\nexport class Client<T extends Routes = Routes, U extends Channels = Channels> {\n\n  /**\n   * Create a new client for the application.\n   *\n   * @param options The options to pass to the client.\n   * @example new Client({ baseUrl: 'https://api.example.com' })\n   */\n  constructor(public options: RequestOptions = {}) {}\n\n  /**\n   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The response from the server.\n   */\n  public fetch<K extends keyof T & string>(route: K, options?: T[K]): Promise<Response & { json: () => Promise<Data<T[K]>> }>\n  public fetch(route: string, options?: FetchOptions): Promise<Response>\n  public fetch(route: string, options?: FetchOptions): Promise<Response> {\n    return fetch(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The data from the API.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const data = request('GET /api/product/:id', { data: { id: '1' } })\n   */\n  public request<K extends keyof T & string>(route: K, options?: T[K]): Promise<Data<T[K]>>\n  public request(route: string, options?: RequestOptions): Promise<unknown>\n  public request(route: string, options?: RequestOptions): Promise<unknown> {\n    return request(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns A result object with either the data or an error.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })\n   * if (error) console.error(error)\n   * else console.log(data)\n   */\n  public requestAttempt<K extends keyof T & string>(route: K, options?: T[K]): Promise<Result<Data<T[K]>>>\n  public requestAttempt(route: string, options?: RequestOptions): Promise<Result<unknown>>\n  public requestAttempt(route: string, options?: RequestOptions): Promise<Result<unknown>> {\n    return attempt(() => this.request(route, options))\n  }\n\n  /**\n   * Create a new WebSocket connection to the server with the given path. The connection will\n   * automatically reconnect if the connection is closed unexpectedly.\n   *\n   * @param channel The path to connect to.\n   * @param options The options to pass to the connection.\n   * @returns The WebSocket connection.\n   */\n  public connect<P extends keyof U & string>(channel: P, options?: U[P]): Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>>\n  public connect(channel: string, options?: ConnectOptions): Awaitable<WebSocketChannel, WebSocketChannel>\n  public connect(channel: string, options?: ConnectOptions): Awaitable<WebSocketChannel, WebSocketChannel> {\n    return connect(channel, { baseUrl: this.options.baseUrl, ...options })\n  }\n}\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends OpenAPILike>(options?: ServiceOptions<T>): Client<OpenAPIOptionsMap<T>>\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends Routes = Routes, V extends Channels = Channels>(options?: RequestOptions): Client<T, V>\nexport function createClient(options?: RequestOptions): Client {\n  return new Client(options)\n}\n"],"names":["fetch","request","attempt","connect"],"mappings":";;;;;;AAeO,MAAM,OAAiE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5E,YAAmB,UAA0B,IAAI;AAA9B,SAAA,UAAA;AAAA,EAAA;AAAA,EAaZ,MAAM,OAAe,SAA2C;AAC9D,WAAAA,QAAAA,MAAM,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA,EAuB9C,QAAQ,OAAe,SAA4C;AACjE,WAAAC,QAAAA,QAAQ,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA,EAyBhD,eAAe,OAAe,SAAoD;AACvF,WAAOC,QAAAA,QAAQ,MAAM,KAAK,QAAQ,OAAO,OAAO,CAAC;AAAA,EAAA;AAAA,EAa5C,QAAQ,SAAiB,SAAyE;AAChG,WAAAC,QAAA,QAAQ,SAAS,EAAE,SAAS,KAAK,QAAQ,SAAS,GAAG,SAAS;AAAA,EAAA;AAEzE;AAqCO,SAAS,aAAa,SAAkC;AACtD,SAAA,IAAI,OAAO,OAAO;AAC3B;;;"}

package/dist/createClient.d.ts

@@ -1,13 +1,13 @@
 import { Awaitable } from '@unshared/functions';
 import { Result } from '@unshared/functions/attempt';
 import { ServiceOptions } from './createService.js';
-import { O as OpenAPILike, a as OpenAPIOptionsMap } from './chunks/Bs2VarsP.js';
-import { R as RequestOptions } from './chunks/BZ5qrH6f.js';
+import { R as RequestOptions, F as FetchOptions } from './chunks/Nc32BOzg.js';
+import { O as OpenAPILike, a as OpenAPIOptionsMap } from './chunks/5p4H9ZaI.js';
 import { WebSocketChannel, ConnectOptions } from './websocket.js';
 import '@unshared/types';
-import 'openapi-types';
 import './HttpHeaders.js';
 import './HttpMethods.js';
+import 'openapi-types';
 
 type Data<T extends RequestOptions> = T extends RequestOptions<any, any, any, any, any, any, infer R, any> ? R : unknown;
 type Routes = Record<string, RequestOptions>;
@@ -33,6 +33,7 @@ declare class Client<T extends Routes = Routes, U extends Channels = Channels> {
     fetch<K extends keyof T & string>(route: K, options?: T[K]): Promise<Response & {
         json: () => Promise<Data<T[K]>>;
     }>;
+    fetch(route: string, options?: FetchOptions): Promise<Response>;
     /**
      * Fetch a route from the API and return the data. If the client was instantiated with an
      * application, the route name will be inferred from the application routes. Otherwise, you
@@ -52,6 +53,7 @@ declare class Client<T extends Routes = Routes, U extends Channels = Channels> {
      * const data = request('GET /api/product/:id', { data: { id: '1' } })
      */
     request<K extends keyof T & string>(route: K, options?: T[K]): Promise<Data<T[K]>>;
+    request(route: string, options?: RequestOptions): Promise<unknown>;
     /**
      * Attempt to fetch a route from the API and return the data. If the client was instantiated with an
      * application, the route name will be inferred from the application routes. Otherwise, you
@@ -73,6 +75,7 @@ declare class Client<T extends Routes = Routes, U extends Channels = Channels> {
      * else console.log(data)
      */
     requestAttempt<K extends keyof T & string>(route: K, options?: T[K]): Promise<Result<Data<T[K]>>>;
+    requestAttempt(route: string, options?: RequestOptions): Promise<Result<unknown>>;
     /**
      * Create a new WebSocket connection to the server with the given path. The connection will
      * automatically reconnect if the connection is closed unexpectedly.
@@ -82,6 +85,7 @@ declare class Client<T extends Routes = Routes, U extends Channels = Channels> {
      * @returns The WebSocket connection.
      */
     connect<P extends keyof U & string>(channel: P, options?: U[P]): Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>>;
+    connect(channel: string, options?: ConnectOptions): Awaitable<WebSocketChannel, WebSocketChannel>;
 }
 /**
  * Create a new type-safe client for the application. The client can be used to fetch data from

package/dist/createClient.js

@@ -15,70 +15,15 @@ class Client {
   constructor(options = {}) {
     this.options = options;
   }
-  /**
-   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns The response from the server.
-   */
   fetch(route, options) {
     return fetch(route, { ...this.options, ...options });
   }
-  /**
-   * Fetch a route from the API and return the data. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns The data from the API.
-   * @example
-   * // Declare the application type.
-   * type App = Application<[ModuleProduct]>
-   *
-   * // Create a type-safe client for the application.
-   * const request = createClient<App>()
-   *
-   * // Fetch the data from the API.
-   * const data = request('GET /api/product/:id', { data: { id: '1' } })
-   */
   request(route, options) {
     return request(route, { ...this.options, ...options });
   }
-  /**
-   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an
-   * application, the route name will be inferred from the application routes. Otherwise, you
-   * can pass the route name as a string.
-   *
-   * @param route The name of the route to fetch.
-   * @param options The options to pass to the request.
-   * @returns A result object with either the data or an error.
-   * @example
-   * // Declare the application type.
-   * type App = Application<[ModuleProduct]>
-   *
-   * // Create a type-safe client for the application.
-   * const request = createClient<App>()
-   *
-   * // Fetch the data from the API.
-   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })
-   * if (error) console.error(error)
-   * else console.log(data)
-   */
   requestAttempt(route, options) {
     return attempt(() => this.request(route, options));
   }
-  /**
-   * Create a new WebSocket connection to the server with the given path. The connection will
-   * automatically reconnect if the connection is closed unexpectedly.
-   *
-   * @param channel The path to connect to.
-   * @param options The options to pass to the connection.
-   * @returns The WebSocket connection.
-   */
   connect(channel, options) {
     return connect(channel, { baseUrl: this.options.baseUrl, ...options });
   }

package/dist/createClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"createClient.js","sources":["../createClient.ts"],"sourcesContent":["import type { Awaitable } from '@unshared/functions'\nimport type { Result } from '@unshared/functions/attempt'\nimport type { ServiceOptions } from './createService'\nimport type { OpenAPILike, OpenAPIOptionsMap } from './openapi'\nimport type { RequestOptions } from './utils'\nimport type { ConnectOptions, WebSocketChannel } from './websocket'\nimport { attempt } from '@unshared/functions/attempt'\nimport { fetch } from './utils/fetch'\nimport { request } from './utils/request'\nimport { connect } from './websocket/connect'\n\ntype Data<T extends RequestOptions> = T extends RequestOptions<any, any, any, any, any, any, infer R, any> ? R : unknown\ntype Routes = Record<string, RequestOptions>\ntype Channels = Record<string, ConnectOptions>\n\nexport class Client<T extends Routes = Routes, U extends Channels = Channels> {\n\n  /**\n   * Create a new client for the application.\n   *\n   * @param options The options to pass to the client.\n   * @example new Client({ baseUrl: 'https://api.example.com' })\n   */\n  constructor(public options: RequestOptions = {}) {}\n\n  /**\n   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The response from the server.\n   */\n  public fetch<K extends keyof T & string>(route: K, options?: T[K]): Promise<Response & { json: () => Promise<Data<T[K]>> }> {\n    return fetch(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The data from the API.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const data = request('GET /api/product/:id', { data: { id: '1' } })\n   */\n  public request<K extends keyof T & string>(route: K, options?: T[K]): Promise<Data<T[K]>> {\n    return request(route, { ...this.options, ...options }) as Promise<Data<T[K]>>\n  }\n\n  /**\n   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns A result object with either the data or an error.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })\n   * if (error) console.error(error)\n   * else console.log(data)\n   */\n  public requestAttempt<K extends keyof T & string>(route: K, options?: T[K]): Promise<Result<Data<T[K]>>> {\n    return attempt(() => this.request(route, options))\n  }\n\n  /**\n   * Create a new WebSocket connection to the server with the given path. The connection will\n   * automatically reconnect if the connection is closed unexpectedly.\n   *\n   * @param channel The path to connect to.\n   * @param options The options to pass to the connection.\n   * @returns The WebSocket connection.\n   */\n  public connect<P extends keyof U & string>(channel: P, options?: U[P]): Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>> {\n    return connect(channel, { baseUrl: this.options.baseUrl, ...options }) as Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>>\n  }\n}\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends OpenAPILike>(options?: ServiceOptions<T>): Client<OpenAPIOptionsMap<T>>\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends Routes = Routes, V extends Channels = Channels>(options?: RequestOptions): Client<T, V>\nexport function createClient(options?: RequestOptions): Client {\n  return new Client(options)\n}\n"],"names":[],"mappings":";;;;;;;AAeO,MAAM,OAAiE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5E,YAAmB,UAA0B,IAAI;AAA9B,SAAA,UAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWZ,MAAkC,OAAU,SAAyE;AACnH,WAAA,MAAM,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqB9C,QAAoC,OAAU,SAAqC;AACjF,WAAA,QAAQ,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBhD,eAA2C,OAAU,SAA6C;AACvG,WAAO,QAAQ,MAAM,KAAK,QAAQ,OAAO,OAAO,CAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,QAAoC,SAAY,SAA2E;AACzH,WAAA,QAAQ,SAAS,EAAE,SAAS,KAAK,QAAQ,SAAS,GAAG,SAAS;AAAA,EAAA;AAEzE;AAqCO,SAAS,aAAa,SAAkC;AACtD,SAAA,IAAI,OAAO,OAAO;AAC3B;"}
+{"version":3,"file":"createClient.js","sources":["../createClient.ts"],"sourcesContent":["import type { Awaitable } from '@unshared/functions'\nimport type { Result } from '@unshared/functions/attempt'\nimport type { ServiceOptions } from './createService'\nimport type { OpenAPILike, OpenAPIOptionsMap } from './openapi'\nimport type { FetchOptions, RequestOptions } from './utils'\nimport type { ConnectOptions, WebSocketChannel } from './websocket'\nimport { attempt } from '@unshared/functions/attempt'\nimport { fetch } from './utils/fetch'\nimport { request } from './utils/request'\nimport { connect } from './websocket/connect'\n\ntype Data<T extends RequestOptions> = T extends RequestOptions<any, any, any, any, any, any, infer R, any> ? R : unknown\ntype Routes = Record<string, RequestOptions>\ntype Channels = Record<string, ConnectOptions>\n\nexport class Client<T extends Routes = Routes, U extends Channels = Channels> {\n\n  /**\n   * Create a new client for the application.\n   *\n   * @param options The options to pass to the client.\n   * @example new Client({ baseUrl: 'https://api.example.com' })\n   */\n  constructor(public options: RequestOptions = {}) {}\n\n  /**\n   * Fetch a route from the API and return the `Response` object. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The response from the server.\n   */\n  public fetch<K extends keyof T & string>(route: K, options?: T[K]): Promise<Response & { json: () => Promise<Data<T[K]>> }>\n  public fetch(route: string, options?: FetchOptions): Promise<Response>\n  public fetch(route: string, options?: FetchOptions): Promise<Response> {\n    return fetch(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns The data from the API.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const data = request('GET /api/product/:id', { data: { id: '1' } })\n   */\n  public request<K extends keyof T & string>(route: K, options?: T[K]): Promise<Data<T[K]>>\n  public request(route: string, options?: RequestOptions): Promise<unknown>\n  public request(route: string, options?: RequestOptions): Promise<unknown> {\n    return request(route, { ...this.options, ...options })\n  }\n\n  /**\n   * Attempt to fetch a route from the API and return the data. If the client was instantiated with an\n   * application, the route name will be inferred from the application routes. Otherwise, you\n   * can pass the route name as a string.\n   *\n   * @param route The name of the route to fetch.\n   * @param options The options to pass to the request.\n   * @returns A result object with either the data or an error.\n   * @example\n   * // Declare the application type.\n   * type App = Application<[ModuleProduct]>\n   *\n   * // Create a type-safe client for the application.\n   * const request = createClient<App>()\n   *\n   * // Fetch the data from the API.\n   * const { data, error } = requestAttempt('GET /api/product/:id', { data: { id: '1' } })\n   * if (error) console.error(error)\n   * else console.log(data)\n   */\n  public requestAttempt<K extends keyof T & string>(route: K, options?: T[K]): Promise<Result<Data<T[K]>>>\n  public requestAttempt(route: string, options?: RequestOptions): Promise<Result<unknown>>\n  public requestAttempt(route: string, options?: RequestOptions): Promise<Result<unknown>> {\n    return attempt(() => this.request(route, options))\n  }\n\n  /**\n   * Create a new WebSocket connection to the server with the given path. The connection will\n   * automatically reconnect if the connection is closed unexpectedly.\n   *\n   * @param channel The path to connect to.\n   * @param options The options to pass to the connection.\n   * @returns The WebSocket connection.\n   */\n  public connect<P extends keyof U & string>(channel: P, options?: U[P]): Awaitable<WebSocketChannel<U[P]>, WebSocketChannel<U[P]>>\n  public connect(channel: string, options?: ConnectOptions): Awaitable<WebSocketChannel, WebSocketChannel>\n  public connect(channel: string, options?: ConnectOptions): Awaitable<WebSocketChannel, WebSocketChannel> {\n    return connect(channel, { baseUrl: this.options.baseUrl, ...options })\n  }\n}\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends OpenAPILike>(options?: ServiceOptions<T>): Client<OpenAPIOptionsMap<T>>\n\n/**\n * Create a new type-safe client for the application. The client can be used to fetch data from\n * the API and connect to the server using WebSockets with the given path.\n *\n * @param options The options to pass to the client.\n * @returns The client object with the request method.\n * @example\n * // Create a type-safe client for the application.\n * const client = createClient<[ModuleUser]>()\n *\n * // Fetch the data from the API.\n * const data = await client.request('GET /api/user/:id', { id: '1' })\n *\n * // Use the data from the API.\n * console.log(data) // { id: '1', name: 'John Doe' }\n */\nexport function createClient<T extends Routes = Routes, V extends Channels = Channels>(options?: RequestOptions): Client<T, V>\nexport function createClient(options?: RequestOptions): Client {\n  return new Client(options)\n}\n"],"names":[],"mappings":";;;;;;;AAeO,MAAM,OAAiE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5E,YAAmB,UAA0B,IAAI;AAA9B,SAAA,UAAA;AAAA,EAAA;AAAA,EAaZ,MAAM,OAAe,SAA2C;AAC9D,WAAA,MAAM,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA,EAuB9C,QAAQ,OAAe,SAA4C;AACjE,WAAA,QAAQ,OAAO,EAAE,GAAG,KAAK,SAAS,GAAG,SAAS;AAAA,EAAA;AAAA,EAyBhD,eAAe,OAAe,SAAoD;AACvF,WAAO,QAAQ,MAAM,KAAK,QAAQ,OAAO,OAAO,CAAC;AAAA,EAAA;AAAA,EAa5C,QAAQ,SAAiB,SAAyE;AAChG,WAAA,QAAQ,SAAS,EAAE,SAAS,KAAK,QAAQ,SAAS,GAAG,SAAS;AAAA,EAAA;AAEzE;AAqCO,SAAS,aAAa,SAAkC;AACtD,SAAA,IAAI,OAAO,OAAO;AAC3B;"}

package/dist/createService.d.ts

@@ -1,6 +1,6 @@
 import { MaybeLiteral } from '@unshared/types';
-import { b as OperationId, c as OperationById, d as OperationOptions, e as OperationResult, S as ServerUrl, f as OpenAPIV3 } from './chunks/Bs2VarsP.js';
-import { R as RequestOptions } from './chunks/BZ5qrH6f.js';
+import { b as OperationId, c as OperationById, d as OperationOptions, e as OperationResult, S as ServerUrl, f as OpenAPIV3 } from './chunks/5p4H9ZaI.js';
+import { R as RequestOptions } from './chunks/Nc32BOzg.js';
 import 'openapi-types';
 import './HttpHeaders.js';
 import './HttpMethods.js';

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export { HttpMethod } from './HttpMethods.js';
 export { HttpStatusCode } from './HttpStatusCodes.js';
 import '@unshared/functions';
 import '@unshared/functions/attempt';
-import './chunks/Bs2VarsP.js';
+import './chunks/Nc32BOzg.js';
 import '@unshared/types';
-import './chunks/BZ5qrH6f.js';
+import './chunks/5p4H9ZaI.js';
 import 'openapi-types';
 import './websocket.js';

package/dist/openapi.d.ts

@@ -1,7 +1,7 @@
-export { O as OpenAPILike, a as OpenAPIOptionsMap, h as OpenAPIV2, j as OpenAPIV2Like, f as OpenAPIV3, k as OpenAPIV3Like, i as Operation, c as OperationById, n as OperationByRoute, b as OperationId, d as OperationOptions, l as OperationResponse, e as OperationResult, m as OperationRoute, S as ServerUrl, g as getServerUrl, r as resolveOperation } from './chunks/Bs2VarsP.js';
+export { O as OpenAPILike, a as OpenAPIOptionsMap, h as OpenAPIV2, j as OpenAPIV2Like, f as OpenAPIV3, k as OpenAPIV3Like, i as Operation, c as OperationById, n as OperationByRoute, b as OperationId, d as OperationOptions, l as OperationResponse, e as OperationResult, m as OperationRoute, S as ServerUrl, g as getServerUrl, r as resolveOperation } from './chunks/5p4H9ZaI.js';
 import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1, OpenAPI } from 'openapi-types';
 import { StringReplace, WriteableDeep, StringJoin, Substract } from '@unshared/types';
-import './chunks/BZ5qrH6f.js';
+import './chunks/Nc32BOzg.js';
 import './HttpHeaders.js';
 import './HttpMethods.js';
 

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { a as FetchOptions, R as RequestOptions, b as RequestContext } from './chunks/BZ5qrH6f.js';
-export { c as FetchHeaders, F as FetchMethod, d as SearchArrayFormat, S as SearchParamsObject, T as ToSearchParamsOptions, p as parseRequest, r as request, t as toSearchParams } from './chunks/BZ5qrH6f.js';
+import { F as FetchOptions, R as RequestOptions, b as RequestContext } from './chunks/Nc32BOzg.js';
+export { c as FetchHeaders, a as FetchMethod, d as SearchArrayFormat, S as SearchParamsObject, T as ToSearchParamsOptions, p as parseRequest, r as request, t as toSearchParams } from './chunks/Nc32BOzg.js';
 import { Awaitable } from '@unshared/functions/awaitable';
 import { ObjectLike } from '@unshared/types';
 import './HttpHeaders.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unshared/client",
   "type": "module",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "license": "MIT",
   "sideEffects": false,
   "author": "Stanley Horwood <stanley@hsjm.io>",
@@ -68,12 +68,12 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@unshared/functions": "0.3.3",
-    "@unshared/types": "0.3.3",
+    "@unshared/functions": "0.4.0",
+    "@unshared/types": "0.4.0",
     "openapi-types": "12.1.3"
   },
   "devDependencies": {
-    "@unshared/scripts": "0.3.3"
+    "@unshared/scripts": "0.4.0"
   },
   "scripts": {
     "build:httpMethods": "tsx ./scripts/buildHttpMethods.ts",