@kubb/renderer-jsx 5.0.0-beta.7 → 5.0.0-beta.70

package/src/dom.ts

@@ -1,105 +0,0 @@
-import { TEXT_NODE_NAME } from './constants.ts'
-import type { DOMElement, DOMNode, DOMNodeAttribute, TextNode } from './types.ts'
-
-/**
- * Create a new, empty {@link DOMElement} with the given node name.
- * The element has no attributes, no children, and no parent.
- */
-export const createNode = (nodeName: string): DOMElement => {
-  const node: DOMElement = {
-    nodeName: nodeName as DOMElement['nodeName'],
-    attributes: new Map(),
-    childNodes: [],
-    parentNode: undefined,
-  }
-
-  return node
-}
-
-/**
- * Append `childNode` as the last child of `node`.
- *
- * If `childNode` already has a parent, it is removed from that parent first
- * (matching standard DOM move semantics).
- * Text nodes (`nodeName === '#text'`) are silently ignored.
- */
-export const appendChildNode = (node: DOMNode, childNode: DOMElement | DOMNode): void => {
-  if (childNode.parentNode) {
-    removeChildNode(childNode.parentNode, childNode)
-  }
-
-  if (node.nodeName !== TEXT_NODE_NAME) {
-    childNode.parentNode = node
-    node.childNodes.push(childNode)
-  }
-}
-
-/**
- * Insert `newChildNode` before `beforeChildNode` in `node`'s child list.
- *
- * If `newChildNode` already has a parent, it is removed from that parent first.
- * If `beforeChildNode` is not found, `newChildNode` is appended at the end.
- */
-export const insertBeforeNode = (node: DOMElement, newChildNode: DOMNode, beforeChildNode: DOMNode): void => {
-  if (newChildNode.parentNode) {
-    removeChildNode(newChildNode.parentNode, newChildNode)
-  }
-
-  newChildNode.parentNode = node
-
-  const index = node.childNodes.indexOf(beforeChildNode)
-  if (index >= 0) {
-    node.childNodes.splice(index, 0, newChildNode)
-
-    return
-  }
-
-  node.childNodes.push(newChildNode)
-}
-
-/**
- * Remove `removeNode` from `node`'s child list and clear its `parentNode` reference.
- * Does nothing if `removeNode` is not a direct child of `node`.
- */
-export const removeChildNode = (node: DOMElement, removeNode: DOMNode): void => {
-  removeNode.parentNode = undefined
-
-  const index = node.childNodes.indexOf(removeNode)
-  if (index >= 0) {
-    node.childNodes.splice(index, 1)
-  }
-}
-
-/**
- * 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)
-}
-
-/**
- * Create a new {@link TextNode} with the given text value.
- */
-export const createTextNode = (text: string): TextNode => {
-  const node: TextNode = {
-    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/globals.ts

@@ -1,34 +0,0 @@
-import type React from 'react'
-import type {
-  KubbExportProps,
-  KubbFileProps,
-  KubbImportProps,
-  KubbJsxProps,
-  KubbReactElement,
-  KubbReactNode,
-  KubbSourceProps,
-  KubbTextProps,
-  LineBreakProps,
-} from './types.ts'
-
-declare global {
-  namespace JSX {
-    type Element = KubbReactElement
-
-    interface ElementClass extends React.ComponentClass<any> {
-      render(): KubbReactNode
-    }
-
-    interface IntrinsicElements {
-      'kubb-jsx': KubbJsxProps
-      'kubb-text': KubbTextProps
-      'kubb-file': KubbFileProps
-      'kubb-source': KubbSourceProps
-      'kubb-import': KubbImportProps
-      'kubb-export': KubbExportProps
-      br: LineBreakProps
-      indent: {}
-      dedent: {}
-    }
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export { createContext, inject, provide, unprovide } from '@internals/utils'
-export { Const } from './components/Const.tsx'
-export { File } from './components/File.tsx'
-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 { createRenderer, jsxRenderer } from './createRenderer.tsx'

package/src/jsx-dev-runtime.ts

@@ -1,10 +0,0 @@
-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 type * from './jsx-namespace.d.ts'
-
-export type JSXElement = KubbReactElement
-export type ReactNode = KubbReactNode

package/src/jsx-namespace.d.ts

@@ -1,52 +0,0 @@
-import type React from 'react'
-
-import type {
-  KubbArrowFunctionProps,
-  KubbConstProps,
-  KubbExportProps,
-  KubbFileProps,
-  KubbFunctionProps,
-  KubbImportProps,
-  KubbJsxProps,
-  KubbReactElement,
-  KubbReactNode,
-  KubbSourceProps,
-  KubbTextProps,
-  KubbTypeProps,
-  LineBreakProps,
-} from './types'
-
-export namespace JSX {
-  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 {}
-}

package/src/jsx-runtime.ts

@@ -1,12 +0,0 @@
-import * as React from 'react/jsx-runtime'
-import type { 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
-
-export type * from './jsx-namespace.d.ts'
-
-export type JSXElement = KubbReactElement
-export type ReactNode = KubbReactNode

package/src/types.ts

@@ -1,207 +0,0 @@
-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.
- */
-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.
- */
-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
-}
-
-/**
- * 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.
- */
-export type KubbReactNode = ReactNode
-
-/**
- * React element type returned by Kubb JSX components.
- */
-export type KubbReactElement = JSX.Element
-
-/**
- * Props for the `<kubb-jsx>` element.
- * Embeds a raw JSX string verbatim in generated output.
- */
-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
-  children?: KubbReactNode
-  baseName: string
-  path: string
-  override?: boolean
-  meta?: FileNode['meta']
-}
-
-/**
- * Props for the `<kubb-source>` element.
- * Marks a block of source text associated with a file.
- */
-export type KubbSourceProps = Omit<SourceNode, 'kind'> & {
-  children?: KubbReactNode
-}
-
-/**
- * Props for the `<kubb-import>` element.
- * Declares an import statement in the generated file.
- */
-export type KubbImportProps = Omit<ImportNode, 'kind'> & {}
-
-/**
- * Props for the `<kubb-export>` element.
- * Declares an export statement in the generated file.
- */
-export type KubbExportProps = Omit<ExportNode, 'kind'> & {}
-
-/**
- * Props for the `<kubb-function>` element.
- * Generates a function declaration.
- */
-export type KubbFunctionProps = Omit<FunctionNode, 'kind'> & {
-  children?: KubbReactNode
-}
-
-/**
- * Props for the `<kubb-arrow-function>` element.
- * Generates an arrow function declaration.
- */
-export type KubbArrowFunctionProps = Omit<ArrowFunctionNode, 'kind'> & {
-  children?: KubbReactNode
-}
-
-/**
- * Props for the `<kubb-const>` element.
- * Generates a constant declaration.
- */
-export type KubbConstProps = Omit<ConstNode, 'kind'> & {
-  children?: KubbReactNode
-}
-
-/**
- * Props for the `<kubb-type>` element.
- * Generates a TypeScript type alias declaration.
- */
-export type KubbTypeProps = Omit<TypeNode, 'kind'> & {
-  children?: KubbReactNode
-}
-
-/**
- * Props for the HTML `<br>` element.
- */
-export type LineBreakProps = React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement>
-
-/**
- * JSDoc comment block to attach to a generated declaration.
- * Each string in `comments` becomes one line inside the `/** … *\/` block.
- *
- * @example
- * ```ts
- * { comments: ['@description A pet object.', '@deprecated Use PetV2 instead.'] }
- * // Emits:
- * // /**
- * //  * @description A pet object.
- * //  * @deprecated Use PetV2 instead.
- * //  *\/
- * ```
- */
-export type JSDoc = {
-  /**
-   * Lines to emit inside the JSDoc block, in source order.
-   * Use standard JSDoc tags such as `@description`, `@deprecated`, `@see`, etc.
-   */
-  comments: Array<string>
-}

package/src/utils.ts

@@ -1,267 +0,0 @@
-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 { nodeNames, TEXT_NODE_NAME } from './constants.ts'
-import type { DOMElement, DOMNode, ElementNames } from './types.ts'
-
-/**
- * Collect the text and nested AST-node children of a single kubb-* element.
- *
- * `#text` children become raw {@link TextNode}s; nested `kubb-function`, `kubb-const`,
- * `kubb-type`, and similar elements are converted into their respective {@link CodeNode}s.
- * Any unrecognized DOM elements are silently skipped.
- */
-function collectChildNodes(element: DOMElement): Array<CodeNode> {
-  const result: Array<CodeNode> = []
-
-  for (const child of element.childNodes) {
-    if (!child) {
-      continue
-    }
-
-    if (child.nodeName === TEXT_NODE_NAME) {
-      const text = (child as DOMNode<{ nodeName: '#text' }>).nodeValue
-      if (text && text.trim().length > 0) {
-        result.push(createText(text))
-      }
-      continue
-    }
-
-    if (child.nodeName === 'br') {
-      result.push(createBreak())
-      continue
-    }
-
-    if (child.nodeName === 'kubb-function') {
-      const attrs = child.attributes
-      result.push(
-        createFunction({
-          name: attrs.get('name') as string,
-          params: attrs.get('params') as string | undefined,
-          export: attrs.get('export') as boolean | undefined,
-          default: attrs.get('default') as boolean | undefined,
-          async: attrs.get('async') as boolean | undefined,
-          generics: attrs.get('generics') as string | undefined,
-          returnType: attrs.get('returnType') as string | undefined,
-          JSDoc: attrs.get('JSDoc') as JSDocNode | undefined,
-          nodes: collectChildNodes(child),
-        }),
-      )
-    } else if (child.nodeName === 'kubb-arrow-function') {
-      const attrs = child.attributes
-      result.push(
-        createArrowFunction({
-          name: attrs.get('name') as string,
-          params: attrs.get('params') as string | undefined,
-          export: attrs.get('export') as boolean | undefined,
-          default: attrs.get('default') as boolean | undefined,
-          async: attrs.get('async') as boolean | undefined,
-          generics: attrs.get('generics') as string | undefined,
-          returnType: attrs.get('returnType') as string | undefined,
-          singleLine: attrs.get('singleLine') as boolean | undefined,
-          JSDoc: attrs.get('JSDoc') as JSDocNode | undefined,
-          nodes: collectChildNodes(child),
-        } as Omit<ArrowFunctionNode, 'kind'>),
-      )
-    } else if (child.nodeName === 'kubb-const') {
-      const attrs = child.attributes
-      result.push(
-        createConst({
-          name: attrs.get('name') as string,
-          type: attrs.get('type') as string | undefined,
-          export: attrs.get('export') as boolean | undefined,
-          asConst: attrs.get('asConst') as boolean | undefined,
-          JSDoc: attrs.get('JSDoc') as JSDocNode | undefined,
-          nodes: collectChildNodes(child),
-        }),
-      )
-    } else if (child.nodeName === 'kubb-type') {
-      const attrs = child.attributes
-      result.push(
-        createType({
-          name: attrs.get('name') as string,
-          export: attrs.get('export') as boolean | undefined,
-          JSDoc: attrs.get('JSDoc') as JSDocNode | undefined,
-          nodes: collectChildNodes(child),
-        }),
-      )
-    } else if (child.nodeName === 'kubb-jsx') {
-      const textChild = child.childNodes[0]
-      const value = textChild?.nodeName === TEXT_NODE_NAME ? (textChild as DOMNode<{ nodeName: '#text' }>).nodeValue : ''
-      if (value) {
-        result.push(createJsx(value))
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Traverse `node` and collect all `<kubb-source>` elements into a `Set<SourceNode>`.
- *
- * Elements whose `nodeName` is in `ignores` are skipped entirely (including their subtrees).
- * This is used to collect source blocks from a file node while excluding import/export subtrees.
- *
- * @example Collect sources while ignoring export and import elements
- * ```ts
- * const sources = squashSourceNodes(fileElement, ['kubb-export', 'kubb-import'])
- * ```
- */
-function squashSourceNodes(node: DOMElement, ignores: Array<ElementNames>): Set<SourceNode> {
-  const ignoreSet = new Set(ignores)
-  const sources = new Set<SourceNode>()
-
-  const walk = (current: DOMElement): void => {
-    for (const child of current.childNodes) {
-      if (!child) {
-        continue
-      }
-
-      if (child.nodeName !== TEXT_NODE_NAME && ignoreSet.has(child.nodeName)) {
-        continue
-      }
-
-      if (child.nodeName === 'kubb-source') {
-        const source = createSource({
-          name: child.attributes.get('name')?.toString(),
-          isTypeOnly: (child.attributes.get('isTypeOnly') ?? false) as boolean,
-          isExportable: (child.attributes.get('isExportable') ?? false) as boolean,
-          isIndexable: (child.attributes.get('isIndexable') ?? false) as boolean,
-          nodes: collectChildNodes(child),
-        })
-
-        sources.add(source)
-        continue
-      }
-
-      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
-        walk(child)
-      }
-    }
-  }
-
-  walk(node)
-  return sources
-}
-
-/**
- * Traverse `node` and collect all `<kubb-export>` elements into a `Set<ExportNode>`.
- */
-function squashExportNodes(node: DOMElement): Set<ExportNode> {
-  const exports = new Set<ExportNode>()
-
-  const walk = (current: DOMElement): void => {
-    for (const child of current.childNodes) {
-      if (!child) {
-        continue
-      }
-
-      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
-        walk(child)
-      }
-
-      if (child.nodeName === 'kubb-export') {
-        exports.add(
-          createExport({
-            name: child.attributes.get('name') as ExportNode['name'],
-            path: child.attributes.get('path') as string,
-            isTypeOnly: (child.attributes.get('isTypeOnly') ?? false) as boolean,
-            asAlias: (child.attributes.get('asAlias') ?? false) as boolean,
-          }),
-        )
-      }
-    }
-  }
-
-  walk(node)
-  return exports
-}
-
-/**
- * Traverse `node` and collect all `<kubb-import>` elements into a `Set<ImportNode>`.
- */
-function squashImportNodes(node: DOMElement): Set<ImportNode> {
-  const imports = new Set<ImportNode>()
-
-  const walk = (current: DOMElement): void => {
-    for (const child of current.childNodes) {
-      if (!child) {
-        continue
-      }
-
-      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
-        walk(child)
-      }
-
-      if (child.nodeName === 'kubb-import') {
-        imports.add(
-          createImport({
-            name: child.attributes.get('name') as ImportNode['name'],
-            path: child.attributes.get('path') as string,
-            root: child.attributes.get('root') as string | undefined,
-            isTypeOnly: (child.attributes.get('isTypeOnly') ?? false) as boolean,
-            isNameSpace: (child.attributes.get('isNameSpace') ?? false) as boolean,
-          }),
-        )
-      }
-    }
-  }
-
-  walk(node)
-  return imports
-}
-
-/**
- * Walk the virtual DOM tree rooted at `node` and convert every `<kubb-file>` element
- * into a {@link FileNode}, collecting its source blocks, imports, and exports.
- *
- * Returns the list of file nodes in document order. Nested files are supported —
- * the walker descends into non-file elements and recurses through them.
- */
-export function processFiles(node: DOMElement): Array<FileNode> {
-  const collected: Array<FileNode> = []
-
-  function walk(current: DOMElement) {
-    for (const child of current.childNodes) {
-      if (!child) {
-        continue
-      }
-
-      if (child.nodeName !== TEXT_NODE_NAME && child.nodeName !== 'kubb-file' && nodeNames.has(child.nodeName)) {
-        walk(child)
-      }
-
-      if (child.nodeName === 'kubb-file') {
-        if (child.attributes.has('baseName') && child.attributes.has('path')) {
-          const sources = squashSourceNodes(child, ['kubb-export', 'kubb-import'])
-
-          collected.push({
-            baseName: child.attributes.get('baseName'),
-            path: child.attributes.get('path'),
-            meta: child.attributes.get('meta') || {},
-            footer: child.attributes.get('footer'),
-            banner: child.attributes.get('banner'),
-            sources: [...sources],
-            exports: [...squashExportNodes(child)],
-            imports: [...squashImportNodes(child)],
-          } as FileNode)
-        }
-      }
-    }
-  }
-
-  walk(node)
-
-  return collected
-}