@kubb/renderer-jsx 5.0.0-alpha.34 → 5.0.0-alpha.36

package/src/utils.ts

@@ -1,12 +1,25 @@
-import { createArrowFunction, createBreak, createConst, createFunction, createJsx, createSource, createText, createType } from '@kubb/ast'
-import type { ArrowFunctionNode, CodeNode, ExportNode, FileNode, ImportNode, JSDocNode, SourceNode } from '@kubb/ast/types'
-import { nodeNames } from './dom.ts'
+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 strings; nested kubb-function/const/type children
- * become their respective {@link CodeNode}s. Other DOM elements are skipped.
+ *
+ * `#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> = []
@@ -16,7 +29,7 @@ function collectChildNodes(element: DOMElement): Array<CodeNode> {
       continue
     }
 
-    if (child.nodeName === '#text') {
+    if (child.nodeName === TEXT_NODE_NAME) {
       const text = (child as DOMNode<{ nodeName: '#text' }>).nodeValue
       if (text && text.trim().length > 0) {
         result.push(createText(text))
@@ -84,7 +97,7 @@ function collectChildNodes(element: DOMElement): Array<CodeNode> {
       )
     } else if (child.nodeName === 'kubb-jsx') {
       const textChild = child.childNodes[0]
-      const value = textChild?.nodeName === '#text' ? (textChild as DOMNode<{ nodeName: '#text' }>).nodeValue : ''
+      const value = textChild?.nodeName === TEXT_NODE_NAME ? (textChild as DOMNode<{ nodeName: '#text' }>).nodeValue : ''
       if (value) {
         result.push(createJsx(value))
       }
@@ -94,7 +107,18 @@ function collectChildNodes(element: DOMElement): Array<CodeNode> {
   return result
 }
 
-export function squashSourceNodes(node: DOMElement, ignores: Array<ElementNames>): Set<SourceNode> {
+/**
+ * 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>()
 
@@ -104,99 +128,24 @@ export function squashSourceNodes(node: DOMElement, ignores: Array<ElementNames>
         continue
       }
 
-      if (child.nodeName !== '#text' && ignoreSet.has(child.nodeName)) {
+      if (child.nodeName !== TEXT_NODE_NAME && ignoreSet.has(child.nodeName)) {
         continue
       }
 
       if (child.nodeName === 'kubb-source') {
-        // Collect children in DOM order: text strings and kubb-* elements interleaved
-        const orderedNodes: Array<CodeNode> = []
-        for (const c of child.childNodes) {
-          if (!c) continue
-
-          if (c.nodeName === '#text') {
-            const text = (c as DOMNode<{ nodeName: '#text' }>).nodeValue
-            if (text && text.trim().length > 0) {
-              orderedNodes.push(createText(text))
-            }
-          } else if (c.nodeName === 'br') {
-            orderedNodes.push(createBreak())
-          } else if (c.nodeName === 'kubb-function') {
-            const attrs = c.attributes
-            orderedNodes.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(c),
-              }),
-            )
-          } else if (c.nodeName === 'kubb-arrow-function') {
-            const attrs = c.attributes
-            orderedNodes.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(c),
-              } as Omit<ArrowFunctionNode, 'kind'>),
-            )
-          } else if (c.nodeName === 'kubb-const') {
-            const attrs = c.attributes
-            orderedNodes.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(c),
-              }),
-            )
-          } else if (c.nodeName === 'kubb-type') {
-            const attrs = c.attributes
-            orderedNodes.push(
-              createType({
-                name: attrs.get('name') as string,
-                export: attrs.get('export') as boolean | undefined,
-                JSDoc: attrs.get('JSDoc') as JSDocNode | undefined,
-                nodes: collectChildNodes(c),
-              }),
-            )
-          } else if (c.nodeName === 'kubb-jsx') {
-            const textChild = c.childNodes[0]
-            const value = textChild?.nodeName === '#text' ? (textChild as DOMNode<{ nodeName: '#text' }>).nodeValue : ''
-            if (value) {
-              orderedNodes.push(createJsx(value))
-            }
-          }
-        }
-
         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: orderedNodes,
-          // value is no longer set separately — all content is in nodes
+          nodes: collectChildNodes(child),
         })
 
         sources.add(source)
         continue
       }
 
-      if (child.nodeName !== '#text' && nodeNames.has(child.nodeName)) {
+      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
         walk(child)
       }
     }
@@ -206,7 +155,10 @@ export function squashSourceNodes(node: DOMElement, ignores: Array<ElementNames>
   return sources
 }
 
-export function squashExportNodes(node: DOMElement): Set<ExportNode> {
+/**
+ * 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 => {
@@ -215,17 +167,19 @@ export function squashExportNodes(node: DOMElement): Set<ExportNode> {
         continue
       }
 
-      if (child.nodeName !== '#text' && nodeNames.has(child.nodeName)) {
+      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
         walk(child)
       }
 
       if (child.nodeName === 'kubb-export') {
-        exports.add({
-          name: child.attributes.get('name'),
-          path: child.attributes.get('path'),
-          isTypeOnly: child.attributes.get('isTypeOnly') ?? false,
-          asAlias: child.attributes.get('asAlias') ?? false,
-        } as ExportNode)
+        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,
+          }),
+        )
       }
     }
   }
@@ -234,7 +188,10 @@ export function squashExportNodes(node: DOMElement): Set<ExportNode> {
   return exports
 }
 
-export function squashImportNodes(node: DOMElement): Set<ImportNode> {
+/**
+ * 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 => {
@@ -243,18 +200,20 @@ export function squashImportNodes(node: DOMElement): Set<ImportNode> {
         continue
       }
 
-      if (child.nodeName !== '#text' && nodeNames.has(child.nodeName)) {
+      if (child.nodeName !== TEXT_NODE_NAME && nodeNames.has(child.nodeName)) {
         walk(child)
       }
 
       if (child.nodeName === 'kubb-import') {
-        imports.add({
-          name: child.attributes.get('name'),
-          path: child.attributes.get('path'),
-          root: child.attributes.get('root'),
-          isTypeOnly: child.attributes.get('isTypeOnly') ?? false,
-          isNameSpace: child.attributes.get('isNameSpace') ?? false,
-        } as ImportNode)
+        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,
+          }),
+        )
       }
     }
   }
@@ -263,17 +222,24 @@ export function squashImportNodes(node: DOMElement): Set<ImportNode> {
   return imports
 }
 
-export async function processFiles(node: DOMElement): Promise<Array<FileNode>> {
+/**
+ * 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> = []
 
-  async function walk(current: DOMElement) {
+  function walk(current: DOMElement) {
     for (const child of current.childNodes) {
       if (!child) {
         continue
       }
 
-      if (child.nodeName !== '#text' && child.nodeName !== 'kubb-file' && nodeNames.has(child.nodeName)) {
-        await walk(child)
+      if (child.nodeName !== TEXT_NODE_NAME && child.nodeName !== 'kubb-file' && nodeNames.has(child.nodeName)) {
+        walk(child)
       }
 
       if (child.nodeName === 'kubb-file') {
@@ -295,7 +261,7 @@ export async function processFiles(node: DOMElement): Promise<Array<FileNode>> {
     }
   }
 
-  await walk(node)
+  walk(node)
 
   return collected
 }

package/dist/types-C7FD9BLg.d.ts

@@ -1,119 +0,0 @@
-import { n as __name } from "./chunk-CErwXX-a.js";
-import { ArrowFunctionNode, ConstNode, ExportNode, FileNode, FunctionNode, ImportNode, SourceNode, TypeNode } from "@kubb/ast/types";
-import React, { JSX, ReactNode } from "react";
-
-//#region ../../internals/utils/src/context.d.ts
-/**
- * Context type that carries type information about its value
- * This is a branded symbol type that enables type-safe context usage
- */
-type Context<T> = symbol & {
-  readonly __type: T;
-};
-/**
- * Provides a value to descendant components (Vue 3 style)
- *
- * @example
- * ```ts
- * const ThemeKey = Symbol('theme')
- * provide(ThemeKey, { color: 'blue' })
- * ```
- */
-declare function provide<T>(key: symbol | Context<T>, value: T): void;
-/**
- * Injects a value provided by an ancestor component (Vue 3 style)
- *
- * @example
- * ```ts
- * const theme = inject(ThemeKey, { color: 'default' })
- * ```
- */
-declare function inject<T>(key: symbol | Context<T>, defaultValue?: T): T;
-/**
- * Removes a provided value from the context stack (for cleanup)
- * @internal
- */
-declare function unprovide<T>(key: symbol | Context<T>): void;
-/**
- * Creates a context key with a default value (React-style compatibility)
- *
- * @example
- * ```ts
- * const ThemeContext = createContext({ color: 'blue' })
- * // ThemeContext is now typed as Context<{ color: string }>
- * const theme = useContext(ThemeContext) // theme is { color: string }
- * ```
- */
-declare function createContext<T>(defaultValue: T): Context<T>;
-//#endregion
-//#region src/types.d.ts
-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;
-  internal_static?: boolean;
-};
-type DOMNodeAttribute = boolean | string | number | Record<string, unknown>;
-type TextName = '#text';
-type TextNode = {
-  nodeName: TextName;
-  nodeValue: string;
-} & Node;
-type DOMNode<T = {
-  nodeName: NodeNames;
-}> = T extends {
-  nodeName: infer U;
-} ? U extends '#text' ? TextNode : DOMElement : never;
-type OutputTransformer = (s: string, index: number) => string;
-type DOMElement = {
-  nodeName: ElementNames;
-  attributes: Map<string, DOMNodeAttribute>;
-  childNodes: DOMNode[];
-  internal_transform?: OutputTransformer;
-  isStaticDirty?: boolean;
-  staticNode?: DOMElement;
-  onComputeLayout?: () => void;
-  onRender?: () => void;
-  onImmediateRender?: () => void;
-} & Node;
-type NodeNames = ElementNames | TextName;
-type KubbReactNode = ReactNode;
-type KubbReactElement = JSX.Element;
-type KubbJsxProps = {
-  children?: string;
-};
-type KubbTextProps = {
-  children?: KubbReactNode;
-};
-type KubbFileProps = {
-  id?: string;
-  children?: KubbReactNode;
-  baseName: string;
-  path: string;
-  override?: boolean;
-  meta?: FileNode['meta'];
-};
-type KubbSourceProps = Omit<SourceNode, 'kind'> & {
-  children?: KubbReactNode;
-};
-type KubbImportProps = Omit<ImportNode, 'kind'> & {};
-type KubbExportProps = Omit<ExportNode, 'kind'> & {};
-type KubbFunctionProps = Omit<FunctionNode, 'kind'> & {
-  children?: KubbReactNode;
-};
-type KubbArrowFunctionProps = Omit<ArrowFunctionNode, 'kind'> & {
-  children?: KubbReactNode;
-};
-type KubbConstProps = Omit<ConstNode, 'kind'> & {
-  children?: KubbReactNode;
-};
-type KubbTypeProps = Omit<TypeNode, 'kind'> & {
-  children?: KubbReactNode;
-};
-type LineBreakProps = React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
-type JSDoc = {
-  comments: string[];
-};
-//#endregion
-export { inject as C, createContext as S, unprovide as T, 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, provide as w, Context as x, LineBreakProps as y };
-//# sourceMappingURL=types-C7FD9BLg.d.ts.map