@kubb/parser-ts 5.0.0-beta.1 → 5.0.0-beta.100

package/dist/index.js

@@ -1,11 +1,30 @@
-import "./chunk--u3MIqq1.js";
+import "./rolldown-runtime-C0LytTxp.js";
+import { defineParser } from "@kubb/kit";
 import { normalize, relative } from "node:path";
-import { defineParser } from "@kubb/core";
 import ts from "typescript";
-//#region src/constants.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Matches the trailing `.<ext>` segment of a path (keeps segments like `foo.bar.ts`
-* intact by only trimming the last run of non-`/`/`.` characters).
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+/**
+* Indentation unit prepended once per nesting level when pretty-printing.
+*/
+const INDENT = " ".repeat(2);
+/**
+* Matches only the final `.<ext>` of a path, so a name like `foo.bar.ts` keeps
+* `foo.bar` and loses just `.ts`.
 */
 const FILE_EXTENSION_PATTERN = /\.[^/.]+$/;
 /**
@@ -13,45 +32,35 @@ const FILE_EXTENSION_PATTERN = /\.[^/.]+$/;
 */
 const WINDOWS_PATH_SEPARATOR = /\\/g;
 /**
-* Matches `*\/` in free-form text so JSDoc bodies can neutralise premature
+* Matches `*\/` in free-form text so JSDoc bodies can neutralize premature
 * comment terminators (`*\/` → `* /`).
 */
 const JSDOC_TERMINATOR_PATTERN = /\*\//g;
 /**
-* Matches carriage returns for normalising CRLF/CR line endings to LF.
+* Matches carriage returns for normalizing CRLF/CR line endings to LF.
 */
 const CARRIAGE_RETURN_PATTERN = /\r/g;
 /**
-* Matches CRLF sequences used when normalising TypeScript printer output.
+* Matches CRLF sequences used when normalizing TypeScript printer output.
 */
 const CRLF_PATTERN = /\r\n/g;
 /**
-* Matches an identifier that starts with a digit — JavaScript disallows this
-* so the printer prefixes such names with `_`.
+* Matches an identifier that starts with a digit. JavaScript disallows this,
+* so the printer replaces the leading digit with `_`.
 */
 const LEADING_DIGIT_PATTERN = /^\d/;
 //#endregion
-//#region src/parserTs.ts
+//#region src/utils.ts
 const { factory } = ts;
-function slash(path) {
-	return normalize(path).replaceAll(WINDOWS_PATH_SEPARATOR, "/").replace("../", "");
-}
 /**
 * Resolves `filePath` relative to `rootDir` and returns a POSIX-style path
 * prefixed with `./` when the target sits inside the root, or `../` when it escapes it.
 */
 function getRelativePath(rootDir, filePath) {
-	const slashed = slash(relative(rootDir, filePath));
+	const slashed = normalize(relative(rootDir, filePath)).replaceAll(WINDOWS_PATH_SEPARATOR, "/").replace("../", "");
 	return slashed.startsWith("../") ? slashed : `./${slashed}`;
 }
 /**
-* Strips the trailing file extension (for example `.ts`) from a path.
-* Preserves intermediate dots like `foo.bar.ts` → `foo.bar`.
-*/
-function trimExtName(text) {
-	return text.replace(FILE_EXTENSION_PATTERN, "");
-}
-/**
 * Rewrites an import/export path so its extension matches the caller-supplied
 * `options.extname`. When the source path has no extension the original is kept,
 * so virtual/module-only paths flow through unchanged.
@@ -62,60 +71,105 @@ function resolveOutputPath(path, options, rootAware) {
 	return rootAware ? trimExtName(path) : path;
 }
 /**
-* Validates TypeScript AST nodes before printing.
-* Throws an error if any node has SyntaxKind.Unknown which would cause the
-* TypeScript printer to crash.
+* Serializes a `nodes` array into source text. Each entry is rendered via {@link printCodeNode}
+* and joined with a single newline. A `Break` node (`<br/>`) inserts one blank line between
+* statements. Consecutive breaks, and breaks at the very start or end, are folded into the
+* separator, so a double `<br/>` never emits more than one blank line.
 */
