@kubb/core 5.0.0-alpha.32 → 5.0.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.32",
+  "version": "5.0.0-alpha.34",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -64,13 +64,13 @@
     }
   ],
   "dependencies": {
-    "@kubb/react-fabric": "0.15.1",
     "empathic": "^2.0.0",
     "fflate": "^0.8.2",
     "remeda": "^2.33.7",
     "semver": "^7.7.4",
-    "tinyexec": "^1.0.4",
-    "@kubb/ast": "5.0.0-alpha.32"
+    "tinyexec": "^1.1.1",
+    "@kubb/ast": "5.0.0-alpha.34",
+    "@kubb/renderer-jsx": "5.0.0-alpha.34"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
@@ -78,7 +78,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/react-fabric": "0.14.0"
+    "@kubb/renderer-jsx": "5.0.0-alpha.34"
   },
   "engines": {
     "node": ">=22"

package/src/FileProcessor.ts

@@ -1,4 +1,5 @@
-import type { FileNode } from '@kubb/ast/types'
+import { extractStringsFromNodes } from '@kubb/ast'
+import type { CodeNode, FileNode } from '@kubb/ast/types'
 import pLimit from 'p-limit'
 import { PARALLEL_CONCURRENCY_LIMIT } from './constants.ts'
 import type { Parser } from './defineParser.ts'
@@ -20,8 +21,8 @@ type RunOptions = ParseOptions & {
 
 function joinSources(file: FileNode): string {
   return file.sources
-    .map((item) => item.value)
-    .filter((value): value is string => value != null)
+    .map((item) => extractStringsFromNodes(item.nodes as Array<CodeNode>))
+    .filter(Boolean)
     .join('\n\n')
 }
 

package/src/Kubb.ts

@@ -188,7 +188,7 @@ export interface KubbEvents {
        */
       file: FileNode
       /**
-       * Kubb configuration (not present in Fabric).
+       * Kubb configuration
        * Provides access to the current config during file processing.
        */
       config: Config

package/src/build.ts

@@ -56,7 +56,6 @@ type SetupResult = {
  *
  * - Validates the input path (when applicable).
  * - Applies config defaults (`root`, `output.*`, `devtools`).
- * - Creates the Fabric instance and wires storage, format, and lint hooks.
  * - Runs the adapter (if configured) to produce the universal `InputNode`.
  *   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
  *

package/src/defineGenerator.ts

@@ -1,6 +1,6 @@
 import type { PossiblePromise } from '@internals/utils'
 import type { FileNode, OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import { applyHookResult } from './renderNode.tsx'
 import type { GeneratorContext, PluginFactoryOptions } from './types.ts'
 
@@ -38,11 +38,7 @@ export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
    * `options` contains the per-node resolved options (after exclude/include/override).
    */
-  schema?: (
-    this: GeneratorContext<TOptions>,
-    node: SchemaNode,
-    options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+  schema?: (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
   /**
    * Called for each operation node in the AST walk.
    * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
@@ -51,7 +47,7 @@ export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptio
     this: GeneratorContext<TOptions>,
     node: OperationNode,
     options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+  ) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
   /**
    * Called once after all operations have been walked.
    * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
@@ -60,7 +56,7 @@ export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptio
     this: GeneratorContext<TOptions>,
     nodes: Array<OperationNode>,
     options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+  ) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
 }
 
 /**

package/src/defineParser.ts

@@ -6,7 +6,6 @@ type PrintOptions = {
 
 export type Parser<TMeta extends object = any> = {
   name: string
-  type: 'parser'
   /**
    * File extensions this parser handles.
    * Use `undefined` to create a catch-all fallback parser.
@@ -14,21 +13,12 @@ export type Parser<TMeta extends object = any> = {
    * @example ['.ts', '.js']
    */
   extNames: Array<FileNode['extname']> | undefined
-  /**
-   * @deprecated Will be removed once Fabric no longer requires it.
-   * @default () => {}
-   */
-  install(...args: unknown[]): void | Promise<void>
   /**
    * Convert a resolved file to a string.
    */
   parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string
 }
 
-export type UserParser<TMeta extends object = any> = Omit<Parser<TMeta>, 'type' | 'install'> & {
-  install?(...args: unknown[]): void | Promise<void>
-}
-
 /**
  * Defines a parser with type safety.
  *
@@ -43,15 +33,12 @@ export type UserParser<TMeta extends object = any> = Omit<Parser<TMeta>, 'type'
  *   name: 'json',
  *   extNames: ['.json'],
  *   parse(file) {
- *     return file.sources.map((s) => s.value).join('\n')
+ *     const { extractStringsFromNodes } = await import('@kubb/ast')
+ *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
  *   },
  * })
  * ```
  */
-export function defineParser<TMeta extends object = any>(parser: UserParser<TMeta>): Parser<TMeta> {
-  return {
-    install() {},
-    type: 'parser',
-    ...parser,
-  }
+export function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta> {
+  return parser
 }

package/src/hooks/useDriver.ts

@@ -1,11 +1,9 @@
-import { useFabric } from '@kubb/react-fabric'
+import { inject, KubbContext } from '@kubb/renderer-jsx'
 import type { PluginDriver } from '../PluginDriver.ts'
 
 /**
  * @deprecated use `driver` from the generator component props instead
  */
 export function useDriver(): PluginDriver {
-  const { meta } = useFabric<{ driver: PluginDriver }>()
-
-  return meta.driver
+  return inject(KubbContext)!.driver as PluginDriver
 }

package/src/hooks/useMode.ts

@@ -1,10 +1,8 @@
-import { useFabric } from '@kubb/react-fabric'
+import { inject, KubbContext } from '@kubb/renderer-jsx'
 
 /**
  * @deprecated use `mode` from the generator component props instead
  */
 export function useMode(): 'single' | 'split' {
-  const { meta } = useFabric<{ mode: 'single' | 'split' }>()
-
-  return meta.mode
+  return inject(KubbContext)!.mode
 }

package/src/hooks/usePlugin.ts

@@ -1,11 +1,9 @@
-import { useFabric } from '@kubb/react-fabric'
+import { inject, KubbContext } from '@kubb/renderer-jsx'
 import type { Plugin, PluginFactoryOptions } from '../types.ts'
 
 /**
  * @deprecated use `plugin` from the generator component props instead
  */
 export function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {
-  const { meta } = useFabric<{ plugin: Plugin<TOptions> }>()
-
-  return meta.plugin
+  return inject(KubbContext)!.plugin as Plugin<TOptions>
 }

package/src/index.ts

@@ -23,10 +23,12 @@ export { getMode, PluginDriver } from './PluginDriver.ts'
 export { fsStorage } from './storages/fsStorage.ts'
 export { memoryStorage } from './storages/memoryStorage.ts'
 export * from './types.ts'
-export { FunctionParams } from './utils/FunctionParams.ts'
+export type { FunctionParamsAST } from './utils/FunctionParams.ts'
 export { detectFormatter } from './utils/formatters.ts'
 export { getBarrelFiles } from './utils/getBarrelFiles.ts'
 export { getConfigs } from './utils/getConfigs.ts'
+export type { Param, Params } from './utils/getFunctionParams.ts'
+export { createFunctionParams, FunctionParams, getFunctionParams } from './utils/getFunctionParams.ts'
 export { getPreset } from './utils/getPreset.ts'
 export { isInputPath } from './utils/isInputPath.ts'
 export { detectLinter } from './utils/linters.ts'

package/src/renderNode.tsx

@@ -1,16 +1,16 @@
 import type { FileNode } from '@kubb/ast/types'
-import { createReactFabric, Fabric } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { createRenderer } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginDriver } from './PluginDriver.ts'
 
 /**
  * Handles the return value of a plugin AST hook or generator method.
  *
- * - React element → rendered via an isolated react-fabric context, files stored in `driver.fileManager`
+ * - React element → rendered via renderer-jsx, files stored in `driver.fileManager`
  * - `Array<FileNode>` → upserted directly into `driver.fileManager`
  * - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
  */
-export async function applyHookResult(result: FabricReactNode | Array<FileNode> | void, driver: PluginDriver): Promise<void> {
+export async function applyHookResult(result: KubbReactNode | Array<FileNode> | void, driver: PluginDriver): Promise<void> {
   if (!result) return
 
   if (Array.isArray(result)) {
@@ -18,9 +18,11 @@ export async function applyHookResult(result: FabricReactNode | Array<FileNode>
     return
   }
 
-  // Non-array truthy result is treated as a React element (FabricReactNode)
-  const fabricChild = createReactFabric()
-  await fabricChild.render(<Fabric>{result as FabricReactNode}</Fabric>)
-  driver.fileManager.upsert(...(fabricChild.files as unknown as Array<FileNode>))
-  fabricChild.unmount()
+  const renderer = createRenderer()
+
+  // biome-ignore lint/complexity/noUselessFragments: not needed
+  await renderer.render(<>{result as KubbReactNode}</>)
+
+  driver.fileManager.upsert(...renderer.files)
+  renderer.unmount()
 }

package/src/types.ts

@@ -1,7 +1,7 @@
 import type { AsyncEventEmitter, PossiblePromise } from '@internals/utils'
 import type { FileNode, ImportNode, InputNode, Node, OperationNode, Printer, SchemaNode, Visitor } from '@kubb/ast/types'
 import type { HttpMethod } from '@kubb/oas'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { DEFAULT_STUDIO_URL, logLevel } from './constants.ts'
 import type { Storage } from './createStorage.ts'
 import type { Generator } from './defineGenerator.ts'
@@ -56,9 +56,9 @@ export type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins'
    *
    * A catch-all fallback parser is always appended last for any unhandled extension.
    *
-   * When omitted, `parserTs` from `@kubb/parser-ts` is used automatically as the
+   * When omitted, `parserTsx` from `@kubb/parser-ts` is used automatically as the
    * default (requires `@kubb/parser-ts` to be installed as an optional dependency).
-   * @default [parserTs] — from `@kubb/parser-ts`
+   * @default [parserTsx] — from `@kubb/parser-ts`
    * @example
    * ```ts
    * import { parserTs, tsxParser } from '@kubb/parser-ts'
@@ -525,7 +525,7 @@ export type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOpti
   this: GeneratorContext<TOptions>,
   node: SchemaNode,
   options: TOptions['resolvedOptions'],
-) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
 
 /**
  * Handler for a single operation node. Used by the `operation` hook on a plugin.
@@ -534,7 +534,7 @@ export type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryO
   this: GeneratorContext<TOptions>,
   node: OperationNode,
   options: TOptions['resolvedOptions'],
-) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
 
 /**
  * Handler for all collected operation nodes. Used by the `operations` hook on a plugin.
@@ -543,7 +543,7 @@ export type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactory
   this: GeneratorContext<TOptions>,
   nodes: Array<OperationNode>,
   options: TOptions['resolvedOptions'],
-) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
+) => PossiblePromise<KubbReactNode | Array<FileNode> | void>
 
 export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
@@ -879,7 +879,7 @@ export type LoggerOptions = {
 }
 
 /**
- * Shared context passed to all plugins, parsers, and Fabric internals.
+ * Shared context passed to all plugins, parsers, and other internals.
  */
 export type LoggerContext = AsyncEventEmitter<KubbEvents>
 
@@ -1091,6 +1091,6 @@ export type ResolveBannerContext = {
 }
 
 export type { CLIOptions, ConfigInput } from './defineConfig.ts'
-export type { Parser, UserParser } from './defineParser.ts'
+export type { Parser } from './defineParser.ts'
 export type { FunctionParamsAST } from './utils/FunctionParams.ts'
 export type { FileMetaBase } from './utils/getBarrelFiles.ts'

package/src/utils/getBarrelFiles.ts

@@ -80,8 +80,6 @@ function getBarrelFilesByRoot(root: string | undefined, files: Array<FileNode>):
           createSource({
             name: source.name,
             isTypeOnly: source.isTypeOnly,
-            //TODO use parser to generate import
-            value: '',
             isExportable: false,
             isIndexable: false,
           }),

package/src/utils/getFunctionParams.ts

@@ -0,0 +1,247 @@
+import { sortBy } from 'remeda'
+
+export type Param = {
+  /**
+   * `object` will return the pathParams as an object.
+   *
+   * `inline` will return the pathParams as comma separated params.
+   * @default `'inline'`
+   * @private
+   */
+  mode?: 'object' | 'inline' | 'inlineSpread'
+  type?: 'string' | 'number' | (string & {})
+  optional?: boolean
+  /**
+   * @example test = "default"
+   */
+  default?: string
+  /**
+   * Used for no TypeScript(with mode object)
+   * @example test: "default"
+   */
+  value?: string
+  children?: Params
+}
+
+type ParamItem =
+  | (Pick<Param, 'mode' | 'type' | 'value'> & {
+      optional?: true
+      default?: never
+      children?: Params
+    })
+  | (Pick<Param, 'mode' | 'type' | 'value'> & {
+      optional?: false
+      default?: string
+      children?: Params
+    })
+
+export type Params = Record<string, Param | undefined>
+
+type Options = {
+  type: 'constructor' | 'call' | 'object' | 'objectValue'
+  transformName?: (name: string) => string
+  transformType?: (type: string) => string
+}
+
+function order(items: Array<[key: string, item?: ParamItem]>) {
+  return sortBy(items.filter(Boolean) as Array<[key: string, item?: ParamItem]>, ([_key, item]) => {
+    if (item?.children) {
+      return 0 // Treat items with children as required (they'll get = {} if all children are optional)
+    }
+    // Priority order: required (0) → optional (1) → default-only (2)
+    if (item?.optional) {
+      return 1 // Optional parameters (with or without default)
+    }
+    if (item?.default) {
+      // Parameters with default only (not marked as optional)
+      // Note: While the ParamItem type suggests optional and default are mutually exclusive,
+      // this handles the case where a parameter has a default value but isn't explicitly marked as optional
+      return 2
+    }
+    return 0 // Required parameters
+  })
+}
+
+function parseChild(key: string, item: ParamItem, options: Options): string | null {
+  // @ts-expect-error
+  const entries = order(Object.entries(item.children))
+
+  const types: string[] = []
+  const names: string[] = []
+
+  const optional = entries.every(([_key, item]) => item?.optional || !!item?.default)
+
+  entries.forEach(([key, entryItem]) => {
+    if (entryItem) {
+      const name = parseItem(key, { ...entryItem, type: undefined }, options)
+      if (entryItem.children) {
+        const subTypes = Object.entries(entryItem.children)
+          .map(([key]) => {
+            return key
+          })
+          .join(', ')
+
+        if (subTypes) {
+          names.push(`${name}: { ${subTypes} }`)
+        } else {
+          names.push(name)
+        }
+      } else {
+        if (options.type === 'call' && options.transformName) {
+          names.push(`${key}: ${name}`)
+        } else {
+          names.push(name)
+        }
+      }
+
+      if (entries.some(([_key, item]) => item?.type)) {
+        types.push(parseItem(key, { ...entryItem, default: undefined }, options))
+      }
+    }
+  })
+
+  const name = item.mode === 'inline' ? key : names.length ? `{ ${names.join(', ')} }` : undefined
+  const type = item.type ? item.type : types.length ? `{ ${types.join('; ')} }` : undefined
+
+  if (!name) {
+    return null
+  }
+
+  return parseItem(
+    name,
+    {
+      type,
+      default: item.default,
+      optional: !item.default ? optional : undefined,
+    } as ParamItem,
+    options,
+  )
+}
+
+function parseItem(name: string, item: ParamItem, options: Options): string {
+  const acc: string[] = []
+  const transformedName = options.transformName ? options.transformName(name) : name
+  const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type
+
+  if (options.type === 'object') {
+    return transformedName
+  }
+
+  if (options.type === 'objectValue') {
+    return item.value ? `${transformedName}: ${item.value}` : transformedName
+  }
+
+  //LEGACY
+  if (item.type && options.type === 'constructor') {
+    if (item.optional) {
+      // Check if this is a destructured parameter (object mode)
+      const isDestructured = transformedName.startsWith('{')
+      if (isDestructured) {
+        // For destructured parameters, use ": type = {}" syntax to make it optional
+        acc.push(`${transformedName}: ${transformedType} = {}`)
+      } else {
+        // For inline parameters, use "?: type" syntax
+        acc.push(`${transformedName}?: ${transformedType}`)
+      }
+    } else {
+      acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ''}`)
+    }
+  } else if (item.default && options.type === 'constructor') {
+    acc.push(`${transformedName} = ${item.default}`)
+  } else if (item.value) {
+    acc.push(`${transformedName} : ${item.value}`)
+  } else if (item.mode === 'inlineSpread') {
+    acc.push(`... ${transformedName}`)
+  } else {
+    acc.push(transformedName)
+  }
+
+  return acc[0] as string
+}
+
+export function getFunctionParams(params: Params, options: Options): string {
+  const entries = order(Object.entries(params as Record<string, ParamItem | undefined>))
+
+  return entries
+    .reduce((acc, [key, item]) => {
+      if (!item) {
+        return acc
+      }
+
+      if (item.children) {
+        if (Object.keys(item.children).length === 0) {
+          return acc
+        }
+
+        if (item.mode === 'inlineSpread') {
+          return [...acc, getFunctionParams(item.children, options)]
+        }
+
+        const parsedItem = parseChild(key, item, options)
+        if (!parsedItem) {
+          return acc
+        }
+
+        return [...acc, parsedItem]
+      }
+
+      const parsedItem = parseItem(key, item, options)
+
+      return [...acc, parsedItem]
+    }, [] as string[])
+    .join(', ')
+}
+
+/**
+ * @deprecated use @kubb/ast
+ */
+export function createFunctionParams(params: Params): Params {
+  return params
+}
+
+/**
+ * @deprecated use @kubb/ast
+ */
+export class FunctionParams {
+  #params: Params
+
+  static factory(params: Params) {
+    return new FunctionParams(params)
+  }
+  constructor(params: Params) {
+    this.#params = params
+  }
+
+  get params(): Params {
+    return this.#params
+  }
+
+  get flatParams(): Params {
+    const flatter = (acc: Params, [key, item]: [key: string, item?: Param]): Params => {
+      if (item?.children) {
+        return Object.entries(item.children).reduce(flatter, acc)
+      }
+      if (item) {
+        acc[key] = item
+      }
+
+      return acc
+    }
+    return Object.entries(this.#params).reduce(flatter, {} as Params)
+  }
+
+  toCall({ transformName, transformType }: Pick<Options, 'transformName' | 'transformType'> = {}): string {
+    return getFunctionParams(this.#params, { type: 'call', transformName, transformType })
+  }
+
+  toObject(): string {
+    return getFunctionParams(this.#params, { type: 'object' })
+  }
+  toObjectValue(): string {
+    return getFunctionParams(this.#params, { type: 'objectValue' })
+  }
+
+  toConstructor(): string {
+    return getFunctionParams(this.#params, { type: 'constructor' })
+  }
+}