orval 8.4.1 → 8.5.0

package/dist/bin/orval.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as name, i as startWatcher, l as version, n as loadConfigFile, o as normalizeOptions, r as generateSpec, s as description, t as findConfigFile } from "../config-glSQmAy7.mjs";
+import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-By98GXtB.mjs";
 import path from "node:path";
 import { Option, program } from "@commander-js/extra-typings";
 import { ErrorWithTag, OutputClient, OutputMode, isString, log, logError, setVerbose, startMessage } from "@orval/core";

package/dist/{config-glSQmAy7.mjs → config-By98GXtB.mjs}

@@ -3,6 +3,7 @@ import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient,
 import { bundle } from "@scalar/json-magic/bundle";
 import { fetchUrls, parseJson, parseYaml, readFiles } from "@scalar/json-magic/bundle/plugins/node";
 import { upgrade, validate } from "@scalar/openapi-parser";
+import { isNullish as isNullish$1, unique } from "remeda";
 import * as mock from "@orval/mock";
 import { DEFAULT_MOCK_OPTIONS, generateMockImports } from "@orval/mock";
 import angular from "@orval/angular";
@@ -14,10 +15,9 @@ import query from "@orval/query";
 import solidStart from "@orval/solid-start";
 import swr from "@orval/swr";
 import zod, { dereference, generateZodValidationSchemaDefinition, isZodVersionV4, parseZodValidationSchemaDefinition } from "@orval/zod";
-import chalk from "chalk";
+import { styleText } from "node:util";
 import { ExecaError, execa } from "execa";
 import fs from "fs-extra";
-import { unique } from "remeda";
 import fs$1 from "node:fs/promises";
 import { parseArgsStringToArgv } from "string-argv";
 import { findUp, findUpMultiple } from "find-up";
@@ -29,7 +29,7 @@ import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
 var description = "A swagger client generator for typescript";
-var version = "8.4.1";
+var version = "8.5.0";
 
 //#endregion
 //#region src/client.ts
@@ -174,9 +174,9 @@ const generateOperations = (outputClient = DEFAULT_CLIENT, verbsOptions, options
 	}, {});
 };
 const generateExtraFiles = (outputClient = DEFAULT_CLIENT, verbsOptions, output, context) => {
-	const { extraFiles: generateExtraFiles$1 } = getGeneratorClient(outputClient, output);
-	if (!generateExtraFiles$1) return Promise.resolve([]);
-	return generateExtraFiles$1(verbsOptions, output, context);
+	const { extraFiles: generateExtraFiles } = getGeneratorClient(outputClient, output);
+	if (!generateExtraFiles) return Promise.resolve([]);
+	return generateExtraFiles(verbsOptions, output, context);
 };
 
 //#endregion
@@ -312,7 +312,7 @@ async function resolveSpec(input, parserOptions) {
 			parseJson(),
 			parseYaml()
 		],
-		treeShake: true
+		treeShake: false
 	}));
 	const { valid, errors } = await validate(dereferencedData);
 	if (!valid) throw new Error("Validation failed", { cause: errors });
