@kubb/renderer-jsx 5.0.0-beta.6 → 5.0.0-beta.60

package/src/constants.ts

@@ -1,28 +1,9 @@
-import type { ElementNames } from './types.ts'
-
-/**
- * Name used for text-node entries in the virtual DOM.
- */
-export const TEXT_NODE_NAME = '#text' as const
-
-/**
- * Set of all element names recognized by the Kubb renderer.
- * Used to distinguish Kubb-owned elements from unrecognized or text nodes during tree traversal.
- */
-export const nodeNames = new Set<ElementNames>([
-  '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',
-] as const)
+export const KUBB_FILE = 'kubb-file' as const
+export const KUBB_SOURCE = 'kubb-source' as const
+export const KUBB_EXPORT = 'kubb-export' as const
+export const KUBB_IMPORT = 'kubb-import' as const
+export const KUBB_FUNCTION = 'kubb-function' as const
+export const KUBB_ARROW_FUNCTION = 'kubb-arrow-function' as const
+export const KUBB_CONST = 'kubb-const' as const
+export const KUBB_TYPE = 'kubb-type' as const
+export const KUBB_JSX = 'kubb-jsx' as const

package/src/createRenderer.tsx

@@ -1,93 +1,56 @@
 import type { FileNode } from '@kubb/ast'
-import { Runtime } from './Runtime.tsx'
+import { SyncRuntime } from './SyncRuntime.tsx'
 import type { KubbReactElement } from './types.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 that walks the JSX tree in a single recursive pass, with no React
+ * reconciler or scheduler. Pass as the `renderer` property on
+ * `defineGenerator`. Kubb core stays generic, with no hard dependency on
+ * `@kubb/renderer-jsx`.
+ *
+ * Every component must be a pure function. Hooks, suspense, and class
+ * components are not supported. It also exposes `stream()` for incremental
+ * file emission.
  *
- * 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 Wire up a JSX generator
+ * ```tsx
+ * import { defineGenerator } from '@kubb/core'
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
  *
- * @example Basic usage
- * ```ts
- * import { createRenderer, File } 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>
+ *     )
+ *   },
+ * })
+ * ```
  *
- * 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 Stream files as they are produced
+ * ```tsx
+ * const renderer = jsxRenderer()
+ * for (const file of renderer.stream(element)) {
+ *   await writeFile(file.path, file.sources[0])
+ * }
  * ```
  */
-export function createRenderer(options: Options = {}): Renderer {
-  const runtime = new Runtime(options)
+export const jsxRenderer = () => {
+  const runtime = new SyncRuntime()
 
   return {
-    async render(Element) {
-      await runtime.render(Element)
+    async render(element: KubbReactElement): Promise<void> {
+      runtime.render(element)
     },
     get files() {
       return runtime.nodes
     },
-    unmount(error) {
-      runtime.unmount(error)
+    stream(element: KubbReactElement): Generator<FileNode> {
+      return runtime.stream(element)
     },
+    [Symbol.dispose]() {},
   }
 }
-
-/**
- * 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>
- *   },
- * })
- * ```
- */
-export const jsxRenderer: () => Renderer = () => createRenderer()

package/src/globals.ts

@@ -1,13 +1,16 @@
-import type React from 'react'
 import type {
+  KubbArrowFunctionProps,
+  KubbConstProps,
   KubbExportProps,
   KubbFileProps,
+  KubbFunctionProps,
   KubbImportProps,
   KubbJsxProps,
   KubbReactElement,
   KubbReactNode,
   KubbSourceProps,
-  KubbTextProps,
+  KubbTypeProps,
+  Key,
   LineBreakProps,
 } from './types.ts'
 
