@kubb/renderer-jsx 5.0.0-beta.99 → 5.0.0

package/dist/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-ClG-MNz_.cjs");
 const require_jsx_runtime = require("./jsx-runtime.cjs");
 let yaml = require("yaml");
-let _kubb_ast = require("@kubb/ast");
+let _kubb_kit = require("@kubb/kit");
 //#region src/components/md/Callout.tsx
 const CALLOUT_LABEL = {
 	tip: "TIP",
@@ -30,9 +30,11 @@ const CALLOUT_LABEL = {
 */
 function Callout({ type, title, children }) {
 	const label = CALLOUT_LABEL[type];
+	const header = title ? `> [!${label}] ${title}` : `> [!${label}]`;
+	const quoted = children.trimEnd().split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
 	return /* @__PURE__ */ require_jsx_runtime.jsx("kubb-source", {
 		name: "callout",
-		children: `${title ? `> [!${label}] ${title}` : `> [!${label}]`}\n${children.trimEnd().split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n")}`
+		children: `${header}\n${quoted}`
 	});
 }
 Callout.displayName = "Callout";
@@ -210,9 +212,10 @@ File.Source = FileSource;
 * ```
 */
 function Frontmatter({ data }) {
+	const envelope = Object.keys(data).length === 0 ? "" : `---\n${(0, yaml.stringify)(data).trimEnd()}\n---`;
 	return /* @__PURE__ */ require_jsx_runtime.jsx("kubb-source", {
 		name: "frontmatter",
-		children: Object.keys(data).length === 0 ? "" : `---\n${(0, yaml.stringify)(data).trimEnd()}\n---`
+		children: envelope
 	});
 }
 Frontmatter.displayName = "Frontmatter";
@@ -233,13 +236,14 @@ Frontmatter.displayName = "Frontmatter";
 */
 function Function({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc } = props;
+	const genericsString = Array.isArray(generics) ? generics.join(", ").trim() : generics;
 	return /* @__PURE__ */ require_jsx_runtime.jsx("kubb-function", {
 		name,
 		params,
 		export: canExport,
 		default: isDefault,
 		async: isAsync,
-		generics: Array.isArray(generics) ? generics.join(", ").trim() : generics,
+		generics: genericsString,
 		returnType,
 		JSDoc,
 		children
@@ -261,13 +265,14 @@ Function.displayName = "Function";
 */
 function ArrowFunction({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async, generics, params, returnType, JSDoc, singleLine } = props;
+	const genericsString = Array.isArray(generics) ? generics.join(", ").trim() : generics;
 	return /* @__PURE__ */ require_jsx_runtime.jsx("kubb-arrow-function", {
 		name,
 		params,
 		export: canExport,
 		default: isDefault,
 		async,
-		generics: Array.isArray(generics) ? generics.join(", ").trim() : generics,
+		generics: genericsString,
 		returnType,
 		singleLine,
 		JSDoc,
@@ -338,9 +343,10 @@ Jsx.displayName = "Jsx";
 * ```
 */
 function List({ ordered, items }) {
+	const body = items.map((item, index) => `${ordered ? `${index + 1}.` : "-"} ${item}`).join("\n");
 	return /* @__PURE__ */ require_jsx_runtime.jsx("kubb-source", {
 		name: "list",
-		children: items.map((item, index) => `${ordered ? `${index + 1}.` : "-"} ${item}`).join("\n")
+		children: body
 	});
 }
 List.displayName = "List";
@@ -439,12 +445,12 @@ function collectCodeNodes(props) {
 }
 function collectCode(element, nodes) {
 	walkElement(element, (text) => {
-		if (text.trim()) nodes.push(_kubb_ast.ast.factory.createText(text));
+		if (text.trim()) nodes.push(_kubb_kit.ast.factory.createText(text));
 	}, (type, props) => resolveCodeNode(type, props, nodes));
 }
 function resolveCodeNode(type, props, nodes) {
 	if (type === "br") {
-		nodes.push(_kubb_ast.ast.factory.createBreak());
+		nodes.push(_kubb_kit.ast.factory.createBreak());
 		return;
 	}
 	if (type === "kubb-jsx") {
@@ -452,11 +458,11 @@ function resolveCodeNode(type, props, nodes) {
 		walkElement(props["children"], (t) => {
 			value += t;
 		}, () => {});
-		if (value) nodes.push(_kubb_ast.ast.factory.createJsx(value));
+		if (value) nodes.push(_kubb_kit.ast.factory.createJsx(value));
 		return;
 	}
 	if (type === "kubb-function") {
-		nodes.push(_kubb_ast.ast.factory.createFunction({
+		nodes.push(_kubb_kit.ast.factory.createFunction({
 			name: props["name"],
 			params: props["params"],
 			export: props["export"],
@@ -470,7 +476,7 @@ function resolveCodeNode(type, props, nodes) {
 		return;
 	}
 	if (type === "kubb-arrow-function") {
-		nodes.push(_kubb_ast.ast.factory.createArrowFunction({
+		nodes.push(_kubb_kit.ast.factory.createArrowFunction({
 			name: props["name"],
 			params: props["params"],
 			export: props["export"],
@@ -485,7 +491,7 @@ function resolveCodeNode(type, props, nodes) {
 		return;
 	}
 	if (type === "kubb-const") {
-		nodes.push(_kubb_ast.ast.factory.createConst({
+		nodes.push(_kubb_kit.ast.factory.createConst({
 			name: props["name"],
 			type: props["type"],
 			export: props["export"],
@@ -496,7 +502,7 @@ function resolveCodeNode(type, props, nodes) {
 		return;
 	}
 	if (type === "kubb-type") {
-		nodes.push(_kubb_ast.ast.factory.createType({
+		nodes.push(_kubb_kit.ast.factory.createType({
 			name: props["name"],
 			export: props["export"],
 			JSDoc: props["JSDoc"],
@@ -513,7 +519,7 @@ function collectFileChildren(element) {
 		if (text.trim()) throw new Error(`[jsx] '${text}' should be part of <File.Source> component when using the <File/> component`);
 	}, (type, props) => {
 		if (type === "kubb-source") {
-			sources.push(_kubb_ast.ast.factory.createSource({
+			sources.push(_kubb_kit.ast.factory.createSource({
 				name: props["name"]?.toString(),
 				isTypeOnly: !!props["isTypeOnly"],
 				isExportable: !!props["isExportable"],
@@ -523,7 +529,7 @@ function collectFileChildren(element) {
 			return;
 		}
 		if (type === "kubb-export") {
-			exports.push(_kubb_ast.ast.factory.createExport({
+			exports.push(_kubb_kit.ast.factory.createExport({
 				name: props["name"],
 				path: props["path"],
 				isTypeOnly: !!props["isTypeOnly"],
@@ -532,7 +538,7 @@ function collectFileChildren(element) {
 			return;
 		}
 		if (type === "kubb-import") {
-			imports.push(_kubb_ast.ast.factory.createImport({
+			imports.push(_kubb_kit.ast.factory.createImport({
 				name: props["name"],
 				path: props["path"],
 				root: props["root"],
@@ -589,7 +595,7 @@ function* walkFiles(element) {
 }
 /**
 * Synchronous JSX renderer that walks the element tree in a single pass,
-* producing {@link FileNode} objects directly without an intermediate virtual
+* producing {@link ast.FileNode} objects directly without an intermediate virtual
 * DOM. No React fiber, scheduler, or work loop is involved.
 *
 * All components must be pure functions. Hooks and class components are not
@@ -597,12 +603,12 @@ function* walkFiles(element) {
 */
 var Runtime = class {
 	/**
-	* Accumulated {@link FileNode} results from every {@link render} call.
+	* Accumulated {@link ast.FileNode} results from every {@link render} call.
 	*/
 	nodes = [];
 	/**
 	* Walks `element` synchronously, converts every `<kubb-file>` subtree into
-	* a {@link FileNode} with no intermediate virtual DOM, and appends the results
+	* a {@link ast.FileNode} with no intermediate virtual DOM, and appends the results
 	* to {@link nodes}.
 	*/
 	render(element) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { i as KubbReactNode, n as Key, r as KubbReactElement, t as JSDoc } from "./types-seYG0czS.js";
-import { ExportNode, ImportNode, SourceNode } from "@kubb/ast";
+import { ast } from "@kubb/kit";
 //#region src/components/md/Callout.d.ts
 declare const CALLOUT_LABEL: {
   readonly tip: "TIP";
@@ -190,7 +190,7 @@ declare namespace File {
   var Import: typeof FileImport;
   var Source: typeof FileSource;
 }
-type FileSourceProps = Omit<SourceNode, 'kind' | 'value'> & {
+type FileSourceProps = Omit<ast.SourceNode, 'kind' | 'value'> & {
   key?: Key;
   /**
    * Child nodes rendered as the source content of this block.
@@ -221,7 +221,7 @@ declare function FileSource({ children, ...props }: FileSourceProps): KubbReactE
 declare namespace FileSource {
   var displayName: string;
 }
-type FileExportProps = Omit<ExportNode, 'kind'> & {
+type FileExportProps = Omit<ast.ExportNode, 'kind'> & {
   key?: Key;
 };
 /**
@@ -245,7 +245,7 @@ declare function FileExport(props: FileExportProps): KubbReactElement;
 declare namespace FileExport {
   var displayName: string;
 }
-type FileImportProps = Omit<ImportNode, 'kind'> & {
+type FileImportProps = Omit<ast.ImportNode, 'kind'> & {
   key?: Key;
 };
 /**
@@ -596,6 +596,508 @@ declare namespace Type {
   var displayName: string;
 }
 //#endregion
+//#region ../ast/src/nodes/base.d.ts
+/**
+ * `kind` values used by AST nodes.
+ *
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'Type' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
+/**
+ * Base shape shared by all AST nodes.
+ *
+ * @example
+ * ```ts
+ * const base: BaseNode = { kind: 'Input' }
+ * ```
+ */
+type BaseNode = {
+  /**
+   * Node discriminator.
+   */
+  kind: NodeKind;
+};
+//#endregion
+//#region ../ast/src/nodes/code.d.ts
+/**
+ * JSDoc documentation metadata attached to code declarations.
+ */
+type JSDocNode = {
+  /**
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
+   */
+  comments?: Array<string | undefined>;
+};
+/**
+ * AST node representing a TypeScript `const` declaration.
+ *
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
+ * ```
+ */
+type ConstNode = BaseNode & {
+  kind: 'Const';
+  /**
+   * Name of the constant declaration.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  type?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Whether to append `as const` to the declaration.
+   */
+  asConst?: boolean | null;
+  /**
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+type TypeNode = BaseNode & {
+  kind: 'Type';
+  /**
+   * Name of the type alias.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `function` declaration.
+ *
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
+ * ```
+ */
+type FunctionNode = BaseNode & {
+  kind: 'Function';
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   */
+  default?: boolean | null;
+  /**
+   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
+   *
+   * @example
+   * `'id: string, config: Config = {}'`
+   */
+  params?: string | null;
+  /**
+   * Whether the function should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   */
+  async?: boolean | null;
+  /**
+   * TypeScript generic type parameters.
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
+  kind: 'ArrowFunction';
+  /**
+   * Render the arrow function body as a single-line expression.
+   */
+  singleLine?: boolean | null;
+};
+/**
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+type TextNode = BaseNode & {
+  kind: 'Text';
+  /**
+   * The raw string content.
+   */
+  value: string;
+};
+/**
+ * AST node representing a blank line in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
+ * statements into one blank line. Consecutive breaks, and breaks at the start or end of
+ * the list, are folded away, so a `Break` never produces more than one blank line.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+type BreakNode = BaseNode & {
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
+ */
+type JsxNode = BaseNode & {
+  kind: 'Jsx';
+  /**
+   * The raw JSX string content.
+   */
+  value: string;
+};
+/**
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
+ */
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
+//#endregion
+//#region ../ast/src/nodes/file.d.ts
+/**
+ * Supported file extensions.
+ */
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
+/**
+ * Represents a language-agnostic import/dependency declaration.
+ *
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
+ *
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
+ *
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
+ *
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * ```
+ */
+type ImportNode = BaseNode & {
+  kind: 'Import';
+  /**
+   * Import name(s) to be used.
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Import the entire module as a namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates a standard import
+   */
+  isNameSpace?: boolean | null;
+  /**
+   * When set, the import path is resolved relative to this root.
+   */
+  root?: string | null;
+};
+/**
+ * Represents a language-agnostic export/public API declaration.
+ *
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * ```
+ */
+type ExportNode = BaseNode & {
+  kind: 'Export';
+  /**
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
+   */
+  name?: string | Array<string> | null;
+  /**
+   * Path for the export.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   */
+  asAlias?: boolean | null;
+};
+/**
+ * Represents a fragment of source code within a file.
+ *
+ * @example Named exportable source
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
+ * ```
+ *
+ * @example Inline unnamed code block
+ * ```ts
+ * createSource({ nodes: [createText('const x = 1')] })
+ * ```
+ */
+type SourceNode = BaseNode & {
+  kind: 'Source';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string | null;
+  /**
+   * Mark this source as a type-only export.
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Include the `export` keyword in the generated source.
+   */
+  isExportable?: boolean | null;
+  /**
+   * Include this source in barrel/index file generation.
+   */
+  isIndexable?: boolean | null;
+  /**
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id   = SHA256 hash of the path
+ * // file.name = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
+  /**
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
+   */
+  id: string;
+  /**
+   * File name without extension, derived from `baseName`.
+   *
+   * @see https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  /**
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: `${string}.${string}`;
+  /**
+   * Full qualified path to the file.
+   */
+  path: string;
+  /**
+   * File extension extracted from `baseName`.
+   */
+  extname: Extname;
+  /**
+   * Deduplicated list of source code fragments.
+   */
+  sources: Array<SourceNode>;
+  /**
+   * Deduplicated list of import declarations.
+   */
+  imports: Array<ImportNode>;
+  /**
+   * Deduplicated list of export declarations.
+   */
+  exports: Array<ExportNode>;
+  /**
+   * Optional metadata attached to this file, read by plugins during barrel generation.
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   */
+  footer?: string | null;
+  /**
+   * Absolute on-disk path to copy verbatim into the output, bypassing the parser.
+   *
+   * Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder without reformatting or import reordering. Only `banner` and `footer` are applied
+   * around the copied content. When set, `copy` provides the file content and any `sources`
+   * nodes are ignored for output; `sources` may still carry `name`/`isExportable`/`isIndexable`
+   * so barrel generation treats the file the same as a rendered one.
+   */
+  copy?: string | null;
+};
+//#endregion
 //#region src/jsxRenderer.d.ts
 /**
  * Factory for a renderer that walks the JSX tree in a single recursive pass,
@@ -626,7 +1128,7 @@ declare namespace Type {
  */
 declare const jsxRenderer: () => {
   render(element: KubbReactElement): Promise<void>;
-  readonly files: import("@kubb/ast").FileNode[];
+  readonly files: FileNode[];
   [Symbol.dispose](): void;
 };
 //#endregion

package/dist/index.js

@@ -1,7 +1,7 @@
 import "./rolldown-runtime-C0LytTxp.js";
 import { Fragment, jsx } from "./jsx-runtime.js";
 import { stringify } from "yaml";
-import { ast } from "@kubb/ast";
+import { ast } from "@kubb/kit";
 //#region src/components/md/Callout.tsx
 const CALLOUT_LABEL = {
 	tip: "TIP",
@@ -29,9 +29,11 @@ const CALLOUT_LABEL = {
 */
 function Callout({ type, title, children }) {
 	const label = CALLOUT_LABEL[type];
+	const header = title ? `> [!${label}] ${title}` : `> [!${label}]`;
+	const quoted = children.trimEnd().split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
 	return /* @__PURE__ */ jsx("kubb-source", {
 		name: "callout",
-		children: `${title ? `> [!${label}] ${title}` : `> [!${label}]`}\n${children.trimEnd().split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n")}`
+		children: `${header}\n${quoted}`
 	});
 }
 Callout.displayName = "Callout";
@@ -209,9 +211,10 @@ File.Source = FileSource;
 * ```
 */
 function Frontmatter({ data }) {
+	const envelope = Object.keys(data).length === 0 ? "" : `---\n${stringify(data).trimEnd()}\n---`;
 	return /* @__PURE__ */ jsx("kubb-source", {
 		name: "frontmatter",
-		children: Object.keys(data).length === 0 ? "" : `---\n${stringify(data).trimEnd()}\n---`
+		children: envelope
 	});
 }
 Frontmatter.displayName = "Frontmatter";
@@ -232,13 +235,14 @@ Frontmatter.displayName = "Frontmatter";
 */
 function Function({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc } = props;
+	const genericsString = Array.isArray(generics) ? generics.join(", ").trim() : generics;
 	return /* @__PURE__ */ jsx("kubb-function", {
 		name,
 		params,
 		export: canExport,
 		default: isDefault,
 		async: isAsync,
-		generics: Array.isArray(generics) ? generics.join(", ").trim() : generics,
+		generics: genericsString,
 		returnType,
 		JSDoc,
 		children
@@ -260,13 +264,14 @@ Function.displayName = "Function";
 */
 function ArrowFunction({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async, generics, params, returnType, JSDoc, singleLine } = props;
+	const genericsString = Array.isArray(generics) ? generics.join(", ").trim() : generics;
 	return /* @__PURE__ */ jsx("kubb-arrow-function", {
 		name,
 		params,
 		export: canExport,
 		default: isDefault,
 		async,
-		generics: Array.isArray(generics) ? generics.join(", ").trim() : generics,
+		generics: genericsString,
 		returnType,
 		singleLine,
 		JSDoc,
@@ -337,9 +342,10 @@ Jsx.displayName = "Jsx";
 * ```
 */
 function List({ ordered, items }) {
+	const body = items.map((item, index) => `${ordered ? `${index + 1}.` : "-"} ${item}`).join("\n");
 	return /* @__PURE__ */ jsx("kubb-source", {
 		name: "list",
-		children: items.map((item, index) => `${ordered ? `${index + 1}.` : "-"} ${item}`).join("\n")
+		children: body
 	});
 }
 List.displayName = "List";
@@ -588,7 +594,7 @@ function* walkFiles(element) {
 }
 /**
 * Synchronous JSX renderer that walks the element tree in a single pass,
-* producing {@link FileNode} objects directly without an intermediate virtual
+* producing {@link ast.FileNode} objects directly without an intermediate virtual
 * DOM. No React fiber, scheduler, or work loop is involved.
 *
 * All components must be pure functions. Hooks and class components are not
@@ -596,12 +602,12 @@ function* walkFiles(element) {
 */
 var Runtime = class {
 	/**
-	* Accumulated {@link FileNode} results from every {@link render} call.
+	* Accumulated {@link ast.FileNode} results from every {@link render} call.
 	*/
 	nodes = [];
 	/**
 	* Walks `element` synchronously, converts every `<kubb-file>` subtree into
-	* a {@link FileNode} with no intermediate virtual DOM, and appends the results
+	* a {@link ast.FileNode} with no intermediate virtual DOM, and appends the results
 	* to {@link nodes}.
 	*/
 	render(element) {

package/dist/jsx-dev-runtime.d.ts

@@ -1,9 +1,2 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { i as KubbReactNode, r as KubbReactElement } from "./types-seYG0czS.js";
 import { Fragment, JSX, jsxDEV } from "./jsx-runtime.js";
-//#region src/jsx-dev-runtime.d.ts
-type JSXElement = KubbReactElement;
-type ReactNode = KubbReactNode;
-//#endregion
-export { Fragment, type JSX, JSXElement, ReactNode, jsxDEV };
-//# sourceMappingURL=jsx-dev-runtime.d.ts.map
+export { Fragment, type JSX, jsxDEV };

package/dist/jsx-runtime.d.ts

@@ -1,6 +1,6 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { i as KubbReactNode, n as Key, r as KubbReactElement } from "./types-seYG0czS.js";
-import { ArrowFunctionNode, ConstNode, ExportNode, FunctionNode, ImportNode, SourceNode, TypeNode } from "@kubb/ast";
+import { ast } from "@kubb/kit";
 //#region src/jsx-namespace.d.ts
 /**
  * JSX contract for `@kubb/renderer-jsx`, resolved through `jsxImportSource`.
@@ -43,21 +43,21 @@ declare namespace JSX {
       copy?: string | null;
       meta?: FileNode['meta'] | null;
     };
-    ['kubb-source']: Omit<SourceNode, 'kind'> & {
+    ['kubb-source']: Omit<ast.SourceNode, 'kind'> & {
       children?: KubbReactNode;
     };
-    ['kubb-import']: Omit<ImportNode, 'kind'> & {};
-    ['kubb-export']: Omit<ExportNode, 'kind'> & {};
-    ['kubb-function']: Omit<FunctionNode, 'kind'> & {
+    ['kubb-import']: Omit<ast.ImportNode, 'kind'> & {};
+    ['kubb-export']: Omit<ast.ExportNode, 'kind'> & {};
+    ['kubb-function']: Omit<ast.FunctionNode, 'kind'> & {
       children?: KubbReactNode;
     };
-    ['kubb-arrow-function']: Omit<ArrowFunctionNode, 'kind'> & {
+    ['kubb-arrow-function']: Omit<ast.ArrowFunctionNode, 'kind'> & {
       children?: KubbReactNode;
     };
-    ['kubb-const']: Omit<ConstNode, 'kind'> & {
+    ['kubb-const']: Omit<ast.ConstNode, 'kind'> & {
       children?: KubbReactNode;
     };
-    ['kubb-type']: Omit<TypeNode, 'kind'> & {
+    ['kubb-type']: Omit<ast.TypeNode, 'kind'> & {
       children?: KubbReactNode;
     };
     br: {};
@@ -81,8 +81,6 @@ declare function createElement(type: unknown, props: Record<string, unknown> | n
 declare const jsx: typeof createElement;
 declare const jsxs: typeof createElement;
 declare const jsxDEV: typeof createElement;
-type JSXElement = KubbReactElement;
-type ReactNode = KubbReactNode;
 //#endregion
-export { Fragment, type JSX, JSXElement, ReactNode, jsx, jsxDEV, jsxs };
+export { Fragment, type JSX, jsx, jsxDEV, jsxs };
 //# sourceMappingURL=jsx-runtime.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/renderer-jsx",
-  "version": "5.0.0-beta.99",
+  "version": "5.0.0",
   "description": "Self-contained synchronous JSX renderer for Kubb. Turns JSX into FileNodes with built-in components (File, Function, Type, Const). An alternative for the ast.factory syntax.",
   "keywords": [
     "codegen",
@@ -69,7 +69,7 @@
   },
   "dependencies": {
     "yaml": "^2.9.0",
-    "@kubb/ast": "5.0.0-beta.99"
+    "@kubb/kit": "5.0.0"
   },
   "engines": {
     "node": ">=22"