@@ -333,55 +333,125 @@ async function importSpecs(workspace, options, projectName) {
 /**
 * The plugins from `@scalar/json-magic` does not dereference $ref.
 * Instead it fetches them and puts them under x-ext, and changes the $ref to point to #x-ext/<name>.
-* This function dereferences those x-ext $ref's.
+* This function:
+* 1. Merges external schemas into main spec's components.schemas (with collision handling)
+* 2. Replaces x-ext refs with standard component refs or inlined content
 */
 function dereferenceExternalRef(data) {
 	const extensions = data["x-ext"] ?? {};
+	const schemaNameMappings = mergeExternalSchemas(data, extensions);
+	const result = {};
+	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceXExtRefs(value, extensions, schemaNameMappings);
+	return result;
+}
+/**
+* Merge external document schemas into main spec's components.schemas
+* Returns mapping of original schema names to final names (with suffixes for collisions)
+*/
+function mergeExternalSchemas(data, extensions) {
+	const schemaNameMappings = {};
+	data.components ??= {};
+	const mainComponents = data.components;
+	mainComponents.schemas ??= {};
+	const mainSchemas = mainComponents.schemas;
+	for (const [extKey, extDoc] of Object.entries(extensions)) {
+		schemaNameMappings[extKey] = {};
+		if (isObject(extDoc) && "components" in extDoc) {
+			const extComponents = extDoc.components;
+			if (isObject(extComponents) && "schemas" in extComponents) {
+				const extSchemas = extComponents.schemas;
+				for (const [schemaName, schema] of Object.entries(extSchemas)) {
+					const existingSchema = mainSchemas[schemaName];
+					const isXExtRef = isObject(existingSchema) && "$ref" in existingSchema && isString(existingSchema.$ref) && existingSchema.$ref.startsWith("#/x-ext/");
+					let finalSchemaName = schemaName;
+					if (schemaName in mainSchemas && !isXExtRef) {
+						finalSchemaName = `${schemaName}_${extKey.replaceAll(/[^a-zA-Z0-9]/g, "_")}`;
+						schemaNameMappings[extKey][schemaName] = finalSchemaName;
+					} else schemaNameMappings[extKey][schemaName] = schemaName;
+					mainSchemas[finalSchemaName] = scrubUnwantedKeys(schema);
+				}
+			}
+		}
+	}
+	for (const [extKey, mapping] of Object.entries(schemaNameMappings)) for (const [, finalName] of Object.entries(mapping)) {
+		const schema = mainSchemas[finalName];
+		if (schema) mainSchemas[finalName] = updateInternalRefs(schema, extKey, schemaNameMappings);
+	}
+	return schemaNameMappings;
+}
+/**
+* Remove unwanted keys like $schema and $id from objects
+*/
+function scrubUnwantedKeys(obj) {
 	const UNWANTED_KEYS = new Set(["$schema", "$id"]);
-	function scrub(obj) {
-		if (obj === null || obj === void 0) return obj;
-		if (Array.isArray(obj)) return obj.map((x) => scrub(x));
-		if (isObject(obj)) {
-			const rec = obj;
-			const out = {};
-			for (const [k, v] of Object.entries(rec)) {
-				if (UNWANTED_KEYS.has(k)) continue;
-				out[k] = scrub(v);
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((x) => scrubUnwantedKeys(x));
+	if (isObject(obj)) {
+		const rec = obj;
+		const out = {};
+		for (const [k, v] of Object.entries(rec)) {
+			if (UNWANTED_KEYS.has(k)) continue;
+			out[k] = scrubUnwantedKeys(v);
+		}
+		return out;
+	}
+	return obj;
+}
+/**
+* Update internal refs within an external schema to use suffixed names
+*/
+function updateInternalRefs(obj, extKey, schemaNameMappings) {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((element) => updateInternalRefs(element, extKey, schemaNameMappings));
+	if (isObject(obj)) {
+		const record = obj;
+		if ("$ref" in record && isString(record.$ref)) {
+			const refValue = record.$ref;
+			if (refValue.startsWith("#/components/schemas/")) {
+				const schemaName = refValue.replace("#/components/schemas/", "");
+				const mappedName = schemaNameMappings[extKey][schemaName];
+				if (mappedName) return { $ref: `#/components/schemas/${mappedName}` };
 			}
-			return out;
 		}
-		return obj;
+		const result = {};
+		for (const [key, value] of Object.entries(record)) result[key] = updateInternalRefs(value, extKey, schemaNameMappings);
+		return result;
 	}
-	function replaceRefs(obj) {
-		if (obj === null || obj === void 0) return obj;
-		if (Array.isArray(obj)) return obj.map((element) => replaceRefs(element));
-		if (isObject(obj)) {
-			const record = obj;
-			if ("$ref" in record && isString(record.$ref)) {
-				const refValue = record.$ref;
-				if (refValue.startsWith("#/x-ext/")) {
-					const parts = refValue.replace("#/x-ext/", "").split("/");
-					const extKey = parts.shift();
-					if (extKey) {
-						let refObj = extensions[extKey];
-						for (const p of parts) if (refObj && (isObject(refObj) || Array.isArray(refObj)) && p in refObj) refObj = refObj[p];
-						else {
-							refObj = void 0;
-							break;
-						}
-						if (refObj) return replaceRefs(scrub(refObj));
+	return obj;
+}
+/**
+* Replace x-ext refs with either standard component refs or inlined content
+*/
+function replaceXExtRefs(obj, extensions, schemaNameMappings) {
+	if (isNullish$1(obj)) return obj;
+	if (Array.isArray(obj)) return obj.map((element) => replaceXExtRefs(element, extensions, schemaNameMappings));
+	if (isObject(obj)) {
+		const record = obj;
+		if ("$ref" in record && isString(record.$ref)) {
+			const refValue = record.$ref;
+			if (refValue.startsWith("#/x-ext/")) {
+				const parts = refValue.replace("#/x-ext/", "").split("/");
+				const extKey = parts.shift();
+				if (extKey) {
+					if (parts.length >= 3 && parts[0] === "components" && parts[1] === "schemas") {
+						const schemaName = parts.slice(2).join("/");
+						return { $ref: `#/components/schemas/${schemaNameMappings[extKey][schemaName] || schemaName}` };
 					}
+					let refObj = extensions[extKey];
+					for (const p of parts) if (refObj && (isObject(refObj) || Array.isArray(refObj)) && p in refObj) refObj = refObj[p];
+					else {
+						refObj = void 0;
+						break;
+					}
+					if (refObj) return replaceXExtRefs(scrubUnwantedKeys(refObj), extensions, schemaNameMappings);
 				}
 			}
-			const result$1 = {};
-			for (const [key, value] of Object.entries(record)) result$1[key] = replaceRefs(value);
-			return result$1;
 		}
-		return obj;
+		const result = {};
+		for (const [key, value] of Object.entries(record)) result[key] = replaceXExtRefs(value, extensions, schemaNameMappings);
+		return result;
 	}
-	const result = {};
-	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceRefs(value);
-	return result;
+	return obj;
 }
 
 //#endregion
@@ -405,8 +475,8 @@ async function formatWithPrettier(paths, projectTitle) {
 				});
 				await fs$1.writeFile(filePath, formatted);
 			} catch (error) {
-				if (error instanceof Error) if (error.name === "UndefinedParserError") {} else log(chalk.yellow(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: ${error.toString()}`));
-				else log(chalk.yellow(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: unknown error}`));
+				if (error instanceof Error) if (error.name === "UndefinedParserError") {} else log(styleText("yellow", `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: ${error.toString()}`));
+				else log(styleText("yellow", `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: unknown error}`));
 			}
 		}));
 		return;
@@ -414,7 +484,7 @@ async function formatWithPrettier(paths, projectTitle) {
 	try {
 		await execa("prettier", ["--write", ...paths]);
 	} catch {
-		log(chalk.yellow(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}prettier not found. Install it as a project dependency or globally.`));
+		log(styleText("yellow", `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}prettier not found. Install it as a project dependency or globally.`));
 	}
 }
 /**
@@ -449,14 +519,14 @@ async function collectFilePaths(paths) {
 
 //#endregion
 //#region src/utils/execute-hook.ts
-const executeHook = async (name$1, commands = [], args = []) => {
-	log(chalk.white(`Running ${name$1} hook...`));
+const executeHook = async (name, commands = [], args = []) => {
+	log(styleText("white", `Running ${name} hook...`));
 	for (const command of commands) try {
 		if (isString(command)) await executeCommand(command, args);
 		else if (isFunction(command)) await command(args);
 		else if (isObject(command)) await executeObjectCommand(command, args);
 	} catch (error) {
-		logError(error, `Failed to run ${name$1} hook`);
+		logError(error, `Failed to run ${name} hook`);
 	}
 };
 async function executeCommand(command, args) {
@@ -500,7 +570,7 @@ const resolveAndAttachVersions = (pkg, workspace, cacheKey) => {
 	if (Object.keys(resolved).length > 0) {
 		pkg.resolvedVersions = resolved;
 		resolvedCache.set(cacheKey, resolved);
-		for (const [name$1, version$1] of Object.entries(resolved)) logVerbose(chalk.dim(`Detected ${chalk.white(name$1)} v${chalk.white(version$1)}`));
+		for (const [name, version] of Object.entries(resolved)) logVerbose(styleText("dim", `Detected ${styleText("white", name)} v${styleText("white", version)}`));
 	}
 	return pkg;
 };
@@ -555,7 +625,7 @@ const maybeReplaceCatalog = async (pkg, workspace) => {
 	if (!hasCatalogReferences(pkg)) return pkg;
 	const catalogData = await loadPnpmWorkspaceCatalog(workspace) ?? await loadPackageJsonCatalog(workspace) ?? await loadYarnrcCatalog(workspace);
 	if (!catalogData) {
-		log(`⚠️  ${chalk.yellow("package.json contains catalog: references, but no catalog source was found (checked: pnpm-workspace.yaml, package.json, .yarnrc.yml).")}`);
+		log(`⚠️  ${styleText("yellow", "package.json contains catalog: references, but no catalog source was found (checked: pnpm-workspace.yaml, package.json, .yarnrc.yml).")}`);
 		return pkg;
 	}
 	performSubstitution(pkg.dependencies, catalogData);
@@ -565,27 +635,27 @@ const maybeReplaceCatalog = async (pkg, workspace) => {
 };
 const performSubstitution = (dependencies, catalogData) => {
 	if (!dependencies) return;
-	for (const [packageName, version$1] of Object.entries(dependencies)) if (version$1 === "catalog:" || version$1 === "catalog:default") {
+	for (const [packageName, version] of Object.entries(dependencies)) if (version === "catalog:" || version === "catalog:default") {
 		if (!catalogData.catalog) {
-			log(`⚠️  ${chalk.yellow(`catalog: substitution for the package '${packageName}' failed as there is no default catalog.`)}`);
+			log(`⚠️  ${styleText("yellow", `catalog: substitution for the package '${packageName}' failed as there is no default catalog.`)}`);
 			continue;
 		}
 		const sub = catalogData.catalog[packageName];
 		if (!sub) {
-			log(`⚠️  ${chalk.yellow(`catalog: substitution for the package '${packageName}' failed as there is no matching package in the default catalog.`)}`);
+			log(`⚠️  ${styleText("yellow", `catalog: substitution for the package '${packageName}' failed as there is no matching package in the default catalog.`)}`);
 			continue;
 		}
 		dependencies[packageName] = sub;
-	} else if (version$1.startsWith("catalog:")) {
-		const catalogName = version$1.slice(8);
+	} else if (version.startsWith("catalog:")) {
+		const catalogName = version.slice(8);
 		const catalog = catalogData.catalogs?.[catalogName];
 		if (!catalog) {
-			log(`⚠️  ${chalk.yellow(`'${version$1}' substitution for the package '${packageName}' failed as there is no matching catalog named '${catalogName}'. (available named catalogs are: ${Object.keys(catalogData.catalogs ?? {}).join(", ")})`)}`);
+			log(`⚠️  ${styleText("yellow", `'${version}' substitution for the package '${packageName}' failed as there is no matching catalog named '${catalogName}'. (available named catalogs are: ${Object.keys(catalogData.catalogs ?? {}).join(", ")})`)}`);
 			continue;
 		}
 		const sub = catalog[packageName];
 		if (!sub) {
-			log(`⚠️  ${chalk.yellow(`'${version$1}' substitution for the package '${packageName}' failed as there is no package in the catalog named '${catalogName}'. (packages in the catalog are: ${Object.keys(catalog).join(", ")})`)}`);
+			log(`⚠️  ${styleText("yellow", `'${version}' substitution for the package '${packageName}' failed as there is no package in the catalog named '${catalogName}'. (packages in the catalog are: ${Object.keys(catalog).join(", ")})`)}`);
 			continue;
 		}
 		dependencies[packageName] = sub;
@@ -620,6 +690,13 @@ const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
 function defineConfig(options) {
 	return options;
 }
+/**
+* Type helper to make it easier to write input transformers.
+* accepts a direct {@link InputTransformerFn} function.
+*/
+function defineTransformer(transformer) {
+	return transformer;
+}
 function createFormData(workspace, formData) {
 	const defaultArrayHandling = FormDataArrayHandling.SERIALIZE;
 	if (formData === void 0) return {
@@ -656,8 +733,8 @@ function normalizeSchemasOption(schemas, workspace) {
 }
 async function normalizeOptions(optionsExport, workspace = process.cwd(), globalOptions = {}) {
 	const options = await (isFunction(optionsExport) ? optionsExport() : optionsExport);
-	if (!options.input) throw new Error(chalk.red(`Config require an input`));
-	if (!options.output) throw new Error(chalk.red(`Config require an output`));
+	if (!options.input) throw new Error(styleText("red", `Config require an input`));
+	if (!options.output) throw new Error(styleText("red", `Config require an output`));
 	const inputOptions = isString(options.input) ? { target: options.input } : options.input;
 	const outputOptions = isString(options.output) ? { target: options.output } : options.output;
 	const outputWorkspace = normalizePath(outputOptions.workspace ?? "", workspace);
@@ -665,14 +742,14 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 	const tsconfig = await loadTsconfig(outputOptions.tsconfig ?? globalOptions.tsconfig, workspace);
 	const packageJson = await loadPackageJson(outputOptions.packageJson ?? globalOptions.packageJson, workspace);
 	const mockOption = outputOptions.mock ?? globalOptions.mock;
-	let mock$1;
-	if (isBoolean(mockOption) && mockOption) mock$1 = DEFAULT_MOCK_OPTIONS;
-	else if (isFunction(mockOption)) mock$1 = mockOption;
-	else if (mockOption) mock$1 = {
+	let mock;
+	if (isBoolean(mockOption) && mockOption) mock = DEFAULT_MOCK_OPTIONS;
+	else if (isFunction(mockOption)) mock = mockOption;
+	else if (mockOption) mock = {
 		...DEFAULT_MOCK_OPTIONS,
 		...mockOption
 	};
-	else mock$1 = void 0;
+	else mock = void 0;
 	const defaultFileExtension = ".ts";
 	const globalQueryOptions = {
 		useQuery: true,
@@ -701,7 +778,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 			client: outputOptions.client ?? client ?? OutputClient.AXIOS_FUNCTIONS,
 			httpClient: outputOptions.httpClient ?? httpClient ?? ((outputOptions.client ?? client) === OutputClient.ANGULAR_QUERY ? OutputHttpClient.ANGULAR : OutputHttpClient.FETCH),
 			mode: normalizeOutputMode(outputOptions.mode ?? mode),
-			mock: mock$1,
+			mock,
 			clean: outputOptions.clean ?? clean ?? false,
 			docs: outputOptions.docs ?? false,
 			prettier: outputOptions.prettier ?? prettier ?? false,
@@ -813,13 +890,13 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		},
 		hooks: options.hooks ? normalizeHooks(options.hooks) : {}
 	};
-	if (!normalizedOptions.input.target) throw new Error(chalk.red(`Config require an input target`));
-	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(chalk.red(`Config require an output target or schemas`));
+	if (!normalizedOptions.input.target) throw new Error(styleText("red", `Config require an input target`));
+	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(styleText("red", `Config require an output target or schemas`));
 	return normalizedOptions;
 }
 function normalizeMutator(workspace, mutator) {
 	if (isObject(mutator)) {
-		if (!mutator.path) throw new Error(chalk.red(`Mutator need a path`));
+		if (!mutator.path) throw new Error(styleText("red", `Mutator need a path`));
 		return {
 			...mutator,
 			path: upath.resolve(workspace, mutator.path),
@@ -832,51 +909,51 @@ function normalizeMutator(workspace, mutator) {
 	};
 	return mutator;
 }
-function normalizePathOrUrl(path$1, workspace) {
-	if (isString(path$1) && !isUrl(path$1)) return normalizePath(path$1, workspace);
-	return path$1;
+function normalizePathOrUrl(path, workspace) {
+	if (isString(path) && !isUrl(path)) return normalizePath(path, workspace);
+	return path;
 }
-function normalizePath(path$1, workspace) {
-	if (!isString(path$1)) return path$1;
-	return upath.resolve(workspace, path$1);
+function normalizePath(path, workspace) {
+	if (!isString(path)) return path;
+	return upath.resolve(workspace, path);
 }
 function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
-	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, query: query$1, zod: zod$1, ...rest }]) => {
+	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, query, zod, ...rest }]) => {
 		return [key, {
 			...rest,
-			...query$1 ? { query: normalizeQueryOptions(query$1, workspace, global.query) } : {},
-			...zod$1 ? { zod: {
+			...query ? { query: normalizeQueryOptions(query, workspace, global.query) } : {},
+			...zod ? { zod: {
 				strict: {
-					param: zod$1.strict?.param ?? false,
-					query: zod$1.strict?.query ?? false,
-					header: zod$1.strict?.header ?? false,
-					body: zod$1.strict?.body ?? false,
-					response: zod$1.strict?.response ?? false
+					param: zod.strict?.param ?? false,
+					query: zod.strict?.query ?? false,
+					header: zod.strict?.header ?? false,
+					body: zod.strict?.body ?? false,
+					response: zod.strict?.response ?? false
 				},
 				generate: {
-					param: zod$1.generate?.param ?? true,
-					query: zod$1.generate?.query ?? true,
-					header: zod$1.generate?.header ?? true,
-					body: zod$1.generate?.body ?? true,
-					response: zod$1.generate?.response ?? true
+					param: zod.generate?.param ?? true,
+					query: zod.generate?.query ?? true,
+					header: zod.generate?.header ?? true,
+					body: zod.generate?.body ?? true,
+					response: zod.generate?.response ?? true
 				},
 				coerce: {
-					param: zod$1.coerce?.param ?? false,
-					query: zod$1.coerce?.query ?? false,
-					header: zod$1.coerce?.header ?? false,
-					body: zod$1.coerce?.body ?? false,
-					response: zod$1.coerce?.response ?? false
+					param: zod.coerce?.param ?? false,
+					query: zod.coerce?.query ?? false,
+					header: zod.coerce?.header ?? false,
+					body: zod.coerce?.body ?? false,
+					response: zod.coerce?.response ?? false
 				},
 				preprocess: {
-					...zod$1.preprocess?.param ? { param: normalizeMutator(workspace, zod$1.preprocess.param) } : {},
-					...zod$1.preprocess?.query ? { query: normalizeMutator(workspace, zod$1.preprocess.query) } : {},
-					...zod$1.preprocess?.header ? { header: normalizeMutator(workspace, zod$1.preprocess.header) } : {},
-					...zod$1.preprocess?.body ? { body: normalizeMutator(workspace, zod$1.preprocess.body) } : {},
-					...zod$1.preprocess?.response ? { response: normalizeMutator(workspace, zod$1.preprocess.response) } : {}
+					...zod.preprocess?.param ? { param: normalizeMutator(workspace, zod.preprocess.param) } : {},
+					...zod.preprocess?.query ? { query: normalizeMutator(workspace, zod.preprocess.query) } : {},
+					...zod.preprocess?.header ? { header: normalizeMutator(workspace, zod.preprocess.header) } : {},
+					...zod.preprocess?.body ? { body: normalizeMutator(workspace, zod.preprocess.body) } : {},
+					...zod.preprocess?.response ? { response: normalizeMutator(workspace, zod.preprocess.response) } : {}
 				},
-				generateEachHttpStatus: zod$1.generateEachHttpStatus ?? false,
-				dateTimeOptions: zod$1.dateTimeOptions ?? {},
-				timeOptions: zod$1.timeOptions ?? {}
+				generateEachHttpStatus: zod.generateEachHttpStatus ?? false,
+				dateTimeOptions: zod.dateTimeOptions ?? {},
+				timeOptions: zod.timeOptions ?? {}
 			} } : {},
 			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
 			...mutator ? { mutator: normalizeMutator(workspace, mutator) } : {},
@@ -889,7 +966,7 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 function normalizeOutputMode(mode) {
 	if (!mode) return OutputMode.SINGLE;
 	if (!Object.values(OutputMode).includes(mode)) {
-		createLogger().warn(chalk.yellow(`Unknown the provided mode => ${mode}`));
+		createLogger().warn(styleText("yellow", `Unknown the provided mode => ${mode}`));
 		return OutputMode.SINGLE;
 	}
 	return mode;
@@ -903,12 +980,12 @@ function normalizeHooks(hooks) {
 	else if (isObject(hooks[key])) result[key] = [hooks[key]];
 	return result;
 }
-function normalizeHonoOptions(hono$1 = {}, workspace) {
+function normalizeHonoOptions(hono = {}, workspace) {
 	return {
-		...hono$1.handlers ? { handlers: upath.resolve(workspace, hono$1.handlers) } : {},
-		compositeRoute: hono$1.compositeRoute ?? "",
-		validator: hono$1.validator ?? true,
-		validatorOutputPath: hono$1.validatorOutputPath ? upath.resolve(workspace, hono$1.validatorOutputPath) : ""
+		...hono.handlers ? { handlers: upath.resolve(workspace, hono.handlers) } : {},
+		compositeRoute: hono.compositeRoute ?? "",
+		validator: hono.validator ?? true,
+		validatorOutputPath: hono.validatorOutputPath ? upath.resolve(workspace, hono.validatorOutputPath) : ""
 	};
 }
 function normalizeJSDocOptions(jsdoc = {}) {
@@ -952,12 +1029,12 @@ function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions
 		...isNullish(queryOptions.runtimeValidation) ? {} : { runtimeValidation: queryOptions.runtimeValidation }
 	};
 }
-function getDefaultFilesHeader({ title, description: description$1, version: version$1 } = {}) {
+function getDefaultFilesHeader({ title, description, version: version$1 } = {}) {
 	return [
 		`Generated by ${name} v${version} 🍺`,
 		`Do not edit manually.`,
 		...title ? [title] : [],
-		...description$1 ? [description$1] : [],
+		...description ? [description] : [],
 		...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
 	];
 }
@@ -1009,15 +1086,15 @@ export type ${schemaName} = zod.input<typeof ${schemaName}>;`;
 	}).join("\n\n")}
 `;
 }
-const isValidSchemaIdentifier = (name$1) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name$1);
-const isPrimitiveSchemaName = (name$1) => [
+const isValidSchemaIdentifier = (name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+const isPrimitiveSchemaName = (name) => [
 	"string",
 	"number",
 	"boolean",
 	"void",
 	"unknown",
 	"Blob"
-].includes(name$1);
+].includes(name);
 const dedupeSchemasByName = (schemas) => {
 	const uniqueSchemas = /* @__PURE__ */ new Map();
 	for (const schema of schemas) if (!uniqueSchemas.has(schema.name)) uniqueSchemas.set(schema.name, schema);
@@ -1057,9 +1134,9 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	for (const generatorSchema of schemasWithOpenApiDef) {
-		const { name: name$1, schema: schemaObject } = generatorSchema;
+		const { name, schema: schemaObject } = generatorSchema;
 		if (!schemaObject) continue;
-		const fileName = conventionName(name$1, output.namingConvention);
+		const fileName = conventionName(name, output.namingConvention);
 		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
 		const context = {
 			spec: builder.spec,
@@ -1067,9 +1144,9 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 			workspace: "",
 			output
 		};
-		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name$1, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
 		schemasToWrite.push({
-			schemaName: name$1,
+			schemaName: name,
 			filePath,
 			consts: parsedZodDefinition.consts,
 			zodExpression: parsedZodDefinition.zod
@@ -1104,7 +1181,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			schema: {
 				type: "object",
 				properties: Object.fromEntries(queryParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
-				required: queryParams.filter((p) => p.required).map((p) => p.name).filter((name$1) => name$1 !== void 0)
+				required: queryParams.filter((p) => p.required).map((p) => p.name).filter((name) => name !== void 0)
 			}
 		}] : [];
 		const headerParams = parameters?.filter((p) => "in" in p && p.in === "header");
@@ -1113,7 +1190,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			schema: {
 				type: "object",
 				properties: Object.fromEntries(headerParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
-				required: headerParams.filter((p) => p.required).map((p) => p.name).filter((name$1) => name$1 !== void 0)
+				required: headerParams.filter((p) => p.required).map((p) => p.name).filter((name) => name !== void 0)
 			}
 		}] : [];
 		const responseSchemas = [...verbOption.response.types.success, ...verbOption.response.types.errors].filter((responseType) => !!responseType.originalSchema && !responseType.isRef && isValidSchemaIdentifier(responseType.value) && !isPrimitiveSchemaName(responseType.value)).map((responseType) => ({
@@ -1128,12 +1205,12 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		]);
 	}));
 	const schemasToWrite = [];
-	for (const { name: name$1, schema } of uniqueVerbsSchemas) {
-		const fileName = conventionName(name$1, output.namingConvention);
+	for (const { name, schema } of uniqueVerbsSchemas) {
+		const fileName = conventionName(name, output.namingConvention);
 		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
-		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, zodContext, name$1, strict, isZodV4, { required: true }), zodContext, coerce, strict, isZodV4);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, zodContext, name, strict, isZodV4, { required: true }), zodContext, coerce, strict, isZodV4);
 		schemasToWrite.push({
-			schemaName: name$1,
+			schemaName: name,
 			filePath,
 			consts: parsedZodDefinition.consts,
 			zodExpression: parsedZodDefinition.zod
@@ -1273,7 +1350,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 	});
 	if (output.workspace) {
 		const workspacePath = output.workspace;
-		const imports = implementationPaths.filter((path$1) => !output.mock || !path$1.endsWith(`.${getMockFileExtensionByTypeName(output.mock)}.ts`)).map((path$1) => upath.relativeSafe(workspacePath, getFileInfo(path$1).pathWithoutExtension));
+		const imports = implementationPaths.filter((path) => !output.mock || !path.endsWith(`.${getMockFileExtensionByTypeName(output.mock)}.ts`)).map((path) => upath.relativeSafe(workspacePath, getFileInfo(path).pathWithoutExtension));
 		if (output.schemas) {
 			const schemasPath = isString(output.schemas) ? output.schemas : output.schemas.path;
 			imports.push(upath.relativeSafe(workspacePath, getFileInfo(schemasPath).dirname));
@@ -1309,7 +1386,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 	} catch (error) {
 		let message = `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}biome not found`;
 		if (error instanceof ExecaError && error.exitCode === 1) message = error.message;
-		log(chalk.yellow(message));
+		log(styleText("yellow", message));
 	}
 	if (output.docs) try {
 		let config = {};
@@ -1337,8 +1414,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 			if (output.prettier) await formatWithPrettier([outputPath], projectTitle);
 		} else throw new Error("TypeDoc not initialized");
 	} catch (error) {
-		const message = error instanceof Error ? error.message : `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Unable to generate docs`;
-		log(chalk.yellow(message));
+		log(styleText("yellow", error instanceof Error ? error.message : `⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Unable to generate docs`));
 	}
 	createSuccessMessage(projectTitle);
 }
@@ -1437,5 +1513,5 @@ async function loadConfigFile(configFilePath) {
 }
 
 //#endregion
-export { defineConfig as a, name as c, startWatcher as i, version as l, loadConfigFile as n, normalizeOptions as o, generateSpec as r, description as s, findConfigFile as t };
-//# sourceMappingURL=config-glSQmAy7.mjs.map
+export { defineConfig as a, description as c, startWatcher as i, name as l, loadConfigFile as n, defineTransformer as o, generateSpec as r, normalizeOptions as s, findConfigFile as t, version as u };
+//# sourceMappingURL=config-By98GXtB.mjs.map