@kubb/renderer-jsx 5.0.0-beta.16 → 5.0.0-beta.18

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

@@ -1,6 +1,6 @@
 import { n as __name } from "./chunk-Bb7HlUDG.js";
-import { h as KubbReactNode, m as KubbReactElement } from "./types-nAFMiWFw.js";
-import { t as JSX } from "./jsx-namespace-CNp0arTN.js";
+import { h as KubbReactNode, m as KubbReactElement } from "./types-Dk7A1Y5U.js";
+import { t as JSX } from "./jsx-namespace-BLGeMDcR.js";
 import * as _$react from "react";
 import * as React$1 from "react/jsx-runtime";
 

package/dist/{jsx-namespace-CNp0arTN.d.ts → jsx-namespace-BLGeMDcR.d.ts}

@@ -1,5 +1,5 @@
 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 { _ 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-Dk7A1Y5U.js";
 import React from "react";
 
 //#region src/jsx-namespace.d.ts
@@ -36,4 +36,4 @@ declare namespace JSX$1 {
 }
 //#endregion
 export { JSX$1 as t };
-//# sourceMappingURL=jsx-namespace-CNp0arTN.d.ts.map
+//# sourceMappingURL=jsx-namespace-BLGeMDcR.d.ts.map

package/dist/jsx-runtime.d.ts

@@ -1,6 +1,6 @@
 import { n as __name } from "./chunk-Bb7HlUDG.js";
-import { h as KubbReactNode, m as KubbReactElement } from "./types-nAFMiWFw.js";
-import { t as JSX } from "./jsx-namespace-CNp0arTN.js";
+import { h as KubbReactNode, m as KubbReactElement } from "./types-Dk7A1Y5U.js";
+import { t as JSX } from "./jsx-namespace-BLGeMDcR.js";
 import * as _$react from "react";
 import * as React$1 from "react/jsx-runtime";
 

package/dist/{types-nAFMiWFw.d.ts → types-Dk7A1Y5U.d.ts}

@@ -46,7 +46,7 @@ type DOMElement = {
   /**
    * Key/value attributes passed as JSX props to this element.
    */
-  attributes: Map<string, DOMNodeAttribute>;
+  attributes: Record<string, DOMNodeAttribute>;
   /**
    * Ordered list of child nodes attached to this element.
    */
@@ -165,4 +165,4 @@ type JSDoc = {
 };
 //#endregion
 export { KubbTextProps as _, JSDoc as a, TextNode as b, KubbConstProps as c, KubbFunctionProps as d, KubbImportProps as f, KubbSourceProps as g, KubbReactNode as h, ElementNames as i, KubbExportProps as l, KubbReactElement as m, DOMNode as n, Key as o, KubbJsxProps as p, DOMNodeAttribute as r, KubbArrowFunctionProps as s, DOMElement as t, KubbFileProps as u, KubbTypeProps as v, LineBreakProps as y };
-//# sourceMappingURL=types-nAFMiWFw.d.ts.map
+//# sourceMappingURL=types-Dk7A1Y5U.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { _ as KubbTextProps, a as JSDoc, b as TextNode, c as KubbConstProps, d as KubbFunctionProps, f as KubbImportProps, g as KubbSourceProps, h as KubbReactNode, i as ElementNames, l as KubbExportProps, m as KubbReactElement, n as DOMNode, o as Key, p as KubbJsxProps, r as DOMNodeAttribute, s as KubbArrowFunctionProps, t as DOMElement, u as KubbFileProps, v as KubbTypeProps, y as LineBreakProps } from "./types-nAFMiWFw.js";
+import { _ as KubbTextProps, a as JSDoc, b as TextNode, c as KubbConstProps, d as KubbFunctionProps, f as KubbImportProps, g as KubbSourceProps, h as KubbReactNode, i as ElementNames, l as KubbExportProps, m as KubbReactElement, n as DOMNode, o as Key, p as KubbJsxProps, r as DOMNodeAttribute, s as KubbArrowFunctionProps, t as DOMElement, u as KubbFileProps, v as KubbTypeProps, y as LineBreakProps } from "./types-Dk7A1Y5U.js";
 export { DOMElement, DOMNode, DOMNodeAttribute, ElementNames, JSDoc, Key, KubbArrowFunctionProps, KubbConstProps, KubbExportProps, KubbFileProps, KubbFunctionProps, KubbImportProps, KubbJsxProps, KubbReactElement, KubbReactNode, KubbSourceProps, KubbTextProps, KubbTypeProps, LineBreakProps, TextNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/renderer-jsx",
-  "version": "5.0.0-beta.16",
+  "version": "5.0.0-beta.18",
   "description": "JSX-based renderer for Kubb. Provides a custom React runtime, reconciler, and built-in components (File, Function, Type, Const) for component-based, type-safe code generation.",
   "keywords": [
     "codegen",
@@ -75,7 +75,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.16"
+    "@kubb/ast": "5.0.0-beta.18"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",

package/src/Renderer.ts

@@ -105,7 +105,7 @@ export const Renderer = Reconciler({
     return false
   },
   supportsMutation: true,
-  isPrimaryRenderer: true,
+  isPrimaryRenderer: false,
   supportsPersistence: false,
   supportsHydration: false,
   scheduleTimeout: setTimeout,

package/src/Runtime.tsx

@@ -1,12 +1,12 @@
 import { onProcessExit } from '@internals/utils'
 import type { FileNode } from '@kubb/ast'
-import { ConcurrentRoot } from 'react-reconciler/constants.js'
+import { LegacyRoot } from 'react-reconciler/constants.js'
 import { Root } from './components/Root.tsx'
 import { createNode } from './dom.ts'
 import type { FiberRoot } from 'react-reconciler'
 import { Renderer } from './Renderer.ts'
 import type { DOMElement, KubbReactElement } from './types.ts'
-import { processFiles } from './utils.ts'
+import { collectFiles } from './utils.ts'
 
 type Options = {
   /**
@@ -51,7 +51,7 @@ export class Runtime {
 
     const logRecoverableError = typeof reportError === 'function' ? reportError : console.error
 
-    const rootTag = ConcurrentRoot
+    const rootTag = LegacyRoot
     this.#container = Renderer.createContainer(
       this.#rootNode,
       rootTag,
@@ -86,7 +86,7 @@ export class Runtime {
           return
         }
 
-        const files = processFiles(this.#rootNode)
+        const files = collectFiles(this.#rootNode)
 
         this.nodes.push(...files)
 

package/src/SyncRuntime.tsx

@@ -0,0 +1,285 @@
+import type { ArrowFunctionNode, CodeNode, ExportNode, FileNode, ImportNode, JSDocNode, SourceNode } from '@kubb/ast'
+import {
+  createArrowFunction,
+  createBreak,
+  createConst,
+  createExport,
+  createFunction,
+  createImport,
+  createJsx,
+  createSource,
+  createText,
+  createType,
+} from '@kubb/ast'
+import React from 'react'
+import { KUBB_ARROW_FUNCTION, KUBB_CONST, KUBB_EXPORT, KUBB_FILE, KUBB_FUNCTION, KUBB_IMPORT, KUBB_JSX, KUBB_SOURCE, KUBB_TYPE } from './constants.ts'
+import type { KubbReactElement } from './types.ts'
+
+type OnText = (text: string) => void
+type OnHost = (type: string, props: Record<string, unknown>) => void
+
+/**
+ * Walks `element`, resolving arrays, Fragments, and function components
+ * transparently, then calls `onText` for primitive values and `onHost` for
+ * every host element encountered. Pure function components are called
+ * synchronously; hooks and class components are not supported.
+ */
+function walkElement(element: unknown, onText: OnText, onHost: OnHost): void {
+  if (element == null || typeof element === 'boolean') return
+
+  if (typeof element === 'string' || typeof element === 'number' || typeof element === 'bigint') {
+    onText(String(element))
+    return
+  }
+
+  if (Array.isArray(element)) {
+    for (const child of element) walkElement(child, onText, onHost)
+    return
+  }
+
+  if (typeof element === 'object' && '$$typeof' in element) {
+    const el = element as unknown as React.ReactElement
+    const { type } = el
+    const props = el.props as Record<string, unknown>
+
+    if (type === React.Fragment) {
+      walkElement(props['children'], onText, onHost)
+    } else if (typeof type === 'function') {
+      walkElement((type as (p: unknown) => unknown)(props), onText, onHost)
+    } else if (typeof type === 'string') {
+      onHost(type, props)
+    }
+  }
+}
+
+function toBool(val: unknown): boolean {
+  return (val ?? false) as boolean
+}
+
+function collectCodeNodes(props: Record<string, unknown>): CodeNode[] {
+  const nodes: CodeNode[] = []
+  collectCode(props['children'], nodes)
+  return nodes
+}
+
+function collectCode(element: unknown, nodes: CodeNode[]): void {
+  walkElement(
+    element,
+    (text) => {
+      if (text.trim()) nodes.push(createText(text))
+    },
+    (type, props) => resolveCodeNode(type, props, nodes),
+  )
+}
+
+function resolveCodeNode(type: string, props: Record<string, unknown>, nodes: CodeNode[]): void {
+  if (type === 'br') {
+    nodes.push(createBreak())
+    return
+  }
+
+  if (type === KUBB_JSX) {
+    let value = ''
+    walkElement(
+      props['children'],
+      (t) => {
+        value += t
+      },
+      () => {},
+    )
+    if (value) nodes.push(createJsx(value))
+    return
+  }
+
+  if (type === KUBB_FUNCTION) {
+    nodes.push(
+      createFunction({
+        name: props['name'] as string,
+        params: props['params'] as string | undefined,
+        export: props['export'] as boolean | undefined,
+        default: props['default'] as boolean | undefined,
+        async: props['async'] as boolean | undefined,
+        generics: props['generics'] as string | undefined,
+        returnType: props['returnType'] as string | undefined,
+        JSDoc: props['JSDoc'] as JSDocNode | undefined,
+        nodes: collectCodeNodes(props),
+      }),
+    )
+    return
+  }
+
+  if (type === KUBB_ARROW_FUNCTION) {
+    nodes.push(
+      createArrowFunction({
+        name: props['name'] as string,
+        params: props['params'] as string | undefined,
+        export: props['export'] as boolean | undefined,
+        default: props['default'] as boolean | undefined,
+        async: props['async'] as boolean | undefined,
+        generics: props['generics'] as string | undefined,
+        returnType: props['returnType'] as string | undefined,
+        singleLine: props['singleLine'] as boolean | undefined,
+        JSDoc: props['JSDoc'] as JSDocNode | undefined,
+        nodes: collectCodeNodes(props),
+      } as Omit<ArrowFunctionNode, 'kind'>),
+    )
+    return
+  }
+
+  if (type === KUBB_CONST) {
+    nodes.push(
+      createConst({
+        name: props['name'] as string,
+        type: props['type'] as string | undefined,
+        export: props['export'] as boolean | undefined,
+        asConst: props['asConst'] as boolean | undefined,
+        JSDoc: props['JSDoc'] as JSDocNode | undefined,
+        nodes: collectCodeNodes(props),
+      }),
+    )
+    return
+  }
+
+  if (type === KUBB_TYPE) {
+    nodes.push(
+      createType({
+        name: props['name'] as string,
+        export: props['export'] as boolean | undefined,
+        JSDoc: props['JSDoc'] as JSDocNode | undefined,
+        nodes: collectCodeNodes(props),
+      }),
+    )
+    return
+  }
+}
+
+type FileChildren = { sources: SourceNode[]; exports: ExportNode[]; imports: ImportNode[] }
+
+function collectFileChildren(element: unknown): FileChildren {
+  const sources: SourceNode[] = []
+  const exports: ExportNode[] = []
+  const imports: ImportNode[] = []
+
+  walkElement(
+    element,
+    (text) => {
+      if (text.trim()) {
+        throw new Error(`[react] '${text}' should be part of <File.Source> component when using the <File/> component`)
+      }
+    },
+    (type, props) => {
+      if (type === KUBB_SOURCE) {
+        sources.push(
+          createSource({
+            name: props['name']?.toString(),
+            isTypeOnly: toBool(props['isTypeOnly']),
+            isExportable: toBool(props['isExportable']),
+            isIndexable: toBool(props['isIndexable']),
+            nodes: collectCodeNodes(props),
+          }),
+        )
+        return
+      }
+
+      if (type === KUBB_EXPORT) {
+        exports.push(
+          createExport({
+            name: props['name'] as ExportNode['name'],
+            path: props['path'] as string,
+            isTypeOnly: toBool(props['isTypeOnly']),
+            asAlias: toBool(props['asAlias']),
+          }),
+        )
+        return
+      }
+
+      if (type === KUBB_IMPORT) {
+        imports.push(
+          createImport({
+            name: props['name'] as ImportNode['name'],
+            path: props['path'] as string,
+            root: props['root'] as string | undefined,
+            isTypeOnly: toBool(props['isTypeOnly']),
+            isNameSpace: toBool(props['isNameSpace']),
+          }),
+        )
+        return
+      }
+
+      const nested = collectFileChildren(props['children'])
+      sources.push(...nested.sources)
+      exports.push(...nested.exports)
+      imports.push(...nested.imports)
+    },
+  )
+
+  return { sources, exports, imports }
+}
+
+function* walkFiles(element: unknown): Generator<FileNode> {
+  const files: FileNode[] = []
+
+  function onHost(type: string, props: Record<string, unknown>): void {
+    if (type === KUBB_FILE && props['baseName'] !== undefined && props['path'] !== undefined) {
+      const { sources, exports, imports } = collectFileChildren(props['children'])
+      files.push({
+        baseName: props['baseName'],
+        path: props['path'],
+        meta: props['meta'] || {},
+        footer: props['footer'],
+        banner: props['banner'],
+        sources,
+        exports,
+        imports,
+      } as FileNode)
+    } else {
+      walkElement(props['children'], () => {}, onHost)
+    }
+  }
+
+  walkElement(element, () => {}, onHost)
+  yield* files
+}
+
+/**
+ * Synchronous JSX renderer that walks the element tree in a single pass,
+ * producing {@link 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
+ * supported. Produces identical output to the React-backed {@link Runtime} at
+ * approximately 2–4× the speed and a fraction of the allocations.
+ */
+export class SyncRuntime {
+  /**
+   * Accumulated {@link FileNode} results from every {@link render} call.
+   */
+  nodes: FileNode[] = []
+
+  /**
+   * Walks `element` synchronously, converts every `<kubb-file>` subtree into
+   * a {@link FileNode} with no intermediate virtual DOM, and appends the results
+   * to {@link nodes}.
+   */
+  render(element: KubbReactElement): void {
+    for (const file of walkFiles(element)) {
+      this.nodes.push(file)
+    }
+  }
+
+  /**
+   * Walks `element` synchronously and yields each {@link FileNode} as it is
+   * produced, without buffering into an intermediate array first. Callers can
+   * begin processing each file before the rest of the element tree is traversed.
+   *
+   * @example
+   * ```ts
+   * for (const file of runtime.stream(element)) {
+   *   await writeFile(file)
+   * }
+   * ```
+   */
+  *stream(element: KubbReactElement): Generator<FileNode> {
+    yield* walkFiles(element)
+  }
+}

package/src/constants.ts

@@ -5,20 +5,30 @@ import type { ElementNames } from './types.ts'
  */
 export const TEXT_NODE_NAME = '#text' 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
+
 /**
  * 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_EXPORT,
+  KUBB_FILE,
+  KUBB_SOURCE,
+  KUBB_IMPORT,
+  KUBB_FUNCTION,
+  KUBB_ARROW_FUNCTION,
+  KUBB_CONST,
+  KUBB_TYPE,
+  KUBB_JSX,
   'kubb-text',
   'kubb-root',
   'kubb-app',

package/src/createRenderer.tsx

@@ -1,20 +1,19 @@
+import type { FileNode } from '@kubb/ast'
 import { Runtime } from './Runtime.tsx'
+import { SyncRuntime } from './SyncRuntime.tsx'
 import type { KubbReactElement } from './types.ts'
 
 /**
- * A renderer factory for generators that produce JSX output.
+ * 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
+ * Pass as the `renderer` property of `defineGenerator`. Core drives rendering
  * 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>
@@ -36,3 +35,45 @@ export const jsxRenderer = () => {
     },
   }
 }
+
+/**
+ * Lightweight renderer factory with no React fiber, scheduler, or work loop.
+ *
+ * Walks the JSX element tree in a single recursive pass. All components must be
+ * pure functions; hooks and class components are not supported. Drop-in
+ * replacement for {@link jsxRenderer} at approximately 2–4× the speed.
+ *
+ * @example Drop-in replacement
+ * ```ts
+ * import { jsxRendererSync } from '@kubb/renderer-jsx'
+ *
+ * export const myGenerator = defineGenerator<PluginTs>({
+ *   renderer: jsxRendererSync,
+ *   schema(node, options) {
+ *     return <File baseName="output.ts" path="src/output.ts">...</File>
+ *   },
+ * })
+ * ```
+ *
+ * @example Stream files as they are produced
+ * ```ts
+ * for await (const file of jsxRendererSync().stream(element)) {
+ *   await writeFile(file)
+ * }
+ * ```
+ */
+export const jsxRendererSync = () => {
+  const runtime = new SyncRuntime()
+  return {
+    async render(element: KubbReactElement): Promise<void> {
+      runtime.render(element)
+    },
+    get files() {
+      return runtime.nodes
+    },
+    async *stream(element: KubbReactElement): AsyncGenerator<FileNode> {
+      yield* runtime.stream(element)
+    },
+    unmount(_error?: Error | number | null) {},
+  }
+}

package/src/dom.ts

@@ -8,7 +8,7 @@ import type { DOMElement, DOMNode, DOMNodeAttribute, TextNode } from './types.ts
 export const createNode = (nodeName: string): DOMElement => {
   return {
     nodeName: nodeName as DOMElement['nodeName'],
-    attributes: new Map(),
+    attributes: Object.create(null) as Record<string, DOMNodeAttribute>,
     childNodes: [],
     parentNode: undefined,
   }
@@ -48,7 +48,6 @@ export const insertBeforeNode = (node: DOMElement, newChildNode: DOMNode, before
   const index = node.childNodes.indexOf(beforeChildNode)
   if (index >= 0) {
     node.childNodes.splice(index, 0, newChildNode)
-
     return
   }
 
@@ -72,32 +71,23 @@ export const removeChildNode = (node: DOMElement, removeNode: DOMNode): void =>
  * Set an attribute on `node`, storing it in the node's `attributes` map.
  */
 export const setAttribute = (node: DOMElement, key: string, value: DOMNodeAttribute): void => {
-  node.attributes.set(key, value)
+  node.attributes[key] = value
 }
 
 /**
  * Create a new {@link TextNode} with the given text value.
  */
 export const createTextNode = (text: string): TextNode => {
-  const node: TextNode = {
+  return {
     nodeName: TEXT_NODE_NAME,
     nodeValue: text,
     parentNode: undefined,
   }
-
-  setTextNodeValue(node, text)
-
-  return node
 }
 
 /**
  * Update the `nodeValue` of an existing {@link TextNode}.
- * Non-string values are coerced to strings via `String(text)`.
  */
 export const setTextNodeValue = (node: TextNode, text: string): void => {
-  if (typeof text !== 'string') {
-    text = String(text)
-  }
-
   node.nodeValue = text
 }

package/src/index.ts

@@ -5,4 +5,4 @@ export { Function } from './components/Function.tsx'
 export { Jsx } from './components/Jsx.tsx'
 export { Root } from './components/Root.tsx'
 export { Type } from './components/Type.tsx'
-export { jsxRenderer } from './createRenderer.tsx'
+export { jsxRenderer, jsxRendererSync } from './createRenderer.tsx'

package/src/types.ts

@@ -71,7 +71,7 @@ export type DOMElement = {
   /**
    * Key/value attributes passed as JSX props to this element.
    */
-  attributes: Map<string, DOMNodeAttribute>
+  attributes: Record<string, DOMNodeAttribute>
   /**
    * Ordered list of child nodes attached to this element.
    */