-function validateNodes(...nodes) {
+function printNodes(nodes) {
+	if (!nodes || nodes.length === 0) return "";
+	let result = "";
+	let hasContent = false;
+	let pendingBreak = false;
 	for (const node of nodes) {
-		if (!node) throw new Error("Attempted to print undefined or null TypeScript node");
-		if (node.kind === ts.SyntaxKind.Unknown) throw new Error(`Invalid TypeScript AST node detected with SyntaxKind.Unknown. This typically indicates a schema pattern that could not be properly converted to TypeScript. Node: ${JSON.stringify(node, null, 2)}`);
+		if (node.kind === "Break") {
+			if (hasContent) pendingBreak = true;
+			continue;
+		}
+		const text = printCodeNode(node);
+		if (!text) continue;
+		if (hasContent) result += pendingBreak ? "\n\n" : "\n";
+		result += text;
+		hasContent = true;
+		pendingBreak = false;
 	}
+	return result;
 }
 /**
-* Converts TypeScript/TSX AST nodes to a string using the TypeScript printer.
+* Indents every non-empty line of `text` by one indent unit. Pass a number to repeat
+* {@link INDENT_CHAR} that many times, or a string to use as the indent verbatim.
 */
-function print(...elements) {
-	const sourceFile = ts.createSourceFile("print.tsx", "", ts.ScriptTarget.ES2022, true, ts.ScriptKind.TSX);
-	return ts.createPrinter({
-		omitTrailingSemicolon: true,
-		newLine: ts.NewLineKind.LineFeed,
-		removeComments: false,
-		noEmitHelpers: true
-	}).printList(ts.ListFormat.MultiLine, factory.createNodeArray(elements.filter(Boolean)), sourceFile).replace(CRLF_PATTERN, "\n");
+function indentLines(text, indent = INDENT) {
+	if (!text) return "";
+	const pad = typeof indent === "string" ? indent : " ".repeat(indent);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : "").join("\n");
 }
 /**
-* Like `print` but validates nodes first to surface issues early.
+* Removes the common leading whitespace shared by every non-blank line and trims
+* surrounding blank lines, so multi-line content authored inside an indented template
+* literal lines up at a column-zero baseline. Leading whitespace is counted by
+* character, so N tabs and N spaces are treated as the same depth.
+*
+* @example
+* ```ts
+* dedent('\n    foo\n      bar\n    ')
+* // 'foo\n  bar'
+* ```
 */
-function safePrint(...elements) {
-	validateNodes(...elements);
-	return print(...elements);
+function dedent(text) {
+	if (!text) return "";
+	const lines = text.split("\n");
+	const isBlank = (line) => line.trim() === "";
+	const start = lines.findIndex((line) => !isBlank(line));
+	if (start === -1) return "";
+	const end = lines.findLastIndex((line) => !isBlank(line));
+	const trimmed = lines.slice(start, end + 1);
+	const indents = trimmed.filter((line) => !isBlank(line)).map((line) => line.match(/^\s*/)?.[0].length ?? 0);
+	const min = indents.length ? Math.min(...indents) : 0;
+	return trimmed.map((line) => isBlank(line) ? "" : line.slice(min)).join("\n");
 }
-function createImport({ name, path, root, isTypeOnly = false, isNameSpace = false }) {
-	const resolvePath = root ? getRelativePath(root, path) : path;
-	if (!Array.isArray(name)) {
-		if (isNameSpace) return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamespaceImport(factory.createIdentifier(name))), factory.createStringLiteral(resolvePath), void 0);
-		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, factory.createIdentifier(name), void 0), factory.createStringLiteral(resolvePath), void 0);
-	}
-	const specifiers = name.map((item) => {
-		if (typeof item === "object") {
-			const { propertyName, name: alias } = item;
-			return factory.createImportSpecifier(false, alias ? factory.createIdentifier(propertyName) : void 0, factory.createIdentifier(alias ?? propertyName));
-		}
-		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
-	});
-	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(specifiers)), factory.createStringLiteral(resolvePath), void 0);
+/**
+* Renders the generic clause (`<T, U>`) shared by function and arrow-function nodes.
+* Accepts either a raw string (rendered verbatim) or an array of type-parameter names.
+*/
+function formatGenerics(generics) {
+	if (!generics) return "";
+	return `<${Array.isArray(generics) ? generics.join(", ") : generics}>`;
 }
