+3 -3

packages/config-vite-base/package.json

··· 2 2 "name": "@config/vite-base", 3 3 "version": "0.0.1", 4 4 "description": "Base configuration for Vite and Vitest", 5 5 - "main": "dist/index.js", 6 6 - "module": "dist/index.js", 7 7 - "types": "dist/index.d.ts", 5 5 + "main": "dist/index.mjs", 6 6 + "module": "dist/index.mjs", 7 7 + "types": "dist/index.d.mts", 8 8 "license": "MIT", 9 9 "type": "module", 10 10 "scripts": {

+271

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/client-custom/bundle/client/index.d.mts

··· 1 1 + //#region src/core/auth.d.ts 2 2 + type AuthToken = string | undefined; 3 3 + interface Auth { 4 4 + /** 5 5 + * Which part of the request do we use to send the auth? 6 6 + * 7 7 + * @default 'header' 8 8 + */ 9 9 + in?: 'header' | 'query' | 'cookie'; 10 10 + /** 11 11 + * Header or query parameter name. 12 12 + * 13 13 + * @default 'Authorization' 14 14 + */ 15 15 + name?: string; 16 16 + scheme?: 'basic' | 'bearer'; 17 17 + type: 'apiKey' | 'http'; 18 18 + } 19 19 + //#endregion 20 20 + //#region src/core/pathSerializer.d.ts 21 21 + interface SerializerOptions<T> { 22 22 + /** 23 23 + * @default true 24 24 + */ 25 25 + explode: boolean; 26 26 + style: T; 27 27 + } 28 28 + type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited'; 29 29 + type ObjectStyle = 'form' | 'deepObject'; 30 30 + //#endregion 31 31 + //#region src/core/bodySerializer.d.ts 32 32 + type QuerySerializer = (query: Record<string, unknown>) => string; 33 33 + type BodySerializer = (body: any) => any; 34 34 + type QuerySerializerOptionsObject = { 35 35 + allowReserved?: boolean; 36 36 + array?: Partial<SerializerOptions<ArrayStyle>>; 37 37 + object?: Partial<SerializerOptions<ObjectStyle>>; 38 38 + }; 39 39 + type QuerySerializerOptions = QuerySerializerOptionsObject & { 40 40 + /** 41 41 + * Per-parameter serialization overrides. When provided, these settings 42 42 + * override the global array/object settings for specific parameter names. 43 43 + */ 44 44 + parameters?: Record<string, QuerySerializerOptionsObject>; 45 45 + }; 46 46 + declare const formDataBodySerializer: { 47 47 + bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData; 48 48 + }; 49 49 + declare const jsonBodySerializer: { 50 50 + bodySerializer: <T>(body: T) => string; 51 51 + }; 52 52 + declare const urlSearchParamsBodySerializer: { 53 53 + bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string; 54 54 + }; 55 55 + //#endregion 56 56 + //#region src/core/types.d.ts 57 57 + interface Client$1<RequestFn$1 = never, Config$2 = unknown, MethodFn$1 = never, BuildUrlFn$1 = never> { 58 58 + /** 59 59 + * Returns the final request URL. 60 60 + */ 61 61 + buildUrl: BuildUrlFn$1; 62 62 + connect: MethodFn$1; 63 63 + delete: MethodFn$1; 64 64 + get: MethodFn$1; 65 65 + getConfig: () => Config$2; 66 66 + head: MethodFn$1; 67 67 + options: MethodFn$1; 68 68 + patch: MethodFn$1; 69 69 + post: MethodFn$1; 70 70 + put: MethodFn$1; 71 71 + request: RequestFn$1; 72 72 + setConfig: (config: Config$2) => Config$2; 73 73 + trace: MethodFn$1; 74 74 + } 75 75 + interface Config$1 { 76 76 + /** 77 77 + * Auth token or a function returning auth token. The resolved value will be 78 78 + * added to the request payload as defined by its `security` array. 79 79 + */ 80 80 + auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken; 81 81 + /** 82 82 + * A function for serializing request body parameter. By default, 83 83 + * {@link JSON.stringify()} will be used. 84 84 + */ 85 85 + bodySerializer?: BodySerializer | null; 86 86 + /** 87 87 + * An object containing any HTTP headers that you want to pre-populate your 88 88 + * `Headers` object with. 89 89 + * 90 90 + * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more} 91 91 + */ 92 92 + headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>; 93 93 + /** 94 94 + * The request method. 95 95 + * 96 96 + * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more} 97 97 + */ 98 98 + method?: 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE'; 99 99 + /** 100 100 + * A function for serializing request query parameters. By default, arrays 101 101 + * will be exploded in form style, objects will be exploded in deepObject 102 102 + * style, and reserved characters are percent-encoded. 103 103 + * 104 104 + * This method will have no effect if the native `paramsSerializer()` Axios 105 105 + * API function is used. 106 106 + * 107 107 + * {@link https://swagger.io/docs/specification/serialization/#query View examples} 108 108 + */ 109 109 + querySerializer?: QuerySerializer | QuerySerializerOptions; 110 110 + /** 111 111 + * A function validating request data. This is useful if you want to ensure 112 112 + * the request conforms to the desired shape, so it can be safely sent to 113 113 + * the server. 114 114 + */ 115 115 + requestValidator?: (data: unknown) => Promise<unknown>; 116 116 + /** 117 117 + * A function transforming response data before it's returned. This is useful 118 118 + * for post-processing data, e.g. converting ISO strings into Date objects. 119 119 + */ 120 120 + responseTransformer?: (data: unknown) => Promise<unknown>; 121 121 + /** 122 122 + * A function validating response data. This is useful if you want to ensure 123 123 + * the response conforms to the desired shape, so it can be safely passed to 124 124 + * the transformers and returned to the user. 125 125 + */ 126 126 + responseValidator?: (data: unknown) => Promise<unknown>; 127 127 + } 128 128 + //#endregion 129 129 + //#region src/utils.d.ts 130 130 + type ErrInterceptor<Err, Res, Req, Options$1> = (error: Err, response: Res, request: Req, options: Options$1) => Err | Promise<Err>; 131 131 + type ReqInterceptor<Req, Options$1> = (request: Req, options: Options$1) => Req | Promise<Req>; 132 132 + type ResInterceptor<Res, Req, Options$1> = (response: Res, request: Req, options: Options$1) => Res | Promise<Res>; 133 133 + declare class Interceptors<Interceptor> { 134 134 + fns: Array<Interceptor | null>; 135 135 + clear(): void; 136 136 + eject(id: number | Interceptor): void; 137 137 + exists(id: number | Interceptor): boolean; 138 138 + getInterceptorIndex(id: number | Interceptor): number; 139 139 + update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false; 140 140 + use(fn: Interceptor): number; 141 141 + } 142 142 + interface Middleware<Req, Res, Err, Options$1> { 143 143 + error: Interceptors<ErrInterceptor<Err, Res, Req, Options$1>>; 144 144 + request: Interceptors<ReqInterceptor<Req, Options$1>>; 145 145 + response: Interceptors<ResInterceptor<Res, Req, Options$1>>; 146 146 + } 147 147 + declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>; 148 148 + //#endregion 149 149 + //#region src/types.d.ts 150 150 + interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 { 151 151 + /** 152 152 + * Base URL for all requests made by this client. 153 153 + */ 154 154 + baseUrl?: T['baseUrl']; 155 155 + /** 156 156 + * Fetch API implementation. You can use this option to provide a custom 157 157 + * fetch instance. 158 158 + * 159 159 + * @default globalThis.fetch 160 160 + */ 161 161 + fetch?: (request: Request) => ReturnType<typeof fetch>; 162 162 + /** 163 163 + * Return the response data parsed in a specified format. By default, `auto` 164 164 + * will infer the appropriate method from the `Content-Type` response header. 165 165 + * You can override this behavior with any of the {@link Body} methods. 166 166 + * Select `stream` if you don't want to parse response data at all. 167 167 + * 168 168 + * @default 'auto' 169 169 + */ 170 170 + parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text'; 171 171 + /** 172 172 + * Throw an error instead of returning it in the response? 173 173 + * 174 174 + * @default false 175 175 + */ 176 176 + throwOnError?: T['throwOnError']; 177 177 + } 178 178 + interface RequestOptions<ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{ 179 179 + throwOnError: ThrowOnError; 180 180 + }> { 181 181 + /** 182 182 + * Any body that you want to add to your request. 183 183 + * 184 184 + * {@link https://developer.mozilla.org/docs/Web/API/fetch#body} 185 185 + */ 186 186 + body?: unknown; 187 187 + path?: Record<string, unknown>; 188 188 + query?: Record<string, unknown>; 189 189 + /** 190 190 + * Security mechanism(s) to use for the request. 191 191 + */ 192 192 + security?: ReadonlyArray<Auth>; 193 193 + url: Url; 194 194 + } 195 195 + type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{ 196 196 + data: TData; 197 197 + request: Request; 198 198 + response: Response; 199 199 + }> : Promise<({ 200 200 + data: TData; 201 201 + error: undefined; 202 202 + } | { 203 203 + data: undefined; 204 204 + error: TError; 205 205 + }) & { 206 206 + request: Request; 207 207 + response: Response; 208 208 + }>; 209 209 + interface ClientOptions { 210 210 + baseUrl?: string; 211 211 + throwOnError?: boolean; 212 212 + } 213 213 + type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError>; 214 214 + type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<ThrowOnError>, 'method'> & Pick<Required<RequestOptions<ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError>; 215 215 + type BuildUrlFn = <TData extends { 216 216 + body?: unknown; 217 217 + path?: Record<string, unknown>; 218 218 + query?: Record<string, unknown>; 219 219 + url: string; 220 220 + }>(options: Pick<TData, 'url'> & Options<TData>) => string; 221 221 + type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn> & { 222 222 + interceptors: Middleware<Request, Response, unknown, RequestOptions>; 223 223 + }; 224 224 + /** 225 225 + * The `createClientConfig()` function will be called on client initialization 226 226 + * and the returned object will become the client's initial configuration. 227 227 + * 228 228 + * You may want to initialize your client this way instead of calling 229 229 + * `setConfig()`. This is useful for example if you're using Next.js 230 230 + * to ensure your client always has the correct values. 231 231 + */ 232 232 + type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>; 233 233 + interface TDataShape { 234 234 + body?: unknown; 235 235 + headers?: unknown; 236 236 + path?: unknown; 237 237 + query?: unknown; 238 238 + url: string; 239 239 + } 240 240 + type OmitKeys<T, K$1> = Pick<T, Exclude<keyof T, K$1>>; 241 241 + type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>; 242 242 + //#endregion 243 243 + //#region src/client.d.ts 244 244 + declare const createClient: (config?: Config) => Client; 245 245 + //#endregion 246 246 + //#region src/core/params.d.ts 247 247 + type Slot = 'body' | 'headers' | 'path' | 'query'; 248 248 + type Field = { 249 249 + in: Exclude<Slot, 'body'>; 250 250 + key: string; 251 251 + map?: string; 252 252 + } | { 253 253 + in: Extract<Slot, 'body'>; 254 254 + key?: string; 255 255 + map?: string; 256 256 + }; 257 257 + interface Fields { 258 258 + allowExtra?: Partial<Record<Slot, boolean>>; 259 259 + args?: ReadonlyArray<Field>; 260 260 + } 261 261 + type FieldsConfig = ReadonlyArray<Field | Fields>; 262 262 + interface Params { 263 263 + body: unknown; 264 264 + headers: Record<string, unknown>; 265 265 + path: Record<string, unknown>; 266 266 + query: Record<string, unknown>; 267 267 + } 268 268 + declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params; 269 269 + //# sourceMappingURL=index.d.mts.map 270 270 + 271 271 + export { type Auth, type Client, type ClientOptions, type Config, type CreateClientConfig, type Options, type QuerySerializerOptions, type RequestOptions, type RequestResult, type TDataShape, buildClientParams, createClient, createConfig, formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer };

+1 -1

packages/openapi-ts/src/generate/client.ts

··· 213 213 214 214 const indexJsFile = 215 215 clientModulePathComponents[clientModulePathComponents.length - 1]; 216 216 - const distFiles = [indexJsFile!, 'index.d.ts', 'index.d.cts']; 216 216 + const distFiles = [indexJsFile!, 'index.d.mts', 'index.d.cts']; 217 217 const dirPath = path.resolve(outputPath, 'client'); 218 218 ensureDirSync(dirPath); 219 219 for (const file of distFiles) {