@kubb/ast 5.0.0-alpha.4 → 5.0.0-alpha.6

package/dist/index.js

@@ -1,4 +1,5 @@
 import "./chunk--u3MIqq1.js";
+import { parseArgs, styleText } from "node:util";
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
@@ -35,7 +36,8 @@ const schemaTypes = {
 	uuid: "uuid",
 	email: "email",
 	url: "url",
-	blob: "blob"
+	blob: "blob",
+	never: "never"
 };
 const httpMethods = {
 	get: "GET",
@@ -175,50 +177,63 @@ const isResponseNode = isKind("Response");
 * from `@kubb/core` — wraps a builder to make options optional and separates raw options
 * from resolved options.
 *
-* @example
+* The builder receives resolved options and returns:
+* - `name` — a unique identifier for the printer
+* - `options` — options stored on the returned printer instance
+* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
+* - `print` _(optional)_ — a root-level override that becomes the public `printer.print`.
+*   Inside it, `this.print(node)` still dispatches to the `nodes` map — safe recursion, no infinite loop.
+*
+* When no `print` override is provided, `printer.print` is the node-level dispatcher directly.
+*
+* @example Basic usage — Zod schema printer
 * ```ts
-* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, { strict: boolean }, string>
+* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
-* export const zodPrinter = definePrinter<ZodPrinter>((options) => {
-*   const { strict = true } = options
-*   return {
-*     name: 'zod',
-*     options: { strict },
-*     nodes: {
-*       string(node) {
-*         return `z.string()`
-*       },
-*       object(node) {
-*         const props = node.properties
-*           ?.map(p => `${p.name}: ${this.print(p)}`)
-*           .join(', ') ?? ''
-*         return `z.object({ ${props} })`
-*       },
+* export const zodPrinter = definePrinter<ZodPrinter>((options) => ({
+*   name: 'zod',
+*   options: { strict: options.strict ?? true },
+*   nodes: {
+*     string: () => 'z.string()',
+*     object(node) {
+*       const props = node.properties.map(p => `${p.name}: ${this.print(p.schema)}`).join(', ')
+*       return `z.object({ ${props} })`
 *     },
-*   }
-* })
+*   },
+* }))
+* ```
+*
+* @example With a root-level `print` override to wrap output in a full declaration
+* ```ts
+* type TsPrinter = PrinterFactoryOptions<'ts', { typeName?: string }, ts.TypeNode, ts.Node>
 *
-* const printer = zodPrinter({ strict: false })
-* printer.name            // 'zod'
-* printer.options         // { strict: false }
-* printer.print(node)     // 'z.string()'
+* export const printerTs = definePrinter<TsPrinter>((options) => ({
+*   name: 'ts',
+*   options,
+*   nodes: { string: () => factory.keywordTypeNodes.string },
+*   print(node) {
+*     const type = this.print(node) // calls the node-level dispatcher
+*     if (!type || !this.options.typeName) return type
+*     return factory.createTypeAliasDeclaration(this.options.typeName, type)
+*   },
+* }))
 * ```
 */
 function definePrinter(build) {
 	return (options) => {
-		const { name, options: resolvedOptions, nodes } = build(options ?? {});
+		const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
 		const context = {
 			options: resolvedOptions,
 			print: (node) => {
 				const handler = nodes[node.type];
-				return handler ? handler.call(context, node) : void 0;
+				if (!handler) return void 0;
+				return handler.call(context, node);
 			}
 		};
 		return {
 			name,
 			options: resolvedOptions,
-			print: context.print,
-			for: (nodes) => nodes.map(context.print)
+			print: printOverride ? printOverride.bind(context) : context.print
 		};
 	};
 }
@@ -245,6 +260,263 @@ function refMapToObject(refMap) {
 	return Object.fromEntries(refMap);
 }
 //#endregion
+//#region ../../internals/utils/dist/index.js
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
+function defineCLIAdapter(adapter) {
+	return adapter;
+}
+/**
+* Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
+* Use to expose CLI capabilities to AI agents or MCP tools.
+*/
+function getCommandSchema(defs) {
+	return defs.map(serializeCommand);
+}
+function serializeCommand(def) {
+	return {
+		name: def.name,
+		description: def.description,
+		arguments: def.arguments,
+		options: serializeOptions(def.options ?? {}),
+		subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : []
+	};
+}
+function serializeOptions(options) {
+	return Object.entries(options).map(([name, opt]) => {
+		return {
+			name,
+			flags: `${opt.short ? `-${opt.short}, ` : ""}--${name}${opt.type === "string" ? ` <${opt.hint ?? name}>` : ""}`,
+			type: opt.type,
+			description: opt.description,
+			...opt.default !== void 0 ? { default: opt.default } : {},
+			...opt.hint ? { hint: opt.hint } : {},
+			...opt.enum ? { enum: opt.enum } : {},
+			...opt.required ? { required: opt.required } : {}
+		};
+	});
+}
+/** Prints formatted help output for a command using its `CommandDefinition`. */
+function renderHelp(def, parentName) {
+	const schema = getCommandSchema([def])[0];
+	const programName = parentName ? `${parentName} ${schema.name}` : schema.name;
+	const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(" ")}` : "";
+	const subCmdPart = schema.subCommands.length ? " <command>" : "";
+	console.log(`\n${styleText("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
+	if (schema.description) console.log(`  ${schema.description}\n`);
+	if (schema.subCommands.length) {
+		console.log(styleText("bold", "Commands:"));
+		for (const sub of schema.subCommands) console.log(`  ${styleText("cyan", sub.name.padEnd(16))}${sub.description}`);
+		console.log();
+	}
+	const options = [...schema.options, {
+		name: "help",
+		flags: "-h, --help",
+		type: "boolean",
+		description: "Show help"
+	}];
+	console.log(styleText("bold", "Options:"));
+	for (const opt of options) {
+		const flags = styleText("cyan", opt.flags.padEnd(30));
+		const defaultPart = opt.default !== void 0 ? styleText("dim", ` (default: ${opt.default})`) : "";
+		console.log(`  ${flags}${opt.description}${defaultPart}`);
+	}
+	console.log();
+}
+function buildParseOptions(def) {
+	const result = { help: {
+		type: "boolean",
+		short: "h"
+	} };
+	for (const [name, opt] of Object.entries(def.options ?? {})) result[name] = {
+		type: opt.type,
+		...opt.short ? { short: opt.short } : {},
+		...opt.default !== void 0 ? { default: opt.default } : {}
+	};
+	return result;
+}
+async function runCommand(def, argv, parentName) {
+	const parseOptions = buildParseOptions(def);
+	let parsed;
+	try {
+		const result = parseArgs({
+			args: argv,
+			options: parseOptions,
+			allowPositionals: true,
+			strict: false
+		});
+		parsed = {
+			values: result.values,
+			positionals: result.positionals
+		};
+	} catch {
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (parsed.values["help"]) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	for (const [name, opt] of Object.entries(def.options ?? {})) if (opt.required && parsed.values[name] === void 0) {
+		console.error(styleText("red", `Error: --${name} is required`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (!def.run) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	try {
+		await def.run(parsed);
+	} catch (err) {
+		console.error(styleText("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+}
+function printRootHelp(programName, version, defs) {
+	console.log(`\n${styleText("bold", "Usage:")} ${programName} <command> [options]\n`);
+	console.log(`  Kubb generation — v${version}\n`);
+	console.log(styleText("bold", "Commands:"));
+	for (const def of defs) console.log(`  ${styleText("cyan", def.name.padEnd(16))}${def.description}`);
+	console.log();
+	console.log(styleText("bold", "Options:"));
+	console.log(`  ${styleText("cyan", "-v, --version".padEnd(30))}Show version number`);
+	console.log(`  ${styleText("cyan", "-h, --help".padEnd(30))}Show help`);
+	console.log();
+	console.log(`Run ${styleText("cyan", `${programName} <command> --help`)} for command-specific help.\n`);
+}
+defineCLIAdapter({
+	renderHelp(def, parentName) {
+		renderHelp(def, parentName);
+	},
+	async run(defs, argv, opts) {
+		const { programName, defaultCommandName, version } = opts;
+		const args = argv.length >= 2 && argv[0]?.includes("node") ? argv.slice(2) : argv;
+		if (args[0] === "--version" || args[0] === "-v") {
+			console.log(version);
+			process.exit(0);
+		}
+		if (args[0] === "--help" || args[0] === "-h") {
+			printRootHelp(programName, version, defs);
+			process.exit(0);
+		}
+		if (args.length === 0) {
+			const defaultDef = defs.find((d) => d.name === defaultCommandName);
+			if (defaultDef?.run) await runCommand(defaultDef, [], programName);
+			else printRootHelp(programName, version, defs);
+			return;
+		}
+		const [first, ...rest] = args;
+		const isKnownSubcommand = defs.some((d) => d.name === first);
+		let def;
+		let commandArgv;
+		let parentName;
+		if (isKnownSubcommand) {
+			def = defs.find((d) => d.name === first);
+			commandArgv = rest;
+			parentName = programName;
+		} else {
+			def = defs.find((d) => d.name === defaultCommandName);
+			commandArgv = args;
+			parentName = programName;
+		}
+		if (!def) {
+			console.error(`Unknown command: ${first}`);
+			printRootHelp(programName, version, defs);
+			process.exit(1);
+		}
+		if (def.subCommands?.length) {
+			const [subName, ...subRest] = commandArgv;
+			const subDef = def.subCommands.find((s) => s.name === subName);
+			if (subName === "--help" || subName === "-h") {
+				renderHelp(def, parentName);
+				process.exit(0);
+			}
+			if (!subDef) {
+				renderHelp(def, parentName);
+				process.exit(subName ? 1 : 0);
+			}
+			await runCommand(subDef, subRest, `${parentName} ${def.name}`);
+			return;
+		}
+		await runCommand(def, commandArgv, parentName);
+	}
+});
+/**
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
 //#region src/utils.ts
 const plainStringTypes = new Set([
 	"string",
@@ -265,8 +537,32 @@ function isPlainStringType(node) {
 	if (temporal) return temporal.representation !== "date";
 	return false;
 }
+/**
+* Transforms the `name` field of each parameter node according to the given casing strategy.
+*
+* The original `params` array is never mutated — a new array of cloned nodes is returned.
+* When no `casing` is provided the original array is returned as-is.
+*
+* Use this before passing parameters to schema builders so that property keys
+* in the generated output match the desired casing while the original
+* `OperationNode.parameters` array remains untouched for other consumers.
+*/
+function applyParamsCasing(params, casing) {
+	if (!casing) return params;
+	return params.map((param) => {
+		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
+		return {
+			...param,
+			name: transformed
+		};
+	});
+}
 //#endregion
 //#region src/visitor.ts
+/**
+* Creates a concurrency-limiting wrapper. At most `concurrency` promises may be
+* in-flight simultaneously; additional calls are queued and dispatched as slots free.
+*/
 function createLimit(concurrency) {
 	let active = 0;
 	const queue = [];
@@ -289,7 +585,10 @@ function createLimit(concurrency) {
 	};
 }
 /**
-* Traversable children of `node`, respecting `recurse` for schema nodes.
+* Returns the immediate traversable children of `node`.
+*
+* For `Schema` nodes, children (properties, items, members) are only included
+* when `recurse` is `true`; shallow traversal omits them entirely.
 */
 function getChildren(node, recurse) {
 	switch (node.kind) {
@@ -319,6 +618,9 @@ function getChildren(node, recurse) {
 async function walk(node, visitor, options = {}) {
 	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
 }
+/**
+* Internal recursive walk implementation — calls visitor then recurses into children.
+*/
 async function _walk(node, visitor, recurse, limit) {
 	switch (node.kind) {
 		case "Root":
@@ -439,6 +741,6 @@ function collect(node, visitor, options = {}) {
 	return results;
 }
 //#endregion
-export { buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPlainStringType, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+export { applyParamsCasing, buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPlainStringType, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
 
 //# sourceMappingURL=index.js.map