@kubb/renderer-jsx 5.0.0-beta.3 → 5.0.0-beta.31

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-Cur_nGCL.js";
+import { t as JSX } from "./jsx-namespace-D_TStJE_.js";
 import * as _$react from "react";
 import * as React$1 from "react/jsx-runtime";
 

package/dist/{jsx-namespace-CNp0arTN.d.ts → jsx-namespace-D_TStJE_.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-Cur_nGCL.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-D_TStJE_.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-Cur_nGCL.js";
+import { t as JSX } from "./jsx-namespace-D_TStJE_.js";
 import * as _$react from "react";
 import * as React$1 from "react/jsx-runtime";
 

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

@@ -13,13 +13,14 @@ type Key = string | number | bigint;
  */
 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;
+  parentNode: DOMElement | null;
   internal_static?: boolean;
 };
 /**
  * Allowed attribute value types for DOM elements.
+ * `null` signals intentionally empty — the prop was explicitly cleared.
  */
-type DOMNodeAttribute = boolean | string | number | Record<string, unknown> | Array<unknown>;
+type DOMNodeAttribute = boolean | string | number | null | Record<string, unknown> | Array<unknown>;
 type TextName = '#text';
 /**
  * Leaf DOM node containing raw text.
@@ -46,11 +47,11 @@ 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.
    */
-  childNodes: DOMNode[];
+  childNodes: Array<DOMNode>;
   internal_transform?: OutputTransformer;
   isStaticDirty?: boolean;
   staticNode?: DOMElement;
@@ -86,12 +87,12 @@ type KubbTextProps = {
  * Represents a generated file.
  */
 type KubbFileProps = {
-  id?: string;
+  id?: string | null;
   children?: KubbReactNode;
   baseName: string;
   path: string;
-  override?: boolean;
-  meta?: FileNode['meta'];
+  override?: boolean | null;
+  meta?: FileNode['meta'] | null;
 };
 /**
  * Props for the `<kubb-source>` element.
@@ -165,4 +166,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-Cur_nGCL.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-Cur_nGCL.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,19 +1,13 @@
 {
   "name": "@kubb/renderer-jsx",
-  "version": "5.0.0-beta.3",
-  "description": "React integration for Kubb - JSX runtime and component-based code generation with React reconciler for building type-safe generators",
+  "version": "5.0.0-beta.31",
+  "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": [
-    "code-generator",
     "codegen",
-    "component-generation",
-    "file-generation",
     "jsx",
     "jsx-runtime",
     "kubb",
-    "plugin-system",
-    "plugins",
     "react",
-    "react-reconciler",
     "typescript"
   ],
   "license": "MIT",
@@ -81,10 +75,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.3"
+    "yaml": "^2.9.0",
+    "@kubb/ast": "5.0.0-beta.31"
   },
   "devDependencies": {
-    "@types/react": "^19.2.14",
+    "@types/react": "^19.2.15",
     "@types/react-reconciler": "0.33.0",
     "react": "19.2.5",
     "react-reconciler": "0.33.0",

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,
@@ -155,9 +155,7 @@ export const Renderer = Reconciler({
   maySuspendCommit() {
     return false
   },
-  // eslint-disable-next-line @typescript-eslint/naming-convention
   NotPendingTransition: undefined,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
   HostTransitionContext: createContext(null) as unknown as ReactContext<unknown>,
   resetFormInstance() {},
   requestPostPaintCallback() {},
@@ -180,5 +178,3 @@ export const Renderer = Reconciler({
     return null
   },
 })
-
-export type { FiberRoot } from 'react-reconciler'

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 './Renderer.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 = {
   /**
@@ -22,11 +22,11 @@ export class Runtime {
 
   exitPromise?: Promise<void>
 
-  nodes: FileNode[] = []
+  nodes: Array<FileNode> = []
   readonly #container: FiberRoot
   readonly #rootNode: DOMElement
 
-  constructor(options: Options) {
+  constructor(options: Options = {}) {
     this.#options = options
     this.#rootNode = createNode('kubb-root')
     this.#rootNode.onRender = this.onRender
@@ -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)
 
@@ -156,15 +156,4 @@ export class Runtime {
 
     this.resolveExitPromise()
   }
-
-  async waitUntilExit(): Promise<void> {
-    if (!this.exitPromise) {
-      this.exitPromise = new Promise((resolve, reject) => {
-        this.resolveExitPromise = resolve
-        this.rejectExitPromise = reject
-      })
-    }
-
-    return this.exitPromise
-  }
 }

package/src/SyncRuntime.tsx

@@ -0,0 +1,309 @@
+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)
+      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(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(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 | 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(
+      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(
+      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(
+      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(
+          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 | 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 React.ReactElement
+    const { type } = el
+    const props = el.props as Record<string, unknown>
+
+    if (type === React.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

@@ -0,0 +1,59 @@
+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/CodeBlock.tsx

@@ -0,0 +1,37 @@
+import type { Key, KubbReactElement } from '../types.ts'
+
+type Props = {
+  key?: Key
+  /**
+   * Language tag for syntax highlighting. Rendered after the opening fence.
+   *
+   * @example
+   * `lang: 'typescript'`
+   */
+  lang?: string
+  /**
+   * Code body. Wrapped in triple-backtick fences as-is.
+   */
+  children: string
+}
+
+/**
+ * Renders a fenced markdown code block.
+ *
+ * Emits a `<File.Source>` block containing the children wrapped in
+ * triple-backtick fences with an optional language tag.
+ *
+ * @example
+ * ```tsx
+ * <CodeBlock lang="typescript">{'const pet = { id: 1 }'}</CodeBlock>
+ * // ```typescript
+ * // const pet = { id: 1 }
+ * // ```
+ * ```
+ */
+export function CodeBlock({ lang, children }: Props): KubbReactElement {
+  const fence = `\`\`\`${lang ?? ''}\n${children}\n\`\`\``
+  return <kubb-source name="codeBlock">{fence}</kubb-source>
+}
+
+CodeBlock.displayName = 'CodeBlock'

package/src/components/Const.tsx

@@ -15,26 +15,26 @@ type ConstProps = {
    * - `false` generates `const name = …`
    * @default false
    */
-  export?: boolean
+  export?: boolean | null
   /**
    * TypeScript type annotation for the constant, written verbatim after `const name:`.
    *
    * @example
    * `type: 'Pet'` → `const pet: Pet = …`
    */
-  type?: string
+  type?: string | null
   /**
    * JSDoc block to prepend to the constant declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc
+  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
+  asConst?: boolean | null
   /**
    * Child nodes rendered as the initialiser expression of the constant.
    */

package/src/components/File.tsx

@@ -27,7 +27,7 @@ type BasePropsWithoutBaseName = {
    * Fully qualified path to the generated file.
    * Optional when `baseName` is omitted — the component renders its children inline.
    */
-  path?: string
+  path?: string | null
 }
 
 type BaseProps = BasePropsWithBaseName | BasePropsWithoutBaseName
@@ -38,15 +38,17 @@ type Props<TMeta> = BaseProps & {
    * Arbitrary metadata attached to the file node.
    * Used by plugins for barrel generation and custom post-processing.
    */
-  meta?: TMeta
+  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
+  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
+  footer?: string | null
   /**
    * Child nodes rendered as the content of this file (source blocks, imports, exports).
    */