@kubb/renderer-jsx 5.0.0-beta.62 → 5.0.0-beta.64

package/src/SyncRuntime.tsx

@@ -1,298 +0,0 @@
-import type { ArrowFunctionNode, CodeNode, ExportNode, FileNode, ImportNode, JSDocNode, SourceNode } from '@kubb/ast'
-import * as factory from '@kubb/ast/factory'
-import { KUBB_ARROW_FUNCTION, KUBB_CONST, KUBB_EXPORT, KUBB_FILE, KUBB_FUNCTION, KUBB_IMPORT, KUBB_JSX, KUBB_SOURCE, KUBB_TYPE } from './constants.ts'
-import { Fragment } from './jsx-runtime.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 KubbReactElement
-    const { type } = el
-    const props = el.props as Record<string, unknown>
-
-    if (type === Fragment) {
-      walkElement(props['children'], onText, onHost)
-      return
-    }
-    if (typeof type === 'function') {
-      walkElement((type as (p: unknown) => unknown)(props), onText, onHost)
-      return
-    }
-    if (typeof type === 'string') {
-      onHost(type, props)
-    }
-  }
-}
-
-function toBool(val: unknown): boolean {
-  return (val ?? false) as boolean
-}
-
-function collectCodeNodes(props: Record<string, unknown>): Array<CodeNode> {
-  const nodes: Array<CodeNode> = []
-  collectCode(props['children'], nodes)
-  return nodes
-}
-
-function collectCode(element: unknown, nodes: Array<CodeNode>): void {
-  walkElement(
-    element,
-    (text) => {
-      if (text.trim()) nodes.push(factory.createText(text))
-    },
-    (type, props) => resolveCodeNode(type, props, nodes),
-  )
-}
-
-function resolveCodeNode(type: string, props: Record<string, unknown>, nodes: Array<CodeNode>): void {
-  if (type === 'br') {
-    nodes.push(factory.createBreak())
-    return
-  }
-
-  if (type === KUBB_JSX) {
-    let value = ''
-    walkElement(
-      props['children'],
-      (t) => {
-        value += t
-      },
-      () => {},
-    )
-    if (value) nodes.push(factory.createJsx(value))
-    return
-  }
-
-  if (type === KUBB_FUNCTION) {
-    nodes.push(
-      factory.createFunction({
-        name: props['name'] as string,
-        params: props['params'] as string | null | undefined,
-        export: props['export'] as boolean | null | undefined,
-        default: props['default'] as boolean | null | undefined,
-        async: props['async'] as boolean | null | undefined,
-        generics: props['generics'] as string | Array<string> | null | undefined,
-        returnType: props['returnType'] as string | null | undefined,
-        JSDoc: props['JSDoc'] as JSDocNode | null | undefined,
-        nodes: collectCodeNodes(props),
-      }),
-    )
-    return
-  }
-
-  if (type === KUBB_ARROW_FUNCTION) {
-    nodes.push(
-      factory.createArrowFunction({
-        name: props['name'] as string,
-        params: props['params'] as string | null | undefined,
-        export: props['export'] as boolean | null | undefined,
-        default: props['default'] as boolean | null | undefined,
-        async: props['async'] as boolean | null | undefined,
-        generics: props['generics'] as string | Array<string> | null | undefined,
-        returnType: props['returnType'] as string | null | undefined,
-        singleLine: props['singleLine'] as boolean | null | undefined,
-        JSDoc: props['JSDoc'] as JSDocNode | null | undefined,
-        nodes: collectCodeNodes(props),
-      } as Omit<ArrowFunctionNode, 'kind'>),
-    )
-    return
-  }
-
-  if (type === KUBB_CONST) {
-    nodes.push(
-      factory.createConst({
-        name: props['name'] as string,
-        type: props['type'] as string | null | undefined,
-        export: props['export'] as boolean | null | undefined,
-        asConst: props['asConst'] as boolean | null | undefined,
-        JSDoc: props['JSDoc'] as JSDocNode | null | undefined,
-        nodes: collectCodeNodes(props),
-      }),
-    )
-    return
-  }
-
-  if (type === KUBB_TYPE) {
-    nodes.push(
-      factory.createType({
-        name: props['name'] as string,
-        export: props['export'] as boolean | null | undefined,
-        JSDoc: props['JSDoc'] as JSDocNode | null | undefined,
-        nodes: collectCodeNodes(props),
-      }),
-    )
-    return
-  }
-}
-
-type FileChildren = { sources: Array<SourceNode>; exports: Array<ExportNode>; imports: Array<ImportNode> }
-
-function collectFileChildren(element: unknown): FileChildren {
-  const sources: Array<SourceNode> = []
-  const exports: Array<ExportNode> = []
-  const imports: Array<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(
-          factory.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(
-          factory.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(
-          factory.createImport({
-            name: props['name'] as ImportNode['name'],
-            path: props['path'] as string,
-            root: props['root'] as string | null | 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> {
-  if (element == null || typeof element === 'boolean') return
-
-  if (typeof element === 'string' || typeof element === 'number' || typeof element === 'bigint') return
-
-  if (Array.isArray(element)) {
-    for (const child of element) yield* walkFiles(child)
-    return
-  }
-
-  if (typeof element === 'object' && '$$typeof' in element) {
-    const el = element as unknown as KubbReactElement
-    const { type } = el
-    const props = el.props as Record<string, unknown>
-
-    if (type === Fragment) {
-      yield* walkFiles(props['children'])
-      return
-    }
-
-    if (typeof type === 'function') {
-      yield* walkFiles((type as (p: unknown) => unknown)(props))
-      return
-    }
-
-    if (typeof type === 'string') {
-      if (type === KUBB_FILE && props['baseName'] !== undefined && props['path'] !== undefined) {
-        const { sources, exports, imports } = collectFileChildren(props['children'])
-        yield {
-          baseName: props['baseName'],
-          path: props['path'],
-          meta: props['meta'] || {},
-          footer: props['footer'],
-          banner: props['banner'],
-          sources,
-          exports,
-          imports,
-        } as FileNode
-      } else {
-        yield* walkFiles(props['children'])
-      }
-    }
-  }
-}
-
-/**
- * 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: Array<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/components/Callout.tsx

@@ -1,59 +0,0 @@
-import type { Key, KubbReactElement } from '../types.ts'
-
-const CALLOUT_LABEL = {
-  tip: 'TIP',
-  note: 'NOTE',
-  important: 'IMPORTANT',
-  warning: 'WARNING',
-  caution: 'CAUTION',
-} as const
-
-export type CalloutType = keyof typeof CALLOUT_LABEL
-
-type Props = {
-  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.
- * ```
- */
-export function Callout({ type, title, children }: Props): KubbReactElement {
-  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 <kubb-source name="callout">{`${header}\n${quoted}`}</kubb-source>
-}
-
-Callout.displayName = 'Callout'

package/src/components/Const.tsx

@@ -1,72 +0,0 @@
-import type { JSDoc, Key, KubbReactElement, KubbReactNode } from '../types.ts'
-
-type ConstProps = {
-  key?: Key
-  /**
-   * Identifier of the generated constant declaration.
-   *
-   * @example
-   * `name: 'petSchema'`
-   */
-  name: string
-  /**
-   * Emit the `export` keyword before the `const` declaration.
-   * - `true` generates `export const name = …`
-   * - `false` generates `const name = …`
-   * @default false
-   */
-  export?: boolean | null
-  /**
-   * TypeScript type annotation for the constant, written verbatim after `const name:`.
-   *
-   * @example
-   * `type: 'Pet'` → `const pet: Pet = …`
-   */
-  type?: string | null
-  /**
-   * JSDoc block to prepend to the constant declaration.
-   * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
-   */
-  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 | null
-  /**
-   * Child nodes rendered as the initialiser expression of the constant.
-   */
-  children?: KubbReactNode
-}
-
-/**
- * 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>
- * ```
- */
-export function Const({ children, ...props }: ConstProps): KubbReactElement {
-  const { name, export: canExport, type, JSDoc, asConst } = props
-
-  return (
-    <kubb-const name={name} type={type} export={canExport} asConst={asConst} JSDoc={JSDoc}>
-      {children}
-    </kubb-const>
-  )
-}
-
-Const.displayName = 'Const'

package/src/components/File.tsx

@@ -1,188 +0,0 @@
-import type { ExportNode, ImportNode, SourceNode } from '@kubb/ast'
-import type { Key, KubbReactElement, KubbReactNode } from '../types.ts'
-
-type BasePropsWithBaseName = {
-  /**
-   * Base file name including extension, derived from the input path.
-   * Based on UNIX basename convention: `${name}${extname}`.
-   *
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   *
-   * @example
-   * `baseName: 'petStore.ts'`
-   */
-  baseName: `${string}.${string}`
-  /**
-   * Fully qualified path to the generated file.
-   *
-   * @example
-   * `path: 'src/models/petStore.ts'`
-   */
-  path: string
-}
-
-type BasePropsWithoutBaseName = {
-  baseName?: never
-  /**
-   * Fully qualified path to the generated file.
-   * Optional when `baseName` is omitted, the component renders its children inline.
-   */
-  path?: string | null
-}
-
-type BaseProps = BasePropsWithBaseName | BasePropsWithoutBaseName
-
-type Props<TMeta> = BaseProps & {
-  key?: Key
-  /**
-   * Arbitrary metadata attached to the file node.
-   * Used by plugins for barrel generation and custom post-processing.
-   */
-  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 | null
-  /**
-   * Text appended to the generated file content after all source blocks.
-   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
-   */
-  footer?: string | null
-  /**
-   * Child nodes rendered as the content of this file (source blocks, imports, exports).
-   */
-  children?: KubbReactNode
-}
-
-/**
- * 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>
- * ```
- */
-export function File<TMeta extends object = object>({ children, ...props }: Props<TMeta>): KubbReactElement {
-  const { baseName, path } = props
-
-  if (!baseName || !path) {
-    return <>{children}</>
-  }
-
-  return <kubb-file {...props}>{children}</kubb-file>
-}
-
-File.displayName = 'File'
-
-type FileSourceProps = Omit<SourceNode, 'kind' | 'value'> & {
-  key?: Key
-  /**
-   * Child nodes rendered as the source content of this block.
-   */
-  children?: KubbReactNode
-}
-
-/**
- * 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>
- * ```
- *
- * @example Type-only source block
- * ```tsx
- * <File.Source name="PetId" isTypeOnly isExportable>
- *   {`export type PetId = string`}
- * </File.Source>
- * ```
- */
-function FileSource({ children, ...props }: FileSourceProps): KubbReactElement {
-  const { name, isExportable, isIndexable, isTypeOnly } = props
-
-  return (
-    <kubb-source name={name} isTypeOnly={isTypeOnly} isExportable={isExportable} isIndexable={isIndexable}>
-      {children}
-    </kubb-source>
-  )
-}
-
-FileSource.displayName = 'FileSource'
-
-type FileExportProps = Omit<ExportNode, 'kind'> & { key?: Key }
-
-/**
- * Declares an export entry for the enclosing {@link File}.
- *
- * 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: FileExportProps): KubbReactElement {
-  const { name, path, isTypeOnly, asAlias } = props
-
-  return <kubb-export name={name} path={path} isTypeOnly={isTypeOnly} asAlias={asAlias} />
-}
-
-FileExport.displayName = 'FileExport'
-
-type FileImportProps = Omit<ImportNode, 'kind'> & { key?: Key }
-
-/**
- * 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.
- *
- * @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: FileImportProps): KubbReactElement {
-  const { name, root, path, isTypeOnly, isNameSpace } = props
-
-  return <kubb-import name={name} root={root} path={path} isNameSpace={isNameSpace} isTypeOnly={isTypeOnly} />
-}
-
-FileImport.displayName = 'FileImport'
-
-File.Export = FileExport
-File.Import = FileImport
-File.Source = FileSource

package/src/components/Frontmatter.tsx

@@ -1,38 +0,0 @@
-import { stringify } from 'yaml'
-import type { Key, KubbReactElement } from '../types.ts'
-
-type Props = {
-  key?: Key
-  /**
-   * Plain object serialized 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>
- * ```
- */
-export function Frontmatter({ data }: Props): KubbReactElement {
-  const envelope = `---\n${stringify(data).trimEnd()}\n---`
-  return <kubb-source name="frontmatter">{envelope}</kubb-source>
-}
-
-Frontmatter.displayName = 'Frontmatter'