-function createExport({ path, asAlias, isTypeOnly = false, name }) {
-	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true: ${name}`);
-	if (!Array.isArray(name)) {
-		const parsedName = name && LEADING_DIGIT_PATTERN.test(name) ? `_${name.slice(1)}` : name;
-		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
-	}
-	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(name.map((propertyName) => factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName))), factory.createStringLiteral(path), void 0);
+/**
+* Renders the return-type suffix (`: T` or `: Promise<T>` when `isAsync` is true).
+* Returns an empty string when no return type is provided.
+*/
+function formatReturnType(returnType, isAsync) {
+	if (!returnType) return "";
+	return isAsync ? `: Promise<${returnType}>` : `: ${returnType}`;
+}
+/**
+* Module-scoped TypeScript printer instance. A printer does not mutate the source file, so one
+* instance is reused across every `print()` call instead of constructing a new printer each time.
+*/
+const TS_PRINTER = ts.createPrinter({
+	omitTrailingSemicolon: true,
+	newLine: ts.NewLineKind.LineFeed,
+	removeComments: false,
+	noEmitHelpers: true
+});
+/**
+* Module-scoped source file used as the print target. `printList` only reads the source
+* file's compiler options / language version. It never mutates it.
+*/
+const PRINT_SOURCE_FILE = ts.createSourceFile("print.tsx", "", ts.ScriptTarget.ES2022, true, ts.ScriptKind.TSX);
+TS_PRINTER.printList(ts.ListFormat.MultiLine, factory.createNodeArray([]), PRINT_SOURCE_FILE);
+/**
+* Converts TypeScript/TSX AST nodes to a string using the TypeScript printer.
+*/
+function print(...elements) {
+	const filtered = elements.filter(Boolean);
+	if (filtered.length === 0) return "";
+	return TS_PRINTER.printList(ts.ListFormat.MultiLine, factory.createNodeArray(filtered), PRINT_SOURCE_FILE).replace(CRLF_PATTERN, "\n");
 }
 /**
-* Converts a {@link JSDocNode} to a JSDoc comment block string.
+* Converts a {@link ast.JSDocNode} to a JSDoc comment block string.
 *
 * @example
 * ```ts
@@ -138,54 +192,19 @@ function printJSDoc(jsDoc) {
 	].join("\n");
 }
 /**
-* Serializes the body / value content from a `nodes` array.
-*
-* Each element is either a raw string or a structured {@link CodeNode}
-* (recursively converted via {@link printCodeNode}).
-* Elements are joined with `\n`.
-*/
-function printNodes(nodes) {
-	if (!nodes || nodes.length === 0) return "";
-	return nodes.map(printCodeNode).join("\n");
-}
-/**
-* Indents every non-empty line of `text` by `spaces` spaces.
-*/
-function indentLines(text, spaces = 2) {
-	if (!text) return "";
-	const pad = " ".repeat(spaces);
-	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : "").join("\n");
-}
-/**
-* Renders the generic clause (`<T, U>`) shared by function and arrow-function nodes.
-* Accepts either a raw string (rendered verbatim) or an array of type-parameter names.
-*/
-function formatGenerics(generics) {
-	if (!generics) return "";
-	return `<${Array.isArray(generics) ? generics.join(", ") : generics}>`;
-}
-/**
-* Renders the return-type suffix (`: T` or `: Promise<T>` when `isAsync` is true).
-* Returns an empty string when no return type is provided.
-*/
-function formatReturnType(returnType, isAsync) {
-	if (!returnType) return "";
-	return isAsync ? `: Promise<${returnType}>` : `: ${returnType}`;
-}
-/**
-* Converts a {@link ConstNode} to a TypeScript `const` declaration string.
+* Converts a {@link ast.ConstNode} to a TypeScript `const` declaration string.
 *
 * Mirrors the `Const` component from `@kubb/renderer-jsx`.
 *
 * @example
 * ```ts
-* printConst(createConst({ name: 'pet', export: true, nodes: ['{}'] }))
+* printConst(factory.createConst({ name: 'pet', export: true, nodes: ['{}'] }))
 * // 'export const pet = {}'
 * ```
 *
 * @example With type and `as const`
 * ```ts
-* printConst(createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true, nodes: ['[]'] }))
+* printConst(factory.createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true, nodes: ['[]'] }))
 * // 'export const pets: Pet[] = [] as const'
 * ```
 */
