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

package/src/components/Function.tsx

@@ -1,152 +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 false
-   */
-  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(…) { … }`
-   * @default false
-   */
-  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 | 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 = (…) => { … }`
-   * @default false
-   */
-  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,34 +0,0 @@
-import type { KubbReactElement } from '../types.ts'
-
-type Props = {
-  /**
-   * Raw JSX string to embed verbatim in the generated code.
-   * Supports JSX fragments (`<>…</>`), elements, and any valid JSX syntax.
-   * @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 when you need to include JSX markup (including fragments
- * `<>…</>`) in the body of a generated function or component. The `children`
- * prop must be a plain string, expression attributes that reference runtime
- * values should be written 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,66 +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 = …`
-   * @default false
-   */
-  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'
-
-/**
- * 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.
- *
- * @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
-    }
-  }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-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 { List } from './components/List.tsx'
-export { Paragraph } from './components/Paragraph.tsx'
-export { Type } from './components/Type.tsx'
-export { jsxRenderer } from './createRenderer.tsx'

package/src/jsx-dev-runtime.ts

@@ -1,8 +0,0 @@
-import type { KubbReactElement, KubbReactNode } from './types.ts'
-
-export { Fragment, jsxDEV } from './jsx-runtime.ts'
-
-export type * from './jsx-namespace.d.ts'
-
-export type JSXElement = KubbReactElement
-export type ReactNode = KubbReactNode

package/src/jsx-namespace.d.ts

@@ -1,60 +0,0 @@
-import type {
-  KubbArrowFunctionProps,
-  KubbConstProps,
-  KubbExportProps,
-  KubbFileProps,
-  KubbFunctionProps,
-  KubbImportProps,
-  KubbJsxProps,
-  KubbReactElement,
-  KubbReactNode,
-  KubbSourceProps,
-  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 = string | ((props: any) => KubbReactNode)
-  type Element = KubbReactElement
-
-  interface ElementClass {
-    render(): KubbReactNode
-  }
-  interface ElementAttributesProperty {
-    props: {}
-  }
-  interface ElementChildrenAttribute {
-    children: {}
-  }
-
-  interface IntrinsicAttributes {
-    key?: Key | null
-  }
-  interface IntrinsicClassAttributes<T> {
-    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
-  }
-
-  type LibraryManagedAttributes<C, P> = P
-}

package/src/jsx-runtime.ts

@@ -1,28 +0,0 @@
-import type { Key, KubbReactElement, KubbReactNode } from './types.ts'
-
-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'
-
-export type JSXElement = KubbReactElement
-export type ReactNode = KubbReactNode