@@ -15,20 +18,25 @@ declare global {
   namespace JSX {
     type Element = KubbReactElement
 
-    interface ElementClass extends React.ComponentClass<any> {
+    interface ElementClass {
       render(): KubbReactNode
     }
 
+    interface IntrinsicAttributes {
+      key?: Key | null
+    }
+
     interface IntrinsicElements {
       'kubb-jsx': KubbJsxProps
-      'kubb-text': KubbTextProps
       'kubb-file': KubbFileProps
       'kubb-source': KubbSourceProps
       'kubb-import': KubbImportProps
       'kubb-export': KubbExportProps
+      'kubb-function': KubbFunctionProps
+      'kubb-arrow-function': KubbArrowFunctionProps
+      'kubb-const': KubbConstProps
+      'kubb-type': KubbTypeProps
       br: LineBreakProps
-      indent: {}
-      dedent: {}
     }
   }
 }

package/src/index.ts

@@ -1,8 +1,11 @@
-export { createContext, inject, provide, unprovide } from '@internals/utils'
+export { Callout } from './components/Callout.tsx'
 export { Const } from './components/Const.tsx'
 export { File } from './components/File.tsx'
+export { Frontmatter } from './components/Frontmatter.tsx'
 export { Function } from './components/Function.tsx'
+export { Heading } from './components/Heading.tsx'
 export { Jsx } from './components/Jsx.tsx'
-export { Root } from './components/Root.tsx'
+export { List } from './components/List.tsx'
+export { Paragraph } from './components/Paragraph.tsx'
 export { Type } from './components/Type.tsx'
-export { createRenderer, jsxRenderer } from './createRenderer.tsx'
+export { jsxRenderer } from './createRenderer.tsx'

package/src/jsx-dev-runtime.ts

@@ -1,8 +1,6 @@
-import * as React from 'react/jsx-runtime'
 import type { KubbReactElement, KubbReactNode } from './types.ts'
 
-export const Fragment = React.Fragment
-export const jsxDEV = React.jsx
+export { Fragment, jsxDEV } from './jsx-runtime.ts'
 
 export type * from './jsx-namespace.d.ts'
 

package/src/jsx-namespace.d.ts

@@ -1,5 +1,3 @@
-import type React from 'react'
-
 import type {
   KubbArrowFunctionProps,
   KubbConstProps,
@@ -11,29 +9,42 @@ import type {
   KubbReactElement,
   KubbReactNode,
   KubbSourceProps,
-  KubbTextProps,
   KubbTypeProps,
+  Key,
   LineBreakProps,
 } from './types'
 
+/**
+ * JSX contract for `@kubb/renderer-jsx`, resolved through `jsxImportSource`.
+ *
+ * It is self-contained and does not extend `React.JSX`. The renderer only emits
+ * the custom `kubb-*` hosts plus `br`, `indent`, and `dedent`, and supports
+ * pure function components, so the HTML element and class-component machinery
+ * from `@types/react` is not needed.
+ */
 export namespace JSX {
-  type ElementType = React.JSX.ElementType
+  type ElementType = string | ((props: any) => KubbReactNode)
   type Element = KubbReactElement
 
-  interface ElementClass extends React.JSX.ElementClass {
+  interface ElementClass {
     render(): KubbReactNode
   }
   interface ElementAttributesProperty {
     props: {}
   }
-
   interface ElementChildrenAttribute {
     children: {}
   }
 
-  interface IntrinsicElements extends React.JSX.IntrinsicElements {
+  interface IntrinsicAttributes {
+    key?: Key | null
+  }
+  interface IntrinsicClassAttributes<T> {
+    key?: Key | null
+  }
+
+  interface IntrinsicElements {
     'kubb-jsx': KubbJsxProps
-    'kubb-text': KubbTextProps
     'kubb-file': KubbFileProps
     'kubb-source': KubbSourceProps
     'kubb-import': KubbImportProps
@@ -43,10 +54,7 @@ export namespace JSX {
     'kubb-const': KubbConstProps
     'kubb-type': KubbTypeProps
     br: LineBreakProps
-    indent: {}
-    dedent: {}
   }
-  type LibraryManagedAttributes<C, P> = React.JSX.LibraryManagedAttributes<C, P>
-  interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}
-  interface IntrinsicElements extends React.JSX.IntrinsicElements {}
+
+  type LibraryManagedAttributes<C, P> = P
 }

package/src/jsx-runtime.ts

@@ -1,10 +1,26 @@
-import * as React from 'react/jsx-runtime'
-import type { KubbReactElement, KubbReactNode } from './types.ts'
+import type { Key, KubbReactElement, KubbReactNode } from './types.ts'
 
-export const Fragment = React.Fragment
-export const jsx = React.jsx
-export const jsxDEV = React.jsx
-export const jsxs = React.jsxs
+const KUBB_ELEMENT = Symbol.for('kubb.element')
+
+/**
+ * Fragment marker. A `<>…</>` compiles to `jsx(Fragment, …)`, and the renderer
+ * unwraps it while walking the tree.
+ */
+export const Fragment = Symbol.for('kubb.fragment')
+
+/**
+ * Create a Kubb JSX element. The automatic JSX runtime calls this for every tag,
+ * so the renderer never depends on React at runtime. The `type` is a host
+ * string, a function component, or `Fragment`, and children are folded into
+ * `props`.
+ */
+function createElement(type: unknown, props: Record<string, unknown> | null, key?: Key | null): KubbReactElement {
+  return { $$typeof: KUBB_ELEMENT, type, key: key ?? null, props: props ?? {} } as unknown as KubbReactElement
+}
+
+export const jsx = createElement
+export const jsxs = createElement
+export const jsxDEV = createElement
 
 export type * from './jsx-namespace.d.ts'
 

package/src/types.ts

@@ -1,102 +1,25 @@
 import type { ArrowFunctionNode, ConstNode, ExportNode, FileNode, FunctionNode, ImportNode, SourceNode, TypeNode } from '@kubb/ast'
-import type React from 'react'
-import type { JSX, ReactNode } from 'react'
 
 /**
- * Unique identifier for a React element in lists or conditional renders.
+ * Unique key for a Kubb JSX element in lists or conditional renders.
  */
 export type Key = string | number | bigint
 
 /**
- * Custom element names recognized by the Kubb JSX renderer.
- * Each name maps to a corresponding AST node type in the generated code.
+ * Element produced by a Kubb JSX component. The renderer walks these at runtime,
+ * so the fields stay opaque to type-checking.
  */
-export type ElementNames =
-  | 'br'
-  | 'div'
-  | 'indent'
-  | 'dedent'
-  | 'kubb-jsx'
-  | 'kubb-text'
-  | 'kubb-file'
-  | 'kubb-source'
-  | 'kubb-import'
-  | 'kubb-export'
-  | 'kubb-function'
-  | 'kubb-arrow-function'
-  | 'kubb-const'
-  | 'kubb-type'
-  | 'kubb-root'
-  | 'kubb-app'
-
-type Node = {
-  parentNode: DOMElement | undefined
-  internal_static?: boolean
+export type KubbReactElement = {
+  type: unknown
+  props: unknown
+  key: Key | null
 }
 
 /**
- * Allowed attribute value types for DOM elements.
- */
-export type DOMNodeAttribute = boolean | string | number | Record<string, unknown> | Array<unknown>
-
-type TextName = '#text'
-
-/**
- * Leaf DOM node containing raw text.
- */
-export type TextNode = {
-  nodeName: TextName
-  nodeValue: string
-} & Node
-
-/**
- * Virtual DOM node — either a text node or a named element.
- */
-export type DOMNode<T = { nodeName: NodeNames }> = T extends {
-  nodeName: infer U
-}
-  ? U extends '#text'
-    ? TextNode
-    : DOMElement
-  : never
-
-type OutputTransformer = (s: string, index: number) => string
-
-/**
- * Named element in the Kubb virtual DOM tree.
- * Stores attributes, child nodes, and lifecycle callbacks for rendering.
- */
-export type DOMElement = {
-  nodeName: ElementNames
-  /**
-   * Key/value attributes passed as JSX props to this element.
-   */
-  attributes: Map<string, DOMNodeAttribute>
-  /**
-   * Ordered list of child nodes attached to this element.
-   */
-  childNodes: DOMNode[]
-  internal_transform?: OutputTransformer
-
-  // Internal properties
-  isStaticDirty?: boolean
-  staticNode?: DOMElement
-  onComputeLayout?: () => void
-  onRender?: () => void
-  onImmediateRender?: () => void
-} & Node
-
-type NodeNames = ElementNames | TextName
-
-/**
- * React node type for Kubb JSX components.
+ * Anything a Kubb JSX component accepts as children: an element, a primitive
+ * rendered as text, a nullish value that is skipped, or an iterable of nodes.
  */
-export type KubbReactNode = ReactNode
-
-/**
- * React element type returned by Kubb JSX components.
- */
-export type KubbReactElement = JSX.Element
+export type KubbReactNode = KubbReactElement | string | number | bigint | boolean | null | undefined | Iterable<KubbReactNode>
 
 /**
  * Props for the `<kubb-jsx>` element.
@@ -106,25 +29,17 @@ export type KubbJsxProps = {
   children?: string
 }
 
-/**
- * Props for the `<kubb-text>` element.
- * Wraps React children as plain text in the output.
- */
-export type KubbTextProps = {
-  children?: KubbReactNode
-}
-
 /**
  * Props for the `<kubb-file>` element.
  * Represents a generated file.
  */
 export type KubbFileProps = {
-  id?: string
+  id?: string | null
   children?: KubbReactNode
   baseName: string
   path: string
-  override?: boolean
-  meta?: FileNode['meta']
+  override?: boolean | null
+  meta?: FileNode['meta'] | null
 }
 
 /**
@@ -180,9 +95,10 @@ export type KubbTypeProps = Omit<TypeNode, 'kind'> & {
 }
 
 /**
- * Props for the HTML `<br>` element.
+ * Props for the `<br>` element. It emits a single line break and takes no
+ * attributes of its own.
  */
-export type LineBreakProps = React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement>
+export type LineBreakProps = {}
 
 /**
  * JSDoc comment block to attach to a generated declaration.

package/dist/chunk-Bb7HlUDG.js

@@ -1,28 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-export { __name as n, __toESM as r, __commonJSMin as t };

package/dist/jsx-namespace-CNp0arTN.d.ts

@@ -1,39 +0,0 @@
-import { n as __name } from "./chunk-Bb7HlUDG.js";
-import { _ as KubbTextProps, c as KubbConstProps, d as KubbFunctionProps, f as KubbImportProps, g as KubbSourceProps, h as KubbReactNode, l as KubbExportProps, m as KubbReactElement, p as KubbJsxProps, s as KubbArrowFunctionProps, u as KubbFileProps, v as KubbTypeProps, y as LineBreakProps } from "./types-nAFMiWFw.js";
-import React from "react";
-
-//#region src/jsx-namespace.d.ts
-declare namespace JSX$1 {
-  type ElementType = React.JSX.ElementType;
-  type Element = KubbReactElement;
-  interface ElementClass extends React.JSX.ElementClass {
-    render(): KubbReactNode;
-  }
-  interface ElementAttributesProperty {
-    props: {};
-  }
-  interface ElementChildrenAttribute {
-    children: {};
-  }
-  interface IntrinsicElements extends React.JSX.IntrinsicElements {
-    'kubb-jsx': KubbJsxProps;
-    'kubb-text': KubbTextProps;
-    'kubb-file': KubbFileProps;
-    'kubb-source': KubbSourceProps;
-    'kubb-import': KubbImportProps;
-    'kubb-export': KubbExportProps;
-    'kubb-function': KubbFunctionProps;
-    'kubb-arrow-function': KubbArrowFunctionProps;
-    'kubb-const': KubbConstProps;
-    'kubb-type': KubbTypeProps;
-    br: LineBreakProps;
-    indent: {};
-    dedent: {};
-  }
-  type LibraryManagedAttributes<C, P> = React.JSX.LibraryManagedAttributes<C, P>;
-  interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}
-  interface IntrinsicElements extends React.JSX.IntrinsicElements {}
-}
-//#endregion
-export { JSX$1 as t };
-//# sourceMappingURL=jsx-namespace-CNp0arTN.d.ts.map