@kubb/renderer-jsx 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { n as __name } from "./chunk-Bb7HlUDG.js";
-import { a as JSDoc, h as KubbReactNode, m as KubbReactElement, o as Key } from "./types-nAFMiWFw.js";
+import { a as JSDoc, h as KubbReactNode, m as KubbReactElement, o as Key } from "./types-Cur_nGCL.js";
 import { ExportNode, FileNode, ImportNode, SourceNode } from "@kubb/ast";
 import * as _$react from "react";
 
@@ -47,6 +47,95 @@ declare function unprovide<T>(key: symbol | Context<T>): void;
  */
 declare function createContext<T>(defaultValue: T): Context<T>;
 //#endregion
+//#region src/components/Callout.d.ts
+declare const CALLOUT_LABEL: {
+  readonly tip: "TIP";
+  readonly note: "NOTE";
+  readonly important: "IMPORTANT";
+  readonly warning: "WARNING";
+  readonly caution: "CAUTION";
+};
+type CalloutType = keyof typeof CALLOUT_LABEL;
+type Props$8 = {
+  key?: Key;
+  /**
+   * Callout kind. Maps to the uppercase label inside the `> [!TYPE]` marker.
+   */
+  type: CalloutType;
+  /**
+   * Optional title rendered on the same line as the marker.
+   */
+  title?: string | null;
+  /**
+   * Body text. Each line is quoted with `> ` so multi-line content stays
+   * inside the callout block.
+   */
+  children: string;
+};
+/**
+ * Renders a GitHub-style alert callout — portable across GitHub, GitLab,
+ * VitePress, Obsidian, and MDX.
+ *
+ * Emits a `<File.Source>` block containing `> [!TYPE] Title` followed by the
+ * body with every line prefixed by `> `.
+ *
+ * @example
+ * ```tsx
+ * <Callout type="tip">Run `kubb start --watch` to keep the generator hot.</Callout>
+ * // > [!TIP]
+ * // > Run `kubb start --watch` to keep the generator hot.
+ *
+ * <Callout type="warning" title="Heads up">Breaking change in v6.</Callout>
+ * // > [!WARNING] Heads up
+ * // > Breaking change in v6.
+ * ```
+ */
+declare function Callout({
+  type,
+  title,
+  children
+}: Props$8): KubbReactElement;
+declare namespace Callout {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/CodeBlock.d.ts
+type Props$7 = {
+  key?: Key;
+  /**
+   * Language tag for syntax highlighting. Rendered after the opening fence.
+   *
+   * @example
+   * `lang: 'typescript'`
+   */
+  lang?: string;
+  /**
+   * Code body. Wrapped in triple-backtick fences as-is.
+   */
+  children: string;
+};
+/**
+ * Renders a fenced markdown code block.
+ *
+ * Emits a `<File.Source>` block containing the children wrapped in
+ * triple-backtick fences with an optional language tag.
+ *
+ * @example
+ * ```tsx
+ * <CodeBlock lang="typescript">{'const pet = { id: 1 }'}</CodeBlock>
+ * // ```typescript
+ * // const pet = { id: 1 }
+ * // ```
+ * ```
+ */
+declare function CodeBlock({
+  lang,
+  children
+}: Props$7): KubbReactElement;
+declare namespace CodeBlock {
+  var displayName: string;
+}
+//#endregion
 //#region src/components/Const.d.ts
 type ConstProps = {
   key?: Key;
@@ -63,26 +152,26 @@ type ConstProps = {
    * - `false` generates `const name = …`
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * TypeScript type annotation for the constant, written verbatim after `const name:`.
    *
    * @example
    * `type: 'Pet'` → `const pet: Pet = …`
    */
-  type?: string;
+  type?: string | null;
   /**
    * JSDoc block to prepend to the constant declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
    * Append `as const` after the initialiser, enabling TypeScript const assertions.
    * - `true` generates `const name = … as const`
    * - `false` generates `const name = …`
    * @default false
    */
-  asConst?: boolean;
+  asConst?: boolean | null;
   /**
    * Child nodes rendered as the initialiser expression of the constant.
    */
@@ -140,24 +229,26 @@ type BasePropsWithoutBaseName = {
    * Fully qualified path to the generated file.
    * Optional when `baseName` is omitted — the component renders its children inline.
    */
-  path?: string;
+  path?: string | null;
 };
 type BaseProps = BasePropsWithBaseName | BasePropsWithoutBaseName;
-type Props$2<TMeta> = BaseProps & {
+type Props$6<TMeta> = BaseProps & {
   key?: Key;
   /**
    * Arbitrary metadata attached to the file node.
    * Used by plugins for barrel generation and custom post-processing.
    */
-  meta?: TMeta;
+  meta?: TMeta | null;
   /**
    * Text prepended to the generated file content before any source blocks.
+   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
    */
-  banner?: string;
+  banner?: string | null;
   /**
    * Text appended to the generated file content after all source blocks.
+   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
    */
-  footer?: string;
+  footer?: string | null;
   /**
    * Child nodes rendered as the content of this file (source blocks, imports, exports).
    */
@@ -182,7 +273,7 @@ type Props$2<TMeta> = BaseProps & {
 declare function File<TMeta extends object = object>({
   children,
   ...props
-}: Props$2<TMeta>): KubbReactElement;
+}: Props$6<TMeta>): KubbReactElement;
 declare namespace File {
   var displayName: string;
   var Export: typeof FileExport;
@@ -278,8 +369,44 @@ declare namespace FileImport {
   var displayName: string;
 }
 //#endregion
+//#region src/components/Frontmatter.d.ts
+type Props$5 = {
+  key?: Key;
+  /**
+   * Plain object serialised as YAML between `---` fences.
+   *
+   * @example
+   * `data: { title: 'Pets', layout: 'doc' }`
+   */
+  data: Record<string, unknown>;
+};
+/**
+ * Emits a YAML frontmatter envelope at the top of a generated markdown file.
+ *
+ * Renders a `<File.Source>` block containing `---\n<yaml>\n---`. Place it as
+ * the first child of `<File>` so it appears at the top of the output. Pair with
+ * `parserMd` to write `.md` files that downstream tooling (VitePress, MDX,
+ * static-site generators) treats as frontmatter.
+ *
+ * @example Page frontmatter at the top of a generated markdown file
+ * ```tsx
+ * <File baseName="pets.md" path="src/pets.md">
+ *   <Frontmatter data={{ title: 'Pets', layout: 'doc' }} />
+ *   <File.Source>
+ *     {'# Pets\n\nList of pets.'}
+ *   </File.Source>
+ * </File>
+ * ```
+ */
+declare function Frontmatter({
+  data
+}: Props$5): KubbReactElement;
+declare namespace Frontmatter {
+  var displayName: string;
+}
+//#endregion
 //#region src/components/Function.d.ts
-type Props$1 = {
+type Props$4 = {
   key?: Key;
   /**
    * Identifier of the generated function declaration.
@@ -293,28 +420,28 @@ type Props$1 = {
    * Requires `export` to also be `true`.
    * @default false
    */
-  default?: boolean;
+  default?: boolean | null;
   /**
    * Parameter list written verbatim between the function's parentheses.
    *
    * @example
    * `params: 'petId: string, options?: RequestOptions'`
    */
-  params?: string;
+  params?: string | null;
   /**
    * Emit the `export` keyword before the function declaration.
    * - `true` generates `export function name(…) { … }`
    * - `false` generates `function name(…) { … }`
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * Emit the `async` keyword, making this an async function.
    * The return type is automatically wrapped in `Promise<returnType>` when both
    * `async` and `returnType` are set.
    * @default false
    */
-  async?: boolean;
+  async?: boolean | null;
   /**
    * TypeScript generic type parameters written verbatim between `<` and `>`.
    * Pass an array to emit multiple parameters separated by commas.
@@ -325,7 +452,7 @@ type Props$1 = {
    * @example Multiple generics
    * `generics: ['TData', 'TError = unknown']`
    */
-  generics?: string | string[];
+  generics?: string | Array<string> | null;
   /**
    * TypeScript return type annotation written verbatim after `:`.
    * When `async` is `true`, the value is automatically wrapped in `Promise<…>`.
@@ -333,12 +460,12 @@ type Props$1 = {
    * @example
    * `returnType: 'Pet'`
    */
-  returnType?: string;
+  returnType?: string | null;
   /**
    * JSDoc block to prepend to the function declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
    * Child nodes rendered as the body of the function.
    */
@@ -360,19 +487,19 @@ type Props$1 = {
 declare function Function({
   children,
   ...props
-}: Props$1): KubbReactElement;
+}: Props$4): KubbReactElement;
 declare namespace Function {
   var displayName: string;
   var Arrow: typeof ArrowFunction;
 }
-type ArrowFunctionProps = Props$1 & {
+type ArrowFunctionProps = Props$4 & {
   /**
    * Render the arrow function as a single-line expression (no braces around the body).
    * - `true` generates `const name = (…) => expression`
    * - `false` generates `const name = (…) => { … }`
    * @default false
    */
-  singleLine?: boolean;
+  singleLine?: boolean | null;
 };
 /**
  * Generates an arrow function expression assigned to a `const`.
@@ -395,8 +522,42 @@ declare namespace ArrowFunction {
   var displayName: string;
 }
 //#endregion
+//#region src/components/Heading.d.ts
+type Level = 1 | 2 | 3 | 4 | 5 | 6;
+type Props$3 = {
+  key?: Key;
+  /**
+   * Heading depth, `1` through `6`. Matches the number of `#` characters
+   * prefixed to the heading text.
+   */
+  level: Level;
+  /**
+   * Heading text. Inline markdown (links, emphasis) is passed through verbatim.
+   */
+  children: string;
+};
+/**
+ * Renders an ATX-style markdown heading.
+ *
+ * Emits a `<File.Source>` block containing `${'#'.repeat(level)} ${children}`.
+ * Use inside a `<File>` rendered by `parserMd`.
+ *
+ * @example
+ * ```tsx
+ * <Heading level={2}>Installation</Heading>
+ * // ## Installation
+ * ```
+ */
+declare function Heading({
+  level,
+  children
+}: Props$3): KubbReactElement;
+declare namespace Heading {
+  var displayName: string;
+}
+//#endregion
 //#region src/components/Jsx.d.ts
-type Props = {
+type Props$2 = {
   /**
    * Raw JSX string to embed verbatim in the generated code.
    * Supports JSX fragments (`<>…</>`), elements, and any valid JSX syntax.
@@ -424,11 +585,79 @@ type Props = {
  */
 declare function Jsx({
   children
-}: Props): KubbReactElement;
+}: Props$2): KubbReactElement;
 declare namespace Jsx {
   var displayName: string;
 }
 //#endregion
+//#region src/components/List.d.ts
+type Props$1 = {
+  key?: Key;
+  /**
+   * When `true`, emits a numbered list (`1. …`). When `false` or omitted,
+   * emits a bullet list (`- …`).
+   *
+   * @default false
+   */
+  ordered?: boolean | null;
+  /**
+   * One entry per line. Inline markdown is passed through verbatim.
+   */
+  items: ReadonlyArray<string>;
+};
+/**
+ * Renders a markdown list.
+ *
+ * Emits a `<File.Source>` block containing one entry per line, prefixed with
+ * `1.` / `2.` … when `ordered`, or `-` otherwise.
+ *
+ * @example
+ * ```tsx
+ * <List items={['Add the parser', 'Render the page']} />
+ * // - Add the parser
+ * // - Render the page
+ *
+ * <List ordered items={['First', 'Second']} />
+ * // 1. First
+ * // 2. Second
+ * ```
+ */
+declare function List({
+  ordered,
+  items
+}: Props$1): KubbReactElement;
+declare namespace List {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/Paragraph.d.ts
+type Props = {
+  key?: Key;
+  /**
+   * Paragraph text. Inline markdown (links, emphasis, code spans) is passed
+   * through verbatim.
+   */
+  children: string;
+};
+/**
+ * Renders a markdown paragraph.
+ *
+ * Emits a `<File.Source>` block containing the text as-is. Paragraphs are
+ * separated from surrounding blocks by blank lines via the parser's source
+ * joining.
+ *
+ * @example
+ * ```tsx
+ * <Paragraph>{'A pet object with `id` and `name` fields.'}</Paragraph>
+ * ```
+ */
+declare function Paragraph({
+  children
+}: Props): KubbReactElement;
+declare namespace Paragraph {
+  var displayName: string;
+}
+//#endregion
 //#region src/components/Root.d.ts
 type RootProps = {
   /**
@@ -478,12 +707,12 @@ type TypeProps = {
    * - `false` generates `type Name = …`
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * JSDoc block to prepend to the type alias declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
    * Child nodes rendered as the type expression on the right-hand side of the alias.
    */
@@ -519,78 +748,87 @@ declare namespace Type {
 }
 //#endregion
 //#region src/createRenderer.d.ts
-type Options = {
-  /**
-   * Print each render result to the console for debugging.
-   * Useful when diagnosing output differences between renders.
-   * @default false
-   */
-  debug?: boolean;
-};
 /**
- * The renderer instance returned by {@link createRenderer}.
- */
-type Renderer = {
-  /**
-   * Render a JSX element tree and collect the resulting {@link FileNode} entries.
-   * Resolves once all synchronous render work (including React's flush) is done.
-   */
-  render(Element: KubbReactElement): Promise<void>;
-  /**
-   * Tear down the renderer and release all React resources.
-   * Pass an `Error` to signal an abnormal shutdown.
-   */
-  unmount(error?: Error | number | null): void;
-  /**
-   * The {@link FileNode} entries collected from the most recent `render` call.
-   */
-  files: Array<FileNode>;
-};
-/**
- * Create a Kubb JSX renderer.
+ * Renderer factory that turns the JSX produced by a generator into
+ * `FileNode`s using React's reconciler under the hood. Pass as the `renderer`
+ * property on `defineGenerator`. Kubb core stays generic, with no hard
+ * dependency on `@kubb/renderer-jsx`.
  *
- * 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.
+ * Use this when generators rely on React features (hooks, suspense, context).
+ * For pure-function components, see {@link jsxRendererSync} for ~2-4× faster
+ * rendering.
  *
- * @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()
+ * @example Wire up a JSX generator
+ * ```tsx
+ * import { defineGenerator } from '@kubb/core'
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ *
+ * export const myGenerator = defineGenerator<PluginTs>({
+ *   name: 'types',
+ *   renderer: jsxRenderer,
+ *   schema(node, ctx) {
+ *     return (
+ *       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+ *         <Type node={node} resolver={ctx.resolver} />
+ *       </File>
+ *     )
+ *   },
+ * })
  * ```
  */
-declare function createRenderer(options?: Options): Renderer;
+declare const jsxRenderer: () => {
+  render(element: KubbReactElement): Promise<void>;
+  readonly files: FileNode[];
+  dispose(): void;
+  unmount(error?: Error | number | null): void;
+  [Symbol.dispose](): void;
+};
 /**
- * A renderer factory for generators that produce JSX output.
+ * Lightweight renderer that walks the JSX tree in a single recursive pass —
+ * no React reconciler, no scheduler. Drop-in replacement for
+ * {@link jsxRenderer} at roughly 2–4× the throughput.
  *
- * 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`.
+ * Constraints: every component must be a pure function. Hooks, suspense, and
+ * class components are not supported.
  *
- * @example
- * ```ts
- * import { jsxRenderer } from '@kubb/renderer-jsx'
+ * Use this for generators that produce large amounts of output and do not need
+ * React's runtime features. It also exposes `stream()` for incremental file
+ * emission.
+ *
+ * @example Drop-in faster renderer
+ * ```tsx
  * import { defineGenerator } from '@kubb/core'
+ * import { jsxRendererSync } from '@kubb/renderer-jsx'
  *
  * export const myGenerator = defineGenerator<PluginTs>({
- *   name: 'my-generator',
- *   renderer: jsxRenderer,
- *   schema(node, options) {
- *     return <File baseName="output.ts" path="src/output.ts">...</File>
+ *   name: 'types',
+ *   renderer: jsxRendererSync,
+ *   schema(node, ctx) {
+ *     return (
+ *       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+ *         <Type node={node} resolver={ctx.resolver} />
+ *       </File>
+ *     )
  *   },
  * })
  * ```
+ *
+ * @example Stream files as they are produced
+ * ```tsx
+ * const renderer = jsxRendererSync()
+ * for (const file of renderer.stream(element)) {
+ *   await writeFile(file.path, file.sources[0])
+ * }
+ * ```
  */
-declare const jsxRenderer: () => Renderer;
+declare const jsxRendererSync: () => {
+  render(element: KubbReactElement): Promise<void>;
+  readonly files: FileNode[];
+  stream(element: KubbReactElement): Generator<FileNode>;
+  dispose(): void;
+  unmount(_error?: Error | number | null): void;
+  [Symbol.dispose](): void;
+};
 //#endregion
-export { Const, File, Function, Jsx, Root, Type, createContext, createRenderer, inject, jsxRenderer, provide, unprovide };
+export { Callout, CodeBlock, Const, File, Frontmatter, Function, Heading, Jsx, List, Paragraph, Root, Type, createContext, inject, jsxRenderer, jsxRendererSync, provide, unprovide };
 //# sourceMappingURL=index.d.ts.map