@@ -204,13 +223,13 @@ function printConst(node) {
 	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
 }
 /**
-* Converts a {@link TypeNode} to a TypeScript `type` alias declaration string.
+* Converts a {@link ast.TypeNode} to a TypeScript `type` alias declaration string.
 *
 * Mirrors the `Type` component from `@kubb/renderer-jsx`.
 *
 * @example
 * ```ts
-* printType(createType({ name: 'Pet', export: true, nodes: ['{ id: number }'] }))
+* printType(factory.createType({ name: 'Pet', export: true, nodes: ['{ id: number }'] }))
 * // 'export type Pet = { id: number }'
 * ```
 */
@@ -227,19 +246,19 @@ function printType(node) {
 	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
 }
 /**
-* Converts a {@link FunctionNode} to a TypeScript `function` declaration string.
+* Converts a {@link ast.FunctionNode} to a TypeScript `function` declaration string.
 *
 * Mirrors the `Function` component from `@kubb/renderer-jsx`.
 *
 * @example
 * ```ts
-* printFunction(createFunction({ name: 'getPet', export: true, params: 'id: string', returnType: 'Pet', nodes: ['return fetch(id)'] }))
+* printFunction(factory.createFunction({ name: 'getPet', export: true, params: 'id: string', returnType: 'Pet', nodes: ['return fetch(id)'] }))
 * // 'export function getPet(id: string): Pet {\n  return fetch(id)\n}'
 * ```
 *
 * @example Async with generics
 * ```ts
-* printFunction(createFunction({ name: 'fetchPet', export: true, async: true, generics: ['T'], params: 'id: string', returnType: 'T' }))
+* printFunction(factory.createFunction({ name: 'fetchPet', export: true, async: true, generics: ['T'], params: 'id: string', returnType: 'T' }))
 * // 'export async function fetchPet<T>(id: string): Promise<T> {\n}'
 * ```
 */
@@ -263,19 +282,19 @@ function printFunction(node) {
 	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
 }
 /**
-* Converts an {@link ArrowFunctionNode} to a TypeScript arrow function declaration string.
+* Converts an {@link ast.ArrowFunctionNode} to a TypeScript arrow function declaration string.
 *
 * Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
 *
 * @example Multi-line arrow function
 * ```ts
-* printArrowFunction(createArrowFunction({ name: 'getPet', export: true, params: 'id: string', nodes: ['return fetch(id)'] }))
+* printArrowFunction(factory.createArrowFunction({ name: 'getPet', export: true, params: 'id: string', nodes: ['return fetch(id)'] }))
 * // 'export const getPet = (id: string) => {\n  return fetch(id)\n}'
 * ```
 *
 * @example Single-line arrow function
 * ```ts
-* printArrowFunction(createArrowFunction({ name: 'double', params: 'n: number', singleLine: true, nodes: ['n * 2'] }))
+* printArrowFunction(factory.createArrowFunction({ name: 'double', params: 'n: number', singleLine: true, nodes: ['n * 2'] }))
 * // 'const double = (n: number) => n * 2'
 * ```
 */
