@kubb/renderer-jsx 5.0.0-alpha.34 → 5.0.0-alpha.35

package/dist/index.js

@@ -1,7 +1,7 @@
-import { n as __name, r as __toESM, t as __commonJSMin } from "./chunk-CErwXX-a.js";
-import { n as require_react } from "./jsx-runtime-Dmf9wTKR.js";
+import { n as __name, r as __toESM, t as __commonJSMin } from "./chunk-Bb7HlUDG.js";
+import { n as require_react } from "./jsx-runtime-7z5lYBqC.js";
 import { Fragment, jsx } from "./jsx-runtime.js";
-import { createArrowFunction, createBreak, createConst, createFunction, createJsx, createSource, createText, createType } from "@kubb/ast";
+import { createArrowFunction, createBreak, createConst, createExport, createFunction, createImport, createJsx, createSource, createText, createType } from "@kubb/ast";
 //#region ../../internals/utils/src/context.ts
 /**
 * Context stack for tracking the current context values
@@ -109,6 +109,21 @@ function onProcessExit(callback) {
 //#region src/components/Const.tsx
 /**
 * Generates a TypeScript constant declaration.
+*
+* @example Named export with type annotation
+* ```tsx
+* <Const export name="petSchema" type="z.ZodType<Pet>">
+*   {`z.object({ id: z.number() })`}
+* </Const>
+* // export const petSchema: z.ZodType<Pet> = z.object({ id: z.number() })
+* ```
+*
+* @example With JSDoc and const assertion
+* ```tsx
+* <Const name="HTTP_METHODS" asConst JSDoc={{ comments: ['@description Supported HTTP methods.'] }}>
+*   {`['GET', 'POST', 'PUT', 'DELETE']`}
+* </Const>
+* ```
 */
 function Const({ children, ...props }) {
 	const { name, export: canExport, type, JSDoc, asConst } = props;
@@ -125,7 +140,20 @@ Const.displayName = "Const";
 //#endregion
 //#region src/components/File.tsx
 /**
-* Adds files to the FileManager
+* Declares a generated file entry to be collected by the renderer.
+*
+* When both `baseName` and `path` are provided, the component registers a new
+* `FileNode` and passes its children through as source blocks.
+* When either is omitted the children are rendered inline without creating a file entry.
+*
+* @example Basic file with a source block
+* ```tsx
+* <File baseName="petStore.ts" path="src/models/petStore.ts">
+*   <File.Source name="Pet" isExportable isIndexable>
+*     {`export type Pet = { id: number; name: string }`}
+*   </File.Source>
+* </File>
+* ```
 */
 function File({ children, ...props }) {
 	const { baseName, path } = props;
@@ -137,10 +165,24 @@ function File({ children, ...props }) {
 }
 File.displayName = "File";
 /**
-* File.Source
+* Marks a block of source text to be associated with the enclosing {@link File}.
+*
+* Children are treated as the source string. When `isExportable` is `true` the
+* `name` is used for deduplication and barrel generation.
+*
+* @example Exportable, indexable source block
+* ```tsx
+* <File.Source name="Pet" isExportable isIndexable>
+*   {`export type Pet = { id: number; name: string }`}
+* </File.Source>
+* ```
 *
-* Marks a block of source text to be associated with the current file when
-* rendering with the FileCollector. Children are treated as the source string.
+* @example Type-only source block
+* ```tsx
+* <File.Source name="PetId" isTypeOnly isExportable>
+*   {`export type PetId = string`}
+* </File.Source>
+* ```
 */
 function FileSource({ children, ...props }) {
 	const { name, isExportable, isIndexable, isTypeOnly } = props;
@@ -154,10 +196,21 @@ function FileSource({ children, ...props }) {
 }
 FileSource.displayName = "FileSource";
 /**
-* File.Export
+* Declares an export entry for the enclosing {@link File}.
 *
-* Declares an export entry for the current file. This will be collected by
-* the FileCollector for later emission.
+* The export is collected by the renderer and emitted at the top of the generated file.
+*
+* @example Named export
+* ```tsx
+* <File.Export name={['Pet']} path="./models/petStore" />
+* // export { Pet } from './models/petStore'
+* ```
+*
+* @example Type-only wildcard export
+* ```tsx
+* <File.Export path="./models/petStore" isTypeOnly />
+* // export type * from './models/petStore'
+* ```
 */
 function FileExport(props) {
 	const { name, path, isTypeOnly, asAlias } = props;
@@ -170,9 +223,27 @@ function FileExport(props) {
 }
 FileExport.displayName = "FileExport";
 /**
-* File.Import
+* Declares an import entry for the enclosing {@link File}.
+*
+* The import is collected by the renderer and emitted at the top of the generated file.
 *
-* Declares an import entry for the current file.
+* @example Named import
+* ```tsx
+* <File.Import name={['useState']} path="react" />
+* // import { useState } from 'react'
+* ```
+*
+* @example Type-only import
+* ```tsx
+* <File.Import name={['Pet']} path="./models" isTypeOnly />
+* // import type { Pet } from './models'
+* ```
+*
+* @example Namespace import
+* ```tsx
+* <File.Import name="z" path="zod" isNameSpace />
+* // import * as z from 'zod'
+* ```
 */
 function FileImport(props) {
 	const { name, root, path, isTypeOnly, isNameSpace } = props;
@@ -192,6 +263,16 @@ File.Source = FileSource;
 //#region src/components/Function.tsx
 /**
 * Generates a TypeScript function declaration.
+*
+* @example Async exported function with generics
+* ```tsx
+* <Function export async name="getPet" generics={['TData = Pet']} params="petId: string" returnType="TData">
+*   {`return client.get(\`/pets/\${petId}\`)`}
+* </Function>
+* // export async function getPet<TData = Pet>(petId: string): Promise<TData> {
+* //   return client.get(`/pets/${petId}`)
+* // }
+* ```
 */
 function Function$1({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc } = props;
@@ -210,10 +291,17 @@ function Function$1({ children, ...props }) {
 __name(Function$1, "Function");
 Function$1.displayName = "Function";
 /**
-* ArrowFunction
+* Generates an arrow function expression assigned to a `const`.
+* Supports the same flags as {@link Function}.
+* Use `singleLine` to render the body as a concise expression rather than a block.
 *
-* Renders an arrow function definition. Supports the same flags as `Function`.
-* Use `singleLine` to render the body as a single-line expression.
+* @example Single-line arrow function
+* ```tsx
+* <Function.Arrow export name="double" params="n: number" returnType="number" singleLine>
+*   {`n * 2`}
+* </Function.Arrow>
+* // export const double = (n: number): number => n * 2
+* ```
 */
 function ArrowFunction({ children, ...props }) {
 	const { name, default: isDefault, export: canExport, async, generics, params, returnType, JSDoc, singleLine } = props;
@@ -271,7 +359,10 @@ var ErrorBoundary = class extends import_react.Component {
 	}
 };
 /**
-* This component provides the root behavior for the Kubb runtime.
+* Root component for the Kubb renderer tree.
+*
+* Wraps all children in an `ErrorBoundary` so that render errors are caught
+* and forwarded to `onError` rather than crashing the process.
 */
 function Root({ onError, children }) {
 	return /* @__PURE__ */ jsx(ErrorBoundary, {
@@ -285,7 +376,25 @@ Root.displayName = "Root";
 //#endregion
 //#region src/components/Type.tsx
 /**
-* Generates a TypeScript type declaration.
+* Generates a TypeScript type alias declaration.
+*
+* Throws if `name` does not start with an uppercase letter — TypeScript type aliases
+* should follow PascalCase naming conventions.
+*
+* @example Simple exported type alias
+* ```tsx
+* <Type export name="PetId">
+*   {`string | number`}
+* </Type>
+* // export type PetId = string | number
+* ```
+*
+* @example Type alias with JSDoc
+* ```tsx
+* <Type export name="Pet" JSDoc={{ comments: ['@description A pet in the store.'] }}>
+*   {`{ id: number; name: string }`}
+* </Type>
+* ```
 */
 function Type({ children, ...props }) {
 	const { name, export: canExport, JSDoc } = props;
@@ -351,11 +460,42 @@ var require_react_reconciler_constants_development = /* @__PURE__ */ __commonJSM
 	"production" !== process.env.NODE_ENV && (exports.ConcurrentRoot = 1, exports.ContinuousEventPriority = 8, exports.DefaultEventPriority = 32, exports.DiscreteEventPriority = 2, exports.IdleEventPriority = 268435456, exports.LegacyRoot = 0, exports.NoEventPriority = 0);
 }));
 //#endregion
-//#region src/dom.ts
+//#region src/constants.ts
 var import_constants = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_reconciler_constants_production();
 	else module.exports = require_react_reconciler_constants_development();
 })))();
+/**
+* Name used for text-node entries in the virtual DOM.
+*/
+const TEXT_NODE_NAME = "#text";
+/**
+* Set of all element names recognized by the Kubb renderer.
+* Used to distinguish Kubb-owned elements from unrecognized or text nodes during tree traversal.
+*/
+const nodeNames = new Set([
+	"kubb-export",
+	"kubb-file",
+	"kubb-source",
+	"kubb-import",
+	"kubb-function",
+	"kubb-arrow-function",
+	"kubb-const",
+	"kubb-type",
+	"kubb-jsx",
+	"kubb-text",
+	"kubb-root",
+	"kubb-app",
+	"br",
+	"indent",
+	"dedent"
+]);
+//#endregion
+//#region src/dom.ts
+/**
+* Create a new, empty {@link DOMElement} with the given node name.
+* The element has no attributes, no children, and no parent.
+*/
 const createNode = (nodeName) => {
 	return {
 		nodeName,
@@ -364,6 +504,13 @@ const createNode = (nodeName) => {
 		parentNode: void 0
 	};
 };
+/**
+* Append `childNode` as the last child of `node`.
+*
+* If `childNode` already has a parent, it is removed from that parent first
+* (matching standard DOM move semantics).
+* Text nodes (`nodeName === '#text'`) are silently ignored.
+*/
 const appendChildNode = (node, childNode) => {
 	if (childNode.parentNode) removeChildNode(childNode.parentNode, childNode);
 	if (node.nodeName !== "#text") {
@@ -371,6 +518,12 @@ const appendChildNode = (node, childNode) => {
 		node.childNodes.push(childNode);
 	}
 };
+/**
+* Insert `newChildNode` before `beforeChildNode` in `node`'s child list.
+*
+* If `newChildNode` already has a parent, it is removed from that parent first.
+* If `beforeChildNode` is not found, `newChildNode` is appended at the end.
+*/
 const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
 	if (newChildNode.parentNode) removeChildNode(newChildNode.parentNode, newChildNode);
 	newChildNode.parentNode = node;
@@ -381,44 +534,41 @@ const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
 	}
 	node.childNodes.push(newChildNode);
 };
+/**
+* Remove `removeNode` from `node`'s child list and clear its `parentNode` reference.
+* Does nothing if `removeNode` is not a direct child of `node`.
+*/
 const removeChildNode = (node, removeNode) => {
 	removeNode.parentNode = void 0;
 	const index = node.childNodes.indexOf(removeNode);
 	if (index >= 0) node.childNodes.splice(index, 1);
 };
+/**
+* Set an attribute on `node`, storing it in the node's `attributes` map.
+*/
 const setAttribute = (node, key, value) => {
 	node.attributes.set(key, value);
 };
+/**
+* Create a new {@link TextNode} with the given text value.
+*/
 const createTextNode = (text) => {
 	const node = {
-		nodeName: "#text",
+		nodeName: TEXT_NODE_NAME,
 		nodeValue: text,
 		parentNode: void 0
 	};
 	setTextNodeValue(node, text);
 	return node;
 };
+/**
+* Update the `nodeValue` of an existing {@link TextNode}.
+* Non-string values are coerced to strings via `String(text)`.
+*/
 const setTextNodeValue = (node, text) => {
 	if (typeof text !== "string") text = String(text);
 	node.nodeValue = text;
 };
-const nodeNames = new Set([
-	"kubb-export",
-	"kubb-file",
-	"kubb-source",
-	"kubb-import",
-	"kubb-function",
-	"kubb-arrow-function",
-	"kubb-const",
-	"kubb-type",
-	"kubb-jsx",
-	"kubb-text",
-	"kubb-root",
-	"kubb-app",
-	"br",
-	"indent",
-	"dedent"
-]);
 //#endregion
 //#region ../../node_modules/.pnpm/scheduler@0.27.0/node_modules/scheduler/cjs/scheduler.production.js
 /**
@@ -17720,7 +17870,7 @@ const Renderer = (0, import_react_reconciler.default)({
 	},
 	getCurrentUpdatePriority: () => currentUpdatePriority,
 	resolveUpdatePriority() {
-		if (currentUpdatePriority !== 0) return currentUpdatePriority;
+		if (currentUpdatePriority !== import_constants.NoEventPriority) return currentUpdatePriority;
 		return import_constants.DefaultEventPriority;
 	},
 	maySuspendCommit() {
@@ -17753,8 +17903,10 @@ const Renderer = (0, import_react_reconciler.default)({
 //#region src/utils.ts
 /**
 * Collect the text and nested AST-node children of a single kubb-* element.
-* `#text` children become raw strings; nested kubb-function/const/type children
-* become their respective {@link CodeNode}s. Other DOM elements are skipped.
+*
+* `#text` children become raw {@link TextNode}s; nested `kubb-function`, `kubb-const`,
+* `kubb-type`, and similar elements are converted into their respective {@link CodeNode}s.
+* Any unrecognized DOM elements are silently skipped.
 */
 function collectChildNodes(element) {
 	const result = [];
@@ -17822,6 +17974,17 @@ function collectChildNodes(element) {
 	}
 	return result;
 }
+/**
+* Traverse `node` and collect all `<kubb-source>` elements into a `Set<SourceNode>`.
+*
+* Elements whose `nodeName` is in `ignores` are skipped entirely (including their subtrees).
+* This is used to collect source blocks from a file node while excluding import/export subtrees.
+*
+* @example Collect sources while ignoring export and import elements
+* ```ts
+* const sources = squashSourceNodes(fileElement, ['kubb-export', 'kubb-import'])
+* ```
+*/
 function squashSourceNodes(node, ignores) {
 	const ignoreSet = new Set(ignores);
 	const sources = /* @__PURE__ */ new Set();
@@ -17830,70 +17993,12 @@ function squashSourceNodes(node, ignores) {
 			if (!child) continue;
 			if (child.nodeName !== "#text" && ignoreSet.has(child.nodeName)) continue;
 			if (child.nodeName === "kubb-source") {
-				const orderedNodes = [];
-				for (const c of child.childNodes) {
-					if (!c) continue;
-					if (c.nodeName === "#text") {
-						const text = c.nodeValue;
-						if (text && text.trim().length > 0) orderedNodes.push(createText(text));
-					} else if (c.nodeName === "br") orderedNodes.push(createBreak());
-					else if (c.nodeName === "kubb-function") {
-						const attrs = c.attributes;
-						orderedNodes.push(createFunction({
-							name: attrs.get("name"),
-							params: attrs.get("params"),
-							export: attrs.get("export"),
-							default: attrs.get("default"),
-							async: attrs.get("async"),
-							generics: attrs.get("generics"),
-							returnType: attrs.get("returnType"),
-							JSDoc: attrs.get("JSDoc"),
-							nodes: collectChildNodes(c)
-						}));
-					} else if (c.nodeName === "kubb-arrow-function") {
-						const attrs = c.attributes;
-						orderedNodes.push(createArrowFunction({
-							name: attrs.get("name"),
-							params: attrs.get("params"),
-							export: attrs.get("export"),
-							default: attrs.get("default"),
-							async: attrs.get("async"),
-							generics: attrs.get("generics"),
-							returnType: attrs.get("returnType"),
-							singleLine: attrs.get("singleLine"),
-							JSDoc: attrs.get("JSDoc"),
-							nodes: collectChildNodes(c)
-						}));
-					} else if (c.nodeName === "kubb-const") {
-						const attrs = c.attributes;
-						orderedNodes.push(createConst({
-							name: attrs.get("name"),
-							type: attrs.get("type"),
-							export: attrs.get("export"),
-							asConst: attrs.get("asConst"),
-							JSDoc: attrs.get("JSDoc"),
-							nodes: collectChildNodes(c)
-						}));
-					} else if (c.nodeName === "kubb-type") {
-						const attrs = c.attributes;
-						orderedNodes.push(createType({
-							name: attrs.get("name"),
-							export: attrs.get("export"),
-							JSDoc: attrs.get("JSDoc"),
-							nodes: collectChildNodes(c)
-						}));
-					} else if (c.nodeName === "kubb-jsx") {
-						const textChild = c.childNodes[0];
-						const value = textChild?.nodeName === "#text" ? textChild.nodeValue : "";
-						if (value) orderedNodes.push(createJsx(value));
-					}
-				}
 				const source = createSource({
 					name: child.attributes.get("name")?.toString(),
 					isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
 					isExportable: child.attributes.get("isExportable") ?? false,
 					isIndexable: child.attributes.get("isIndexable") ?? false,
-					nodes: orderedNodes
+					nodes: collectChildNodes(child)
 				});
 				sources.add(source);
 				continue;
@@ -17904,47 +18009,60 @@ function squashSourceNodes(node, ignores) {
 	walk(node);
 	return sources;
 }
+/**
+* Traverse `node` and collect all `<kubb-export>` elements into a `Set<ExportNode>`.
+*/
 function squashExportNodes(node) {
 	const exports = /* @__PURE__ */ new Set();
 	const walk = (current) => {
 		for (const child of current.childNodes) {
 			if (!child) continue;
 			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-export") exports.add({
+			if (child.nodeName === "kubb-export") exports.add(createExport({
 				name: child.attributes.get("name"),
 				path: child.attributes.get("path"),
 				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
 				asAlias: child.attributes.get("asAlias") ?? false
-			});
+			}));
 		}
 	};
 	walk(node);
 	return exports;
 }
+/**
+* Traverse `node` and collect all `<kubb-import>` elements into a `Set<ImportNode>`.
+*/
 function squashImportNodes(node) {
 	const imports = /* @__PURE__ */ new Set();
 	const walk = (current) => {
 		for (const child of current.childNodes) {
 			if (!child) continue;
 			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-import") imports.add({
+			if (child.nodeName === "kubb-import") imports.add(createImport({
 				name: child.attributes.get("name"),
 				path: child.attributes.get("path"),
 				root: child.attributes.get("root"),
 				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
 				isNameSpace: child.attributes.get("isNameSpace") ?? false
-			});
+			}));
 		}
 	};
 	walk(node);
 	return imports;
 }
-async function processFiles(node) {
+/**
+* Walk the virtual DOM tree rooted at `node` and convert every `<kubb-file>` element
+* into a {@link FileNode}, collecting its source blocks, imports, and exports.
+*
+* Returns the list of file nodes in document order. Nested files are supported —
+* the walker descends into non-file elements and recurses through them.
+*/
+function processFiles(node) {
 	const collected = [];
-	async function walk(current) {
+	function walk(current) {
 		for (const child of current.childNodes) {
 			if (!child) continue;
-			if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) await walk(child);
+			if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) walk(child);
 			if (child.nodeName === "kubb-file") {
 				if (child.attributes.has("baseName") && child.attributes.has("path")) {
 					const sources = squashSourceNodes(child, ["kubb-export", "kubb-import"]);
@@ -17962,7 +18080,7 @@ async function processFiles(node) {
 			}
 		}
 	}
-	await walk(node);
+	walk(node);
 	return collected;
 }
 //#endregion
@@ -17999,12 +18117,13 @@ var Runtime = class {
 	rejectExitPromise = () => {};
 	unsubscribeExit = () => {};
 	onRender = () => {
-		this.#renderPromise = this.#renderPromise.catch(() => {}).then(async () => {
+		const task = this.#renderPromise.catch(() => {}).then(() => {
 			if (this.#isUnmounted) return;
-			const files = await processFiles(this.#rootNode);
+			const files = processFiles(this.#rootNode);
 			this.nodes.push(...files);
 			if (!this.#options?.debug) return;
-		}).catch((error) => {
+		});
+		this.#renderPromise = task.catch((error) => {
 			this.onError(error);
 		});
 		return this.#renderPromise;
@@ -18055,6 +18174,28 @@ var Runtime = class {
 };
 //#endregion
 //#region src/createRenderer.tsx
+/**
+* Create a Kubb JSX renderer.
+*
+* The renderer converts a React JSX element tree — built from the components in this
+* package — into an array of {@link FileNode} entries representing the generated files.
+*
+* @example Basic usage
+* ```ts
+* import { createRenderer, File } from '@kubb/renderer-jsx'
+*
+* const renderer = createRenderer()
+* await renderer.render(
+*   <File baseName="pet.ts" path="src/models/pet.ts">
+*     <File.Source name="Pet" isExportable isIndexable>
+*       {`export type Pet = { id: number; name: string }`}
+*     </File.Source>
+*   </File>
+* )
+* console.log(renderer.files) // [FileNode]
+* renderer.unmount()
+* ```
+*/
 function createRenderer(options = {}) {
 	const runtime = new Runtime(options);
 	return {
@@ -18069,7 +18210,29 @@ function createRenderer(options = {}) {
 		}
 	};
 }
+/**
+* A renderer factory for generators that produce JSX output.
+*
+* Pass this as the `renderer` property of a `defineGenerator` call so that
+* core can render the JSX element tree returned by your generator methods
+* without a hard dependency on `@kubb/renderer-jsx`.
+*
+* @example
+* ```ts
+* import { jsxRenderer } from '@kubb/renderer-jsx'
+* import { defineGenerator } from '@kubb/core'
+*
+* export const myGenerator = defineGenerator<PluginTs>({
+*   name: 'my-generator',
+*   renderer: jsxRenderer,
+*   schema(node, options) {
+*     return <File baseName="output.ts" path="src/output.ts">...</File>
+*   },
+* })
+* ```
+*/
+const jsxRenderer = () => createRenderer();
 //#endregion
-export { Const, File, Function$1 as Function, Jsx, KubbContext, OasContext, Root, Type, createContext, createRenderer, inject, provide, unprovide };
+export { Const, File, Function$1 as Function, Jsx, KubbContext, OasContext, Root, Type, createContext, createRenderer, inject, jsxRenderer, provide, unprovide };
 
 //# sourceMappingURL=index.js.map