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

package/src/components/File.tsx

@@ -1,187 +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 for plugins to read.
-   */
-  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. `isExportable` prepends the `export` keyword,
- * `isIndexable` includes the source in barrel/index generation, and `name` keys deduplication.
- *
- * @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,37 +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
-   * `{ 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 whose frontmatter downstream tooling can read.
- *
- * @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'

package/src/components/Function.tsx

@@ -1,148 +0,0 @@
-import type { JSDoc, Key, KubbReactElement, KubbReactNode } from '../types.ts'
-
-type Props = {
-  key?: Key
-  /**
-   * Identifier of the generated function declaration.
-   *
-   * @example
-   * `name: 'getPet'`
-   */
-  name: string
-  /**
-   * Emit `default` after the `export` keyword, making this the module's default export.
-   * Requires `export` to also be `true`.
-   */
-  default?: boolean | null
-  /**
-   * Parameter list written verbatim between the function's parentheses.
-   *
-   * @example
-   * `params: 'petId: string, options?: RequestOptions'`
-   */
-  params?: string | null
-  /**
-   * Emit the `export` keyword before the function declaration.
-   * - `true` generates `export function name(…) { … }`
-   * - `false` generates `function name(…) { … }`
-   */
-  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.
-   */
-  async?: boolean | null
-  /**
-   * TypeScript generic type parameters written verbatim between `<` and `>`.
-   * Pass an array to emit multiple parameters separated by commas.
-   *
-   * @example Single generic
-   * `generics: 'TData'`
-   *
-   * @example Multiple generics
-   * `generics: ['TData', 'TError = unknown']`
-   */
-  generics?: string | Array<string> | null
-  /**
-   * TypeScript return type annotation written verbatim after `:`.
-   * When `async` is `true`, the value is automatically wrapped in `Promise<…>`.
-   *
-   * @example
-   * `returnType: 'Pet'`
-   */
-  returnType?: string | null
-  /**
-   * JSDoc block to prepend to the function declaration.
-   * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
-   */
-  JSDoc?: JSDoc | null
-  /**
-   * Child nodes rendered as the body of the function.
-   */
-  children?: KubbReactNode
-}
-
-/**
- * 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}`)
- * // }
- * ```
- */
-export function Function({ children, ...props }: Props): KubbReactElement {
-  const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc } = props
-
-  // Normalize generics array to comma-separated string for DOM attribute storage
-  const genericsString = Array.isArray(generics) ? generics.join(', ').trim() : generics
-
-  return (
-    <kubb-function
-      name={name}
-      params={params}
-      export={canExport}
-      default={isDefault}
-      async={isAsync}
-      generics={genericsString}
-      returnType={returnType}
-      JSDoc={JSDoc}
-    >
-      {children}
-    </kubb-function>
-  )
-}
-
-Function.displayName = 'Function'
-
-type ArrowFunctionProps = Props & {
-  /**
-   * Render the arrow function as a single-line expression (no braces around the body).
-   * - `true` generates `const name = (…) => expression`
-   * - `false` generates `const name = (…) => { … }`
-   */
-  singleLine?: boolean | null
-}
-
-/**
- * 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.
- *
- * @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 }: ArrowFunctionProps) {
-  const { name, default: isDefault, export: canExport, async, generics, params, returnType, JSDoc, singleLine } = props
-
-  const genericsString = Array.isArray(generics) ? generics.join(', ').trim() : generics
-
-  return (
-    <kubb-arrow-function
-      name={name}
-      params={params}
-      export={canExport}
-      default={isDefault}
-      async={async}
-      generics={genericsString}
-      returnType={returnType}
-      singleLine={singleLine}
-      JSDoc={JSDoc}
-    >
-      {children}
-    </kubb-arrow-function>
-  )
-}
-
-ArrowFunction.displayName = 'ArrowFunction'
-Function.Arrow = ArrowFunction

package/src/components/Heading.tsx

@@ -1,34 +0,0 @@
-import type { Key, KubbReactElement } from '../types.ts'
-
-type Level = 1 | 2 | 3 | 4 | 5 | 6
-
-type Props = {
-  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
- * ```
- */
-export function Heading({ level, children }: Props): KubbReactElement {
-  return <kubb-source name="heading">{`${'#'.repeat(level)} ${children}`}</kubb-source>
-}
-
-Heading.displayName = 'Heading'

package/src/components/Jsx.tsx