@@ -298,103 +317,209 @@ function printArrowFunction(node) {
 	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
 }
 /**
-* Converts a {@link CodeNode} to its TypeScript string representation.
+* Converts a {@link ast.CodeNode} to its TypeScript string representation.
 *
 * Dispatches to the appropriate printer based on the node's `kind`.
 *
 * @example
 * ```ts
-* printCodeNode(createConst({ name: 'x', nodes: ['1'] }))
+* printCodeNode(factory.createConst({ name: 'x', nodes: ['1'] }))
 * // 'const x = 1'
 * ```
 */
 function printCodeNode(node) {
-	switch (node.kind) {
-		case "Break": return "";
-		case "Text": return node.value;
-		case "Jsx": return node.value;
-		case "Const": return printConst(node);
-		case "Type": return printType(node);
-		case "Function": return printFunction(node);
-		case "ArrowFunction": return printArrowFunction(node);
-	}
+	if (node.kind === "Break") return "";
+	if (node.kind === "Text") return dedent(node.value);
+	if (node.kind === "Jsx") return dedent(node.value);
+	if (node.kind === "Const") return printConst(node);
+	if (node.kind === "Type") return printType(node);
+	if (node.kind === "Function") return printFunction(node);
+	if (node.kind === "ArrowFunction") return printArrowFunction(node);
+	return "";
 }
 /**
-* Converts a {@link SourceNode} to its TypeScript string representation.
+* Converts a {@link ast.SourceNode} to its TypeScript string representation.
 *
-* Iterates `nodes` in DOM order, rendering each {@link CodeNode} via
+* Iterates `nodes` in DOM order, rendering each {@link ast.CodeNode} via
 * {@link printCodeNode}.
 *
+* Top-level declarations are separated by a blank line so the source reads
+* cleanly without an external formatter.
+*
 * @example From nodes
 * ```ts
-* printSource({ kind: 'Source', nodes: [createConst({ name: 'x', nodes: [createText('1')] }), createText('x.toString()')] })
-* // 'const x = 1\nx.toString()'
+* printSource({ kind: 'Source', nodes: [factory.createConst({ name: 'x', nodes: [factory.createText('1')] }), factory.createText('x.toString()')] })
+* // 'const x = 1\n\nx.toString()'
 * ```
 */
 function printSource(node) {
-	if (node.nodes && node.nodes.length > 0) return node.nodes.map(printCodeNode).join("\n");
-	return "";
+	const nodes = node.nodes;
+	if (!nodes || nodes.length === 0) return "";
+	let result = "";
+	for (const child of nodes) {
+		const text = printCodeNode(child);
+		if (!text) continue;
+		result = result ? `${result}\n\n${text}` : text;
+	}
+	return result;
 }
 /**
-* Parser that converts `.ts` and `.js` files to strings using the TypeScript
-* compiler. Handles import/export statement generation from file metadata.
+* Wraps a module specifier in single quotes, escaping any embedded backslash or quote so the emitted
+* statement stays valid even for unusual paths.
+*/
+function quoteModulePath(path) {
+	return `'${path.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/**
+* Renders an import declaration string in the repo style (single quotes, no semicolons), covering
+* default, namespace (`* as`), and named imports with `{ a as b }` aliases, each optionally
+* `type`-only. `path` is used verbatim, so resolve it first.
 *
-* @default Used automatically when no `parsers` option is set in `defineConfig`.
+* @example
+* ```ts
+* printImport({ name: ['z'], path: './zod.ts' })
+* // "import { z } from './zod.ts'"
+* ```
 */
-const parserTs = defineParser({
-	name: "typescript",
-	extNames: [".ts", ".js"],
-	async parse(file, options = { extname: ".ts" }) {
-		const sourceParts = [];
-		for (const item of file.sources) {
-			const sourceStr = printSource(item);
-			if (sourceStr) sourceParts.push(sourceStr.trimEnd());
-		}
-		const source = sourceParts.join("\n\n");
-		const importNodes = [];
-		for (const item of file.imports) {
-			const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
-			importNodes.push(createImport({
+function printImport({ name, path, isTypeOnly = false, isNameSpace = false }) {
+	const typePrefix = isTypeOnly ? "type " : "";
+	const from = quoteModulePath(path);
+	if (!Array.isArray(name)) {
+		if (isNameSpace) return `import ${typePrefix}* as ${name} from ${from}`;
+		return `import ${typePrefix}${name} from ${from}`;
+	}
+	return `import ${typePrefix}{ ${name.map((item) => {
+		if (typeof item === "object") return item.name ? `${item.propertyName} as ${item.name}` : item.propertyName;
+		return item;
+	}).join(", ")} } from ${from}`;
+}
+/**
+* Renders an export declaration string in the repo style (single quotes, no semicolons), covering
+* named re-exports, namespace alias (`* as name`), and wildcard, each optionally `type`-only.
+* `path` is used verbatim, so resolve it first.
+*
+* @example
+* ```ts
+* printExport({ name: ['Pet', 'Order'], path: './models.ts' })
+* // "export { Pet, Order } from './models.ts'"
+* ```
+*/
+function printExport({ path, name, isTypeOnly = false, asAlias = false }) {
+	const typePrefix = isTypeOnly ? "type " : "";
+	const from = quoteModulePath(path);
+	if (Array.isArray(name)) return `export ${typePrefix}{ ${name.map((item) => typeof item === "string" ? item : item.text).join(", ")} } from ${from}`;
+	if (asAlias && name) return `export ${typePrefix}* as ${LEADING_DIGIT_PATTERN.test(name) ? `_${name.slice(1)}` : name} from ${from}`;
+	if (name) return `export ${typePrefix}{ ${name} } from ${from}`;
+	return `export ${typePrefix}* from ${from}`;
+}
+//#endregion
+//#region src/parserTs.ts
+const DEFAULT_EXTENSION = { ".ts": "" };
+/**
+* Default Kubb parser for `.ts` and `.js` files. Takes the universal AST
+* produced by an adapter and prints it as TypeScript source using the official
+* TypeScript compiler. Imports and exports are rewritten based on each file's
+* metadata and the `extension` option.
+*
+* Used automatically when no `parsers` option is set on `defineConfig`. Use
+* `parserTsx` instead for React projects that emit JSX.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb'
+* import { adapterOas } from '@kubb/adapter-oas'
+* import { parserTs } from '@kubb/parser-ts'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   adapter: adapterOas(),
+*   parsers: [parserTs()],
+*   plugins: [],
+* })
+* ```
+*/
+const parserTs = defineParser(({ extension = DEFAULT_EXTENSION } = {}) => {
+	return {
+		name: "typescript",
+		extNames: [".ts", ".js"],
+		print(...nodes) {
+			return print(...nodes);
+		},
+		parse(file) {
+			const extname = extension[file.extname] || void 0;
+			const sourceParts = [];
+			for (const item of file.sources) {
+				const sourceStr = printSource(item);
+				if (sourceStr) sourceParts.push(sourceStr.trimEnd());
+			}
+			const source = sourceParts.join("\n\n");
+			const importLines = [];
+			for (const item of file.imports) {
+				const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
+				importLines.push(printImport({
+					name: item.name,
+					path: resolveOutputPath(importPath, { extname }, Boolean(item.root)),
+					isTypeOnly: item.isTypeOnly,
+					isNameSpace: item.isNameSpace
+				}));
+			}
+			const exportLines = [];
+			for (const item of file.exports) exportLines.push(printExport({
 				name: item.name,
-				path: resolveOutputPath(importPath, options, Boolean(item.root)),
+				path: resolveOutputPath(item.path, { extname }, true),
 				isTypeOnly: item.isTypeOnly,
-				isNameSpace: item.isNameSpace
+				asAlias: item.asAlias
 			}));
+			const importExportBlock = [...importLines, ...exportLines].join("\n");
+			return [
+				file.banner,
+				importExportBlock,
+				source,
+				file.footer
+			].filter((segment) => Boolean(segment)).map((s) => s.trimEnd()).join("\n\n");
 		}
-		const exportNodes = [];
-		for (const item of file.exports) exportNodes.push(createExport({
-			name: item.name,
-			path: resolveOutputPath(item.path, options, true),
-			isTypeOnly: item.isTypeOnly,
-			asAlias: item.asAlias
-		}));
-		return [
-			file.banner,
-			print(...importNodes, ...exportNodes),
-			source,
-			file.footer
-		].filter((segment) => Boolean(segment)).map((s) => s.trimEnd()).join("\n\n");
-	}
+	};
 });
 //#endregion
 //#region src/parserTsx.ts
 /**
-* Parser that converts `.tsx` and `.jsx` files to strings.
-* Delegates to `typescriptParser` since the TypeScript compiler natively
-* supports JSX/TSX syntax via `ScriptKind.TSX`.
+* Kubb parser for `.tsx` and `.jsx` files. Delegates to `parserTs` because the
+* TypeScript compiler handles JSX natively via `ScriptKind.TSX`, so it shares the
+* same `extension` option.
+*
+* Add to the `parsers` array on `defineConfig` when generating components for
+* React (or any framework that emits JSX).
 *
-* Add this parser to the `parsers` option in `defineConfig` when generating `.tsx`/`.jsx` files.
+* @example
+* ```ts
+* import { defineConfig } from 'kubb'
+* import { adapterOas } from '@kubb/adapter-oas'
+* import { parserTsx } from '@kubb/parser-ts'
 *
-* @default extname '.tsx'
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   adapter: adapterOas(),
+*   parsers: [parserTsx()],
+*   plugins: [],
+* })
+* ```
 */
-const parserTsx = defineParser({
-	name: "tsx",
-	extNames: [".tsx", ".jsx"],
-	async parse(file, options = { extname: ".tsx" }) {
-		return parserTs.parse(file, options);
-	}
+const parserTsx = defineParser((options = {}) => {
+	const parser = parserTs(options);
+	return {
+		name: "tsx",
+		extNames: [".tsx", ".jsx"],
+		print(...nodes) {
+			return print(...nodes);
+		},
+		parse(file) {
+			return parser.parse(file);
+		}
+	};
 });
 //#endregion
-export { createExport, createImport, parserTs, parserTsx, print, safePrint, validateNodes };
+export { parserTs, parserTsx };
 
 //# sourceMappingURL=index.js.map