@kubb/plugin-client 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/types-DBQdg-BV.d.ts

@@ -1,169 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
-import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
-import { Generator as Generator$1 } from "@kubb/plugin-oas/generators";
-import { Oas, contentType } from "@kubb/oas";
-
-//#region src/types.d.ts
-/**
- * Use either a preset `client` type OR a custom `importPath`, not both.
- * `importPath` will override the default `client` preset when both are provided.
- * These options are mutually exclusive. `bundle` and `importPath` are also
- * mutually exclusive since `bundle` only has effect when `importPath` is not set.
- */
-type ClientImportPath = {
-  /**
-   * Which client should be used to do the HTTP calls.
-   * - 'axios' uses axios client for HTTP requests.
-   * - 'fetch' uses native fetch API for HTTP requests.
-   * @default 'axios'
-   */
-  client?: 'axios' | 'fetch';
-  importPath?: never;
-} | {
-  client?: never;
-  /**
-   * Client import path for API calls.
-   * Used as `import client from '${importPath}'`.
-   * Accepts relative and absolute paths; path changes are not performed.
-   */
-  importPath: string;
-  /**
-   * `bundle` has no effect when `importPath` is set.
-   * Use either `bundle` (with `client`) or `importPath`, not both.
-   */
-  bundle?: never;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'clients', barrelType: 'named' }
-   */
-  output?: Output<Oas>;
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType;
-  /**
-   * Group the clients based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>;
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Create `operations.ts` file with all operations grouped by methods.
-   * @default false
-   */
-  operations?: boolean;
-  /**
-   * Export urls that are used by operation x.
-   * - 'export' makes them part of your barrel file.
-   * - false does not make them exportable.
-   * @default false
-   * @example getGetPetByIdUrl
-   */
-  urlType?: 'export' | false;
-  /**
-   * Allows you to set a custom base url for all generated calls.
-   */
-  baseURL?: string;
-  /**
-   * ReturnType that is used when calling the client.
-   * - 'data' returns ResponseConfig[data].
-   * - 'full' returns ResponseConfig.
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full';
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams names
-   * @note response types (data/body) are not affected by this option
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * How to pass your params.
-   * - 'object' returns the params and pathParams as an object.
-   * - 'inline' returns the params as comma separated params.
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline';
-  /**
-   * How to pass your pathParams.
-   * - 'object' returns the pathParams as an object.
-   * - 'inline' returns the pathParams as comma separated params.
-   * @default 'inline'
-   */
-  pathParamsType?: 'object' | 'inline';
-  /**
-   * Which parser can be used before returning the data.
-   * - 'client' returns the data as-is from the client.
-   * - 'zod' uses @kubb/plugin-zod to parse the data.
-   * @default 'client'
-   */
-  parser?: 'client' | 'zod';
-  /**
-   * How to generate the client code.
-   * - 'function' generates standalone functions for each operation.
-   * - 'class' generates a class with methods for each operation.
-   * - 'staticClass' generates a class with static methods for each operation.
-   * @default 'function'
-   */
-  clientType?: 'function' | 'class' | 'staticClass';
-  /**
-   * Bundle the selected client into the generated `.kubb` directory.
-   * When disabled the generated clients will import the shared runtime from `@kubb/plugin-client/clients/*`.
-   * @default false
-   * In version 5 of Kubb this is by default true
-   */
-  bundle?: boolean;
-  /**
-   * Generate a wrapper class that composes all tag-based client classes into a single entry point.
-   */
-  wrapper?: {
-    /**
-     * Name of the wrapper class.
-     */
-    className: string;
-  };
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  };
-  /**
-   * Define some generators next to the client generators
-   */
-  generators?: Array<Generator$1<PluginClient>>;
-} & ClientImportPath;
-type ResolvedOptions = {
-  output: Output<Oas>;
-  group?: Options['group'];
-  baseURL: string | undefined;
-  client: Options['client'];
-  clientType: NonNullable<Options['clientType']>;
-  bundle: NonNullable<Options['bundle']>;
-  parser: NonNullable<Options['parser']>;
-  urlType: NonNullable<Options['urlType']>;
-  importPath: Options['importPath'];
-  dataReturnType: NonNullable<Options['dataReturnType']>;
-  pathParamsType: NonNullable<Options['pathParamsType']>;
-  paramsType: NonNullable<Options['paramsType']>;
-  paramsCasing: Options['paramsCasing'];
-  wrapper: Options['wrapper'];
-};
-type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, never, ResolvePathOptions>;
-//#endregion
-export { Options as n, PluginClient as r, ClientImportPath as t };
-//# sourceMappingURL=types-DBQdg-BV.d.ts.map

package/src/components/index.ts

@@ -1,5 +0,0 @@
-export { ClassClient } from './ClassClient.tsx'
-export { Client } from './Client.tsx'
-export { Operations } from './Operations.tsx'
-export { StaticClassClient } from './StaticClassClient.tsx'
-export { Url } from './Url.tsx'

package/src/generators/index.ts

@@ -1,5 +0,0 @@
-export { classClientGenerator } from './classClientGenerator.tsx'
-export { clientGenerator } from './clientGenerator.tsx'
-export { groupedClientGenerator } from './groupedClientGenerator.tsx'
-export { operationsGenerator } from './operationsGenerator.tsx'
-export { staticClassClientGenerator } from './staticClassClientGenerator.tsx'

package/templates/clients/axios.ts

@@ -1,70 +0,0 @@
-import type { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import axios from 'axios'
-
-declare const AXIOS_BASE: string
-declare const AXIOS_HEADERS: string
-
-/**
- * Subset of AxiosRequestConfig
- */
-export type RequestConfig<TData = unknown> = {
-  baseURL?: string
-  url?: string
-  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
-  params?: unknown
-  data?: TData | FormData
-  responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'
-  signal?: AbortSignal
-  validateStatus?: (status: number) => boolean
-  headers?: AxiosRequestConfig['headers']
-}
-
-/**
- * Subset of AxiosResponse
- */
-export type ResponseConfig<TData = unknown> = {
-  data: TData
-  status: number
-  statusText: string
-  headers: AxiosResponse['headers']
-}
-
-export type ResponseErrorConfig<TError = unknown> = AxiosError<TError>
-
-export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>) => Promise<ResponseConfig<TData>>
-
-let _config: Partial<RequestConfig> = {
-  baseURL: typeof AXIOS_BASE !== 'undefined' ? AXIOS_BASE : undefined,
-  headers: typeof AXIOS_HEADERS !== 'undefined' ? JSON.parse(AXIOS_HEADERS) : undefined,
-}
-
-export const getConfig = () => _config
-
-export const setConfig = (config: RequestConfig) => {
-  _config = config
-  return getConfig()
-}
-
-export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T>>): Partial<T> => {
-  return configs.reduce<Partial<T>>((merged, config) => {
-    return {
-      ...merged,
-      ...config,
-      headers: {
-        ...merged.headers,
-        ...config.headers,
-      },
-    }
-  }, {})
-}
-
-export const axiosInstance = axios.create(getConfig())
-
-export const fetch = async <TData, TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>): Promise<ResponseConfig<TData>> => {
-  return axiosInstance.request<TData, ResponseConfig<TData>>(mergeConfig(getConfig(), config)).catch((e: AxiosError<TError>) => {
-    throw e
-  })
-}
-
-fetch.getConfig = getConfig
-fetch.setConfig = setConfig

package/templates/clients/fetch.ts

@@ -1,93 +0,0 @@
-/**
- * RequestCredentials
- */
-export type RequestCredentials = 'omit' | 'same-origin' | 'include'
-
-/**
- * Subset of FetchRequestConfig
- */
-export type RequestConfig<TData = unknown> = {
-  baseURL?: string
-  url?: string
-  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
-  params?: unknown
-  data?: TData | FormData
-  responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'
-  signal?: AbortSignal
-  headers?: [string, string][] | Record<string, string>
-  credentials?: RequestCredentials
-}
-
-/**
- * Subset of FetchResponse
- */
-export type ResponseConfig<TData = unknown> = {
-  data: TData
-  status: number
-  statusText: string
-  headers: Headers
-}
-
-let _config: Partial<RequestConfig> = {}
-
-export const getConfig = () => _config
-
-export const setConfig = (config: Partial<RequestConfig>) => {
-  _config = config
-  return getConfig()
-}
-
-export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T>>): Partial<T> => {
-  return configs.reduce<Partial<T>>((merged, config) => {
-    return {
-      ...merged,
-      ...config,
-      headers: {
-        ...(Array.isArray(merged.headers) ? Object.fromEntries(merged.headers) : merged.headers),
-        ...(Array.isArray(config.headers) ? Object.fromEntries(config.headers) : config.headers),
-      },
-    }
-  }, {})
-}
-
-export type ResponseErrorConfig<TError = unknown> = TError
-
-export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>) => Promise<ResponseConfig<TData>>
-
-export const fetch = async <TData, _TError = unknown, TVariables = unknown>(paramsConfig: RequestConfig<TVariables>): Promise<ResponseConfig<TData>> => {
-  const normalizedParams = new URLSearchParams()
-
-  const config = mergeConfig(getConfig(), paramsConfig)
-
-  Object.entries(config.params || {}).forEach(([key, value]) => {
-    if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
-    }
-  })
-
-  let targetUrl = [config.baseURL, config.url].filter(Boolean).join('')
-
-  if (config.params) {
-    targetUrl += `?${normalizedParams}`
-  }
-
-  const response = await globalThis.fetch(targetUrl, {
-    credentials: config.credentials || 'same-origin',
-    method: config.method?.toUpperCase(),
-    body: config.data instanceof FormData ? config.data : JSON.stringify(config.data),
-    signal: config.signal,
-    headers: config.headers,
-  })
-
-  const data = [204, 205, 304].includes(response.status) || !response.body ? {} : await response.json()
-
-  return {
-    data: data as TData,
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers as Headers,
-  }
-}
-
-fetch.getConfig = getConfig
-fetch.setConfig = setConfig

package/templates/config.ts

@@ -1,43 +0,0 @@
-export function buildFormData<T = unknown>(data: T): FormData {
-  const formData = new FormData()
-
-  function appendData(key: string, value: any) {
-    if (value instanceof Blob) {
-      formData.append(key, value)
-      return
-    }
-    if (value instanceof Date) {
-      formData.append(key, value.toISOString())
-      return
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      formData.append(key, String(value))
-      return
-    }
-    if (typeof value === 'string') {
-      formData.append(key, value)
-      return
-    }
-    if (typeof value === 'object') {
-      formData.append(key, new Blob([JSON.stringify(value)], { type: 'application/json' }))
-      return
-    }
-  }
-
-  if (data) {
-    Object.entries(data).forEach(([key, value]) => {
-      if (value === undefined || value === null) return
-
-      if (Array.isArray(value)) {
-        for (const valueItem of value) {
-          if (valueItem === undefined || valueItem === null) continue
-          appendData(key, valueItem)
-        }
-      } else {
-        appendData(key, value)
-      }
-    })
-  }
-
-  return formData
-}