@@ -1,35 +0,0 @@
-import type { KubbReactElement } from '../types.ts'
-
-type Props = {
-  /**
-   * Raw JSX string embedded verbatim in the generated code, including
-   * fragments (`<>…</>`).
-   *
-   * @example
-   * ```tsx
-   * <Jsx>{'<>\n  <a href={href}>Open</a>\n</>'}</Jsx>
-   * ```
-   */
-  children?: string
-}
-
-/**
- * Embeds a raw JSX string verbatim in the generated source code.
- *
- * Use this component to include JSX markup (including fragments `<>…</>`) in the
- * body of a generated function or component. The `children` prop must be a plain
- * string. Write expression attributes that reference runtime values as template
- * literals.
- *
- * @example
- * ```tsx
- * <Function name="MyComponent" export>
- *   <Jsx>{'return (\n  <>\n    <div>Hello</div>\n  </>\n)'}</Jsx>
- * </Function>
- * ```
- */
-export function Jsx({ children }: Props): KubbReactElement {
-  return <kubb-jsx>{children}</kubb-jsx>
-}
-
-Jsx.displayName = 'Jsx'

package/src/components/List.tsx

@@ -1,40 +0,0 @@
-import type { Key, KubbReactElement } from '../types.ts'
-
-type Props = {
-  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
- * ```
- */
-export function List({ ordered, items }: Props): KubbReactElement {
-  const body = items.map((item, index) => `${ordered ? `${index + 1}.` : '-'} ${item}`).join('\n')
-  return <kubb-source name="list">{body}</kubb-source>
-}
-
-List.displayName = 'List'

package/src/components/Paragraph.tsx

@@ -1,28 +0,0 @@
-import type { Key, KubbReactElement } from '../types.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>
- * ```
- */
-export function Paragraph({ children }: Props): KubbReactElement {
-  return <kubb-source name="paragraph">{children}</kubb-source>
-}
-
-Paragraph.displayName = 'Paragraph'

package/src/components/Type.tsx

@@ -1,65 +0,0 @@
-import type { JSDoc, Key, KubbReactElement, KubbReactNode } from '../types.ts'
-
-type TypeProps = {
-  key?: Key
-  /**
-   * Identifier of the generated type alias.
-   * Must start with an uppercase letter to follow TypeScript naming conventions.
-   *
-   * @example
-   * `name: 'Pet'`
-   */
-  name: string
-  /**
-   * Emit the `export` keyword before the type alias declaration.
-   * - `true` generates `export type Name = …`
-   * - `false` generates `type Name = …`
-   */
-  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 | null
-  /**
-   * Child nodes rendered as the type expression on the right-hand side of the alias.
-   */
-  children?: KubbReactNode
-}
-
-/**
- * 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>
- * ```
- */
-export function Type({ children, ...props }: TypeProps): KubbReactElement {
-  const { name, export: canExport, JSDoc } = props
-
-  if (name.charAt(0).toUpperCase() !== name.charAt(0)) {
-    throw new Error('Name should start with a capital letter(see TypeScript types)')
-  }
-
-  return (
-    <kubb-type name={name} export={canExport} JSDoc={JSDoc}>
-      {children}
-    </kubb-type>
-  )
-}
-
-Type.displayName = 'Type'

package/src/constants.ts

@@ -1,9 +0,0 @@
-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,56 +0,0 @@
-import type { FileNode } from '@kubb/ast'
-import { SyncRuntime } from './SyncRuntime.tsx'
-import type { KubbReactElement } from './types.ts'
-
-/**
- * Factory for a renderer that walks the JSX tree in a single recursive pass,
- * with no React reconciler or scheduler. Pass it as the `renderer` property on
- * `defineGenerator`. Kubb core calls the factory once per render cycle and 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. The returned renderer also exposes `stream()`
- * for incremental file emission.
- *
- * @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>
- *     )
- *   },
- * })
- * ```
- *
- * @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 const jsxRenderer = () => {
-  const runtime = new SyncRuntime()
-
-  return {
-    async render(element: KubbReactElement): Promise<void> {
-      runtime.render(element)
-    },
-    get files() {
-      return runtime.nodes
-    },
-    stream(element: KubbReactElement): Generator<FileNode> {
-      return runtime.stream(element)
-    },
-    [Symbol.dispose]() {},
-  }
-}

package/src/globals.ts

@@ -1,42 +0,0 @@
-import type {
-  KubbArrowFunctionProps,
-  KubbConstProps,
-  KubbExportProps,
-  KubbFileProps,
-  KubbFunctionProps,
-  KubbImportProps,
-  KubbJsxProps,
-  KubbReactElement,
-  KubbReactNode,
-  KubbSourceProps,
-  KubbTypeProps,
-  Key,
-  LineBreakProps,
-} from './types.ts'
-
-declare global {
-  namespace JSX {
-    type Element = KubbReactElement
-
-    interface ElementClass {
-      render(): KubbReactNode
-    }
-
-    interface IntrinsicAttributes {
-      key?: Key | null
-    }
-
-    interface IntrinsicElements {
-      'kubb-jsx': KubbJsxProps
-      '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
-    }
-  }
-}