@genapi/presets 3.7.1 → 4.1.0

package/LICENSE.md

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

package/README.md

@@ -0,0 +1,36 @@
+# @genapi/presets
+
+<!-- automd:badges -->
+
+[![npm version](https://img.shields.io/npm/v/@genapi/presets)](https://npmjs.com/package/@genapi/presets)
+[![npm downloads](https://img.shields.io/npm/dm/@genapi/presets)](https://npm.chart.dev/@genapi/presets)
+
+<!-- /automd -->
+
+Prebuilt HTTP client pipelines (axios, fetch, ky, got, ofetch, uni) with TypeScript/JavaScript generation support.
+
+## Installation
+
+```bash
+pnpm add @genapi/presets
+```
+
+## API
+
+<!-- automd:jsdocs src=src/index.ts -->
+
+<!-- ⚠️  (jsdocs) (0 , _parser.createParser) is not a function -->
+
+<!-- /automd -->
+
+## License
+
+[MIT](https://github.com/hairyf/genapi/blob/main/LICENSE)
+
+<!-- automd:with-automd -->
+
+---
+
+_🤖 auto updated with [automd](https://automd.unjs.io)_
+
+<!-- /automd -->

package/dist/_shared/query/config.d.mts

@@ -0,0 +1,14 @@
+import { ApiPipeline } from "@genapi/shared";
+
+//#region src/_shared/query/config.d.ts
+/** Query preset Default Output: main(hooks)、api(apis)、type(types)；Query preset only effective output.main / output.api / output.type；type is false, not default api, keep single file main */
+declare function ensureQueryOutput(userConfig: ApiPipeline.Config): void;
+/** main import api file (apis.xxx reference); api import type file (Types reference) */
+declare function addApiImportToMain(configRead: ApiPipeline.ConfigRead): void;
+interface QueryConfigOptions {
+  /** Query library name (e.g., @pinia/colada, @tanstack/react-query, @tanstack/vue-query) */
+  queryLibrary: string;
+}
+declare function createQueryConfig(options: QueryConfigOptions | string): (userConfig: ApiPipeline.Config) => ApiPipeline.ConfigRead;
+//#endregion
+export { QueryConfigOptions, addApiImportToMain, createQueryConfig, ensureQueryOutput };

package/dist/_shared/query/config.mjs

@@ -0,0 +1,58 @@
+import { config } from "@genapi/pipeline";
+import { inject } from "@genapi/shared";
+import path from "node:path";
+
+//#region src/_shared/query/config.ts
+/** Query preset Default Output: main(hooks)、api(apis)、type(types)；Query preset only effective output.main / output.api / output.type；type is false, not default api, keep single file main */
+function ensureQueryOutput(userConfig) {
+	userConfig.output = userConfig.output && typeof userConfig.output === "object" ? userConfig.output : {};
+	const out = userConfig.output;
+	out.main = out.main ?? "src/api/index.ts";
+	out.type = out.type !== false ? out.type ?? (typeof out.main === "string" ? out.main.replace(/\.(ts|js)$/, ".type.ts") : "src/api/index.type.ts") : false;
+	if (out.type !== false) out.api = out.api ?? (typeof out.main === "string" ? out.main.replace(/index\.(ts|js)$/, "index.api.$1") : "src/api/index.api.ts");
+}
+/** main import api file (apis.xxx reference); api import type file (Types reference) */
+function addApiImportToMain(configRead) {
+	const mainOut = configRead.outputs.find((o) => o.type === "main");
+	const apiOut = configRead.outputs.find((o) => o.type === "api");
+	const typeOut = configRead.outputs.find((o) => o.type === "type");
+	const { imports } = inject();
+	if (mainOut && apiOut) {
+		const rel = path.relative(path.dirname(mainOut.path), apiOut.path).replace(/\.(ts|js)$/, "");
+		const value = (rel.startsWith(".") ? rel : `./${rel}`).replace(/\\/g, "/");
+		imports.add("main", {
+			value,
+			namespace: true,
+			name: "apis"
+		});
+	}
+	if (apiOut && typeOut) {
+		const rel = path.relative(path.dirname(apiOut.path), typeOut.path).replace(/\.(ts|js)$/, "");
+		const value = (rel.startsWith(".") ? rel : `./${rel}`).replace(/\\/g, "/");
+		imports.add("api", {
+			value,
+			namespace: true,
+			name: "Types",
+			type: true
+		});
+	}
+}
+function createQueryConfig(options) {
+	const queryLibrary = typeof options === "string" ? options : options.queryLibrary;
+	return function config$1(userConfig) {
+		userConfig.meta = userConfig.meta || {};
+		userConfig.meta.import = userConfig.meta.import || {};
+		ensureQueryOutput(userConfig);
+		const configRead = config(userConfig);
+		const { imports } = inject();
+		addApiImportToMain(configRead);
+		imports.add("main", {
+			names: ["useQuery", "useMutation"],
+			value: queryLibrary
+		});
+		return configRead;
+	};
+}
+
+//#endregion
+export { addApiImportToMain, createQueryConfig, ensureQueryOutput };

package/dist/_shared/query/index.d.mts

@@ -0,0 +1,3 @@
+import { QueryConfigOptions, addApiImportToMain, createQueryConfig, ensureQueryOutput } from "./config.mjs";
+import { createQueryParser } from "./parser.mjs";
+export { type QueryConfigOptions, addApiImportToMain, createQueryConfig, createQueryParser, ensureQueryOutput };

package/dist/_shared/query/index.mjs

@@ -0,0 +1,4 @@
+import { addApiImportToMain, createQueryConfig, ensureQueryOutput } from "./config.mjs";
+import { createQueryParser } from "./parser.mjs";
+
+export { addApiImportToMain, createQueryConfig, createQueryParser, ensureQueryOutput };

package/dist/_shared/query/parser.d.mts

@@ -0,0 +1,7 @@
+import * as _genapi_shared0 from "@genapi/shared";
+
+//#region src/_shared/query/parser.d.ts
+/** Query preset 统一 parser：固定三文件，useQuery(queryKey, queryFn)、useMutation(mutationFn)，description 统一 @wraps */
+declare function createQueryParser(): (configRead: _genapi_shared0.ApiPipeline.ConfigRead) => _genapi_shared0.ApiPipeline.ConfigRead;
+//#endregion
+export { createQueryParser };

package/dist/_shared/query/parser.mjs

@@ -0,0 +1,75 @@
+import { createParser, parseMethodMetadata, parseMethodParameters, transformBodyStringify, transformFetchBody, transformHeaderOptions, transformParameters, transformQueryParams, transformUrlSyntax } from "@genapi/parser";
+
+//#region src/_shared/query/parser.ts
+function hookName(fetcherName) {
+	return `use${fetcherName.charAt(0).toUpperCase()}${fetcherName.slice(1)}`;
+}
+/** Query preset 统一 parser：固定三文件，useQuery(queryKey, queryFn)、useMutation(mutationFn)，description 统一 @wraps */
+function createQueryParser() {
+	return createParser((config, { configRead, functions, interfaces }) => {
+		const { parameters, interfaces: attachInters, options: optList } = parseMethodParameters(config);
+		let { name, description, url, responseType, body } = parseMethodMetadata(config);
+		attachInters.forEach((i) => interfaces.add("type", i));
+		const fetcherParams = [...parameters];
+		fetcherParams.push({
+			name: "config",
+			type: "RequestInit",
+			required: false
+		});
+		if (config.method.toLowerCase() !== "get") optList.unshift(["method", `"${config.method}"`]);
+		transformHeaderOptions("body", {
+			options: optList,
+			parameters
+		});
+		optList.push(["...", "config"]);
+		const { spaceResponseType } = transformParameters(parameters, {
+			syntax: "typescript",
+			interfaces: interfaces.all(),
+			configRead,
+			description,
+			responseType
+		});
+		transformBodyStringify("body", {
+			options: optList,
+			parameters
+		});
+		url = transformQueryParams("query", {
+			body,
+			options: optList,
+			url
+		});
+		url = transformUrlSyntax(url, { baseURL: configRead.config.meta?.baseURL });
+		const fetchBody = transformFetchBody(url, optList, spaceResponseType);
+		const fetcherRef = `apis.${name}`;
+		functions.add("api", {
+			export: true,
+			async: true,
+			name,
+			description,
+			parameters: fetcherParams,
+			body: [...body, ...fetchBody]
+		});
+		const isRead = ["get", "head"].includes(config.method.toLowerCase());
+		const hook = hookName(name);
+		const paramNames = fetcherParams.map((p) => p.name).join(", ");
+		if (isRead) {
+			const keyItems = `${fetcherRef}.name, ${paramNames}`;
+			functions.add("main", {
+				export: true,
+				name: hook,
+				description: [`@wraps ${name}`],
+				parameters: fetcherParams,
+				body: [`return useQuery({ queryKey: [${keyItems}], queryFn: () => ${fetcherRef}(${paramNames}) })`]
+			});
+		} else functions.add("main", {
+			export: true,
+			name: hook,
+			description: [`@wraps ${name}`],
+			parameters: [],
+			body: [`return useMutation({ mutationFn: ${fetcherRef} })`]
+		});
+	});
+}
+
+//#endregion
+export { createQueryParser };

package/dist/_shared/schema/compiler.d.mts

@@ -0,0 +1,10 @@
+import { ApiPipeline } from "@genapi/shared";
+
+//#region src/_shared/schema/compiler.d.ts
+interface SchemaCompilerOptions {
+  /** HTTP client function name (e.g., 'fetch' or 'ofetch') */
+  httpClient: string;
+}
+declare function createSchemaCompiler(options: SchemaCompilerOptions): (config: ApiPipeline.ConfigRead) => ApiPipeline.ConfigRead<ApiPipeline.Config>;
+//#endregion
+export { SchemaCompilerOptions, createSchemaCompiler };

package/dist/_shared/schema/compiler.mjs

@@ -0,0 +1,70 @@
+import { compile } from "@genapi/pipeline";
+import { genInterface, genTypeObject } from "knitwork-x";
+
+//#region src/_shared/schema/compiler.ts
+const [Endpoint, Dynamic] = [Symbol.for("Endpoint"), Symbol.for("DynamicParam")];
+/** Ultimate type conversion: regex word boundary replacement, covering all complex nested scenarios */
+function convert(str, names) {
+	return str?.replace(/\b\w+\b/g, (m) => names.has(m) ? `Types.${m}` : m) || "";
+}
+function createSchemaCompiler(options) {
+	return function compiler(config) {
+		const routes = config.__schemaRoutes || [];
+		const allInterfaces = [...config.graphs.scopes.main?.interfaces || [], ...config.graphs.scopes.type?.interfaces || []];
+		const allTypings = config.graphs.scopes.type?.typings || [];
+		const interfaceNames = new Set([...allInterfaces.map((i) => i.name), ...allTypings.filter((t) => t.name && !t.value?.includes("{")).map((t) => t.name)]);
+		const tree = routes.reduce((root, r) => {
+			const node = r.path.split("/").filter(Boolean).reduce((curr, p) => {
+				const key = p.startsWith("{") ? Dynamic : p;
+				return curr[key] = curr[key] || {};
+			}, root);
+			const ep = node[Endpoint] = node[Endpoint] || {};
+			ep[r.method] = genTypeObject({
+				response: convert(r.responseType, interfaceNames),
+				...r.queryType && { query: convert(r.queryType, interfaceNames) },
+				...r.bodyType && { body: convert(r.bodyType, interfaceNames) },
+				...r.headersType && { headers: convert(r.headersType, interfaceNames) }
+			});
+			return root;
+		}, {});
+		const toObj = (node, isRoot = false) => {
+			const res = {};
+			if (node[Endpoint]) res["[Endpoint]"] = genTypeObject(node[Endpoint]);
+			if (node[Dynamic]) res["[DynamicParam]"] = genTypeObject(toObj(node[Dynamic]));
+			Object.keys(node).forEach((k) => res[isRoot ? `/${k}` : k] = genTypeObject(toObj(node[k])));
+			return res;
+		};
+		config.graphs.scopes.main.functions = [{
+			export: true,
+			name: "$fetch",
+			async: true,
+			generics: [{
+				name: "T",
+				extends: "TypedFetchInput<APISchema>"
+			}],
+			parameters: [{
+				name: "input",
+				type: "T",
+				required: true
+			}, {
+				name: "init",
+				type: "TypedFetchRequestInit<APISchema, T>",
+				required: false
+			}],
+			body: [`return ${options.httpClient}(input, init as any) as Promise<TypedResponse<TypedFetchResponseBody<APISchema, T>>>`]
+		}];
+		config.outputs.forEach((out) => {
+			if (out.type === "main" && !config.config.meta?.onlyDeclaration) {
+				const code = compile(config, "main");
+				const schema = `\n// API Schema\n${genInterface("APISchema", toObj(tree, true))}\n`;
+				const idx = code.lastIndexOf("import");
+				const pos = idx !== -1 ? code.indexOf("\n", idx) + 1 : 0;
+				out.code = code.slice(0, pos) + schema + code.slice(pos);
+			} else if (out.type === "type") out.code = compile(config, "type");
+		});
+		return config;
+	};
+}
+
+//#endregion
+export { createSchemaCompiler };

package/dist/_shared/schema/config.d.mts

@@ -0,0 +1,12 @@
+import { ApiPipeline } from "@genapi/shared";
+
+//#region src/_shared/schema/config.d.ts
+interface SchemaConfigOptions {
+  /** HTTP client package name (e.g., 'ofetch') */
+  httpPackage?: string;
+  /** HTTP client function name to import (e.g., 'ofetch') */
+  httpClientName?: string;
+}
+declare function createSchemaConfig(options?: SchemaConfigOptions): (userConfig: ApiPipeline.Config) => ApiPipeline.ConfigRead;
+//#endregion
+export { SchemaConfigOptions, createSchemaConfig };

package/dist/_shared/schema/config.mjs

@@ -0,0 +1,48 @@
+import { config } from "@genapi/pipeline";
+import { inject } from "@genapi/shared";
+
+//#region src/_shared/schema/config.ts
+function createSchemaConfig(options = {}) {
+	return function config$1(userConfig) {
+		userConfig.meta = userConfig.meta || {};
+		userConfig.meta.import = userConfig.meta.import || {};
+		if (options.httpPackage && options.httpClientName) {
+			userConfig.meta.import.http = userConfig.meta.import.http || options.httpPackage;
+			const configRead = config(userConfig);
+			const { imports } = inject();
+			imports.add("main", {
+				names: [options.httpClientName],
+				value: userConfig.meta.import.http
+			});
+			imports.add("main", {
+				names: [
+					"TypedFetchInput",
+					"TypedFetchRequestInit",
+					"TypedFetchResponseBody",
+					"TypedResponse",
+					"Endpoint",
+					"DynamicParam"
+				],
+				value: "fetchdts"
+			});
+			return configRead;
+		}
+		const configRead = config(userConfig);
+		const { imports } = inject();
+		imports.add("main", {
+			names: [
+				"TypedFetchInput",
+				"TypedFetchRequestInit",
+				"TypedFetchResponseBody",
+				"TypedResponse",
+				"Endpoint",
+				"DynamicParam"
+			],
+			value: "fetchdts"
+		});
+		return configRead;
+	};
+}
+
+//#endregion
+export { createSchemaConfig };

package/dist/_shared/schema/index.d.mts

@@ -0,0 +1,4 @@
+import { SchemaCompilerOptions, createSchemaCompiler } from "./compiler.mjs";
+import { SchemaConfigOptions, createSchemaConfig } from "./config.mjs";
+import { SchemaRoute, schemaParser } from "./parser.mjs";
+export { type SchemaCompilerOptions, type SchemaConfigOptions, type SchemaRoute, createSchemaCompiler, createSchemaConfig, schemaParser };

package/dist/_shared/schema/index.mjs

@@ -0,0 +1,5 @@
+import { createSchemaCompiler } from "./compiler.mjs";
+import { createSchemaConfig } from "./config.mjs";
+import { schemaParser } from "./parser.mjs";
+
+export { createSchemaCompiler, createSchemaConfig, schemaParser };

package/dist/_shared/schema/parser.d.mts

@@ -0,0 +1,14 @@
+import * as _genapi_shared0 from "@genapi/shared";
+
+//#region src/_shared/schema/parser.d.ts
+interface SchemaRoute {
+  path: string;
+  method: string;
+  queryType?: string;
+  bodyType?: string;
+  headersType?: string;
+  responseType: string;
+}
+declare const schemaParser: (configRead: _genapi_shared0.ApiPipeline.ConfigRead) => _genapi_shared0.ApiPipeline.ConfigRead;
+//#endregion
+export { SchemaRoute, schemaParser };

package/dist/_shared/schema/parser.mjs

@@ -0,0 +1,49 @@
+import { createParser, parseSchemaType } from "@genapi/parser";
+
+//#region src/_shared/schema/parser.ts
+function hasContent(r) {
+	return r != null && typeof r === "object" && "content" in r;
+}
+function getResponseType(responses) {
+	const resDefault = responses.default && hasContent(responses.default) ? responses.default : null;
+	const res200 = responses["200"] && typeof responses["200"] === "object" ? responses["200"] : null;
+	const contentDefault = resDefault?.content?.["application/json"];
+	const content200 = res200 && hasContent(res200) ? res200.content?.["application/json"] : null;
+	const schemaFromContent = (contentDefault && typeof contentDefault === "object" && "schema" in contentDefault ? contentDefault.schema : null) ?? (content200 && typeof content200 === "object" && "schema" in content200 ? content200.schema : null);
+	const schemaFromRes200 = res200 && typeof res200 === "object" && "schema" in res200 && !("content" in res200) ? res200.schema : null;
+	const responseSchema = schemaFromContent ?? schemaFromRes200;
+	return responseSchema && typeof responseSchema === "object" ? parseSchemaType(responseSchema) : "void";
+}
+const schemaParser = createParser((config, { configRead }) => {
+	const { path, method, responses, parameters } = config;
+	const queryParams = parameters.filter((p) => p.in === "query");
+	const headerParams = parameters.filter((p) => p.in === "header");
+	const bodyParams = parameters.filter((p) => p.in === "body");
+	const responseType = getResponseType(responses);
+	let queryType;
+	if (queryParams.length > 0) queryType = `{ ${queryParams.map((p) => {
+		const type = parseSchemaType(p);
+		const optional = p.required ? "" : "?";
+		return `${p.name}${optional}: ${type}`;
+	}).join("; ")} }`;
+	let bodyType;
+	if (bodyParams.length > 0) bodyType = parseSchemaType(bodyParams[0]);
+	let headersType;
+	if (headerParams.length > 0) headersType = `{ ${headerParams.map((p) => {
+		const type = parseSchemaType(p);
+		const optional = p.required ? "" : "?";
+		return `'${p.name}'${optional}: ${type}`;
+	}).join("; ")} }`;
+	configRead.__schemaRoutes = configRead.__schemaRoutes || [];
+	configRead.__schemaRoutes.push({
+		path,
+		method: method.toUpperCase(),
+		queryType,
+		bodyType,
+		headersType,
+		responseType
+	});
+});
+
+//#endregion
+export { schemaParser };

package/dist/axios/index.d.mts

@@ -1,9 +1,9 @@
-import "../index.d-C_cfONoz.mjs";
-import "../index.d-Oclhn_rY.mjs";
-import { openapiPipeline$6 as openapiPipeline } from "../index.d-DJrTX9xf.mjs";
-import "../index.d-BumPVmi6.mjs";
-import "../index.d-SEFhGKxl.mjs";
-import { openapiPipeline$2 as openapiPipeline$1 } from "../index.d-fRobkY_s.mjs";
-import "../index.d-CJvL62Un.mjs";
+import openapiPipeline from "./js/index.mjs";
+import openapiPipeline$1 from "./ts/index.mjs";
 
-export { openapiPipeline as js, openapiPipeline$1 as ts };
+//#region src/axios/index.d.ts
+declare namespace index_d_exports {
+  export { openapiPipeline as js, openapiPipeline$1 as ts };
+}
+//#endregion
+export { openapiPipeline as js, index_d_exports as t, openapiPipeline$1 as ts };

package/dist/axios/index.mjs

@@ -1,9 +1,12 @@
-import "../config-CTDgiXdv.mjs";
-import "../parser-DqCzNFba.mjs";
-import { js_default$2 as js_default } from "../js-DrRwXaos.mjs";
-import "../config-Bt-OVtrF.mjs";
-import "../parser-ie6DpPJX.mjs";
-import { ts_default$1 as ts_default } from "../ts-UnhKokN_.mjs";
-import "../axios-C-GYxVyS.mjs";
+import { t as __exportAll } from "../chunk-DQk6qfdC.mjs";
+import openapiPipeline from "./js/index.mjs";
+import openapiPipeline$1 from "./ts/index.mjs";
 
-export { js_default as js, ts_default as ts };
+//#region src/axios/index.ts
+var axios_exports = /* @__PURE__ */ __exportAll({
+	js: () => openapiPipeline,
+	ts: () => openapiPipeline$1
+});
+
+//#endregion
+export { openapiPipeline as js, axios_exports as t, openapiPipeline$1 as ts };

package/dist/axios/js/config/index.d.mts

@@ -1,3 +1,6 @@
-import { config$12 as config } from "../../../index.d-Oclhn_rY.mjs";
+import { ApiPipeline } from "@genapi/shared";
 
+//#region src/axios/js/config/index.d.ts
+declare function config(userConfig: ApiPipeline.Config): ApiPipeline.ConfigRead;
+//#endregion
 export { config };

package/dist/axios/js/config/index.mjs

@@ -1,3 +1,22 @@
-import { config$4 as config } from "../../../config-CTDgiXdv.mjs";
+import { config as config$1 } from "@genapi/pipeline";
+import { replaceMainext } from "@genapi/parser";
+import { inject } from "@genapi/shared";
 
+//#region src/axios/js/config/index.ts
+function config(userConfig) {
+	userConfig.meta = userConfig.meta || {};
+	userConfig.meta.import = userConfig.meta.import || {};
+	userConfig.output = userConfig.output || {};
+	userConfig.meta.import.http = userConfig.meta.import.http || "axios";
+	userConfig.output = replaceMainext(userConfig.output) || "src/api/index.js";
+	const configRead = config$1(userConfig);
+	const { imports } = inject();
+	imports.add("main", {
+		name: "http",
+		value: userConfig.meta.import.http
+	});
+	return configRead;
+}
+
+//#endregion
 export { config };

package/dist/axios/js/index.d.mts

@@ -1,5 +1,18 @@
-import { parser$14 as parser } from "../../index.d-C_cfONoz.mjs";
-import { config$12 as config } from "../../index.d-Oclhn_rY.mjs";
-import { compiler$18 as compiler, dest$18 as dest, generate$18 as generate, openapiPipeline$6 as openapiPipeline, original$18 as original } from "../../index.d-DJrTX9xf.mjs";
+import { config } from "./config/index.mjs";
+import { parser } from "./parser/index.mjs";
+import * as _genapi_pipeline0 from "@genapi/pipeline";
+import { compiler, dest, generate, original } from "@genapi/pipeline";
+import { ApiPipeline } from "@genapi/shared";
 
+//#region src/axios/js/index.d.ts
+declare function openapiPipeline(userConfig: ApiPipeline.Config): Promise<void>;
+declare namespace openapiPipeline {
+  var config: typeof config;
+  var original: typeof _genapi_pipeline0.original;
+  var parser: (configRead: ApiPipeline.ConfigRead) => ApiPipeline.ConfigRead;
+  var compiler: typeof _genapi_pipeline0.compiler;
+  var generate: typeof _genapi_pipeline0.generate;
+  var dest: typeof _genapi_pipeline0.dest;
+}
+//#endregion
 export { compiler, config, openapiPipeline as default, dest, generate, original, parser };

package/dist/axios/js/index.mjs

@@ -1,5 +1,17 @@
-import { config$4 as config } from "../../config-CTDgiXdv.mjs";
-import { parser$4 as parser } from "../../parser-DqCzNFba.mjs";
-import { compiler$4 as compiler, dest$4 as dest, generate$4 as generate, js_default$2 as js_default, original$4 as original } from "../../js-DrRwXaos.mjs";
+import { config } from "./config/index.mjs";
+import { parser } from "./parser/index.mjs";
+import pipeline, { compiler, dest, generate, original } from "@genapi/pipeline";
 
-export { compiler, config, js_default as default, dest, generate, original, parser };
+//#region src/axios/js/index.ts
+function openapiPipeline(userConfig) {
+	return pipeline((userConfig) => config(userConfig), (configRead) => original(configRead), (configRead) => parser(configRead), (configRead) => compiler(configRead), (configRead) => generate(configRead), (configRead) => dest(configRead))(userConfig);
+}
+openapiPipeline.config = config;
+openapiPipeline.original = original;
+openapiPipeline.parser = parser;
+openapiPipeline.compiler = compiler;
+openapiPipeline.generate = generate;
+openapiPipeline.dest = dest;
+
+//#endregion
+export { compiler, config, openapiPipeline as default, dest, generate, original, parser };

package/dist/axios/js/parser/index.d.mts

@@ -1,3 +1,6 @@
-import { PathsTransformOptions$2 as PathsTransformOptions, parser$14 as parser, transformPaths$14 as transformPaths } from "../../../index.d-C_cfONoz.mjs";
+import * as _genapi_shared0 from "@genapi/shared";
 
-export { PathsTransformOptions, parser, transformPaths };
+//#region src/axios/js/parser/index.d.ts
+declare const parser: (configRead: _genapi_shared0.ApiPipeline.ConfigRead) => _genapi_shared0.ApiPipeline.ConfigRead;
+//#endregion
+export { parser };

package/dist/axios/js/parser/index.mjs

@@ -1,3 +1,39 @@
-import { parser$4 as parser, transformPaths$4 as transformPaths } from "../../../parser-DqCzNFba.mjs";
+import { createParser, literalFieldsToString, parseMethodMetadata, parseMethodParameters, transformParameters, transformUrlSyntax } from "@genapi/parser";
 
-export { parser, transformPaths };
+//#region src/axios/js/parser/index.ts
+const parser = createParser((config, { configRead, functions, interfaces }) => {
+	const { parameters, interfaces: attachInters, options } = parseMethodParameters(config, {
+		body: "data",
+		query: "params"
+	});
+	let { name, description, url, responseType } = parseMethodMetadata(config);
+	options.push(["...", "config"]);
+	attachInters.forEach((i) => interfaces.add("type", i));
+	parameters.push({
+		type: "import('axios').AxiosRequestConfig",
+		name: "config",
+		required: false
+	});
+	options.unshift("url");
+	options.unshift(["method", `"${config.method}"`]);
+	if (configRead.config.meta?.baseURL) options.unshift("baseURL");
+	transformParameters(parameters, {
+		syntax: "ecmascript",
+		configRead,
+		description,
+		interfaces: interfaces.all(),
+		responseType,
+		generic: "import('axios').AxiosResponse<{__type__}>"
+	});
+	url = transformUrlSyntax(url);
+	functions.add("main", {
+		export: true,
+		name,
+		description,
+		parameters,
+		body: [`const url = ${url}`, `return http.request({ ${literalFieldsToString(options)} })`]
+	});
+});
+
+//#endregion
+export { parser };