@kubb/core 5.0.0-beta.7 → 5.0.0-beta.70

package/src/defineGenerator.ts

@@ -1,87 +0,0 @@
-import type { PossiblePromise } from '@internals/utils'
-import type { FileNode, OperationNode, SchemaNode } from '@kubb/ast'
-import type { RendererFactory } from './createRenderer.ts'
-import type { GeneratorContext, PluginFactoryOptions } from './types.ts'
-
-export type { GeneratorContext } from './types.ts'
-
-/**
- * Declares a named generator unit that walks the AST and emits files.
- *
- * Each method (`schema`, `operation`, `operations`) is called for the matching node type.
- * Each method returns `TElement | Array<FileNode> | void`. JSX-based generators require a `renderer` factory.
- * Return `Array<FileNode>` directly or call `ctx.upsertFile()` manually and return `void` to bypass rendering.
- *
- * @note Generators are consumed by plugins and registered via `ctx.addGenerator()` in `kubb:plugin:setup`.
- *
- * @example
- * ```ts
- * import { defineGenerator } from '@kubb/core'
- * import { jsxRenderer } from '@kubb/renderer-jsx'
- *
- * export const typeGenerator = defineGenerator({
- *   name: 'typescript',
- *   renderer: jsxRenderer,
- *   schema(node, ctx) {
- *     const { adapter, resolver, root, options } = ctx
- *     return <File ...><Type node={node} resolver={resolver} /></File>
- *   },
- * })
- * ```
- */
-export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown> = {
-  /**
-   * Used in diagnostic messages and debug output.
-   */
-  name: string
-  /**
-   * Optional renderer factory that produces a {@link Renderer} for each render cycle.
-   *
-   * Generators that return renderer elements (e.g. JSX via `@kubb/renderer-jsx`) must set this
-   * to the matching renderer factory (e.g. `jsxRenderer` from `@kubb/renderer-jsx`).
-   *
-   * Generators that only return `Array<FileNode>` or `void` do not need to set this.
-   *
-   * Set `renderer: null` to explicitly opt out of rendering even when the parent plugin
-   * declares a `renderer` (overrides the plugin-level fallback).
-   *
-   * @example
-   * ```ts
-   * import { jsxRenderer } from '@kubb/renderer-jsx'
-   * export const myGenerator = defineGenerator<PluginTs>({
-   *   renderer: jsxRenderer,
-   *   schema(node, ctx) { return <File ...>...</File> },
-   * })
-   * ```
-   */
-  renderer?: RendererFactory<TElement> | null
-  /**
-   * Called for each schema node in the AST walk.
-   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
-   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
-   */
-  schema?: (node: SchemaNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
-  /**
-   * Called for each operation node in the AST walk.
-   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
-   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
-   */
-  operation?: (node: OperationNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
-  /**
-   * Called once after all operations have been walked.
-   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
-   * plus `ctx.options` with the plugin-level options for the batch call.
-   */
-  operations?: (nodes: Array<OperationNode>, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
-}
-
-/**
- * Defines a generator. Returns the object as-is with correct `this` typings.
- * `applyHookResult` handles renderer elements and `File[]` uniformly using
- * the generator's declared `renderer` factory.
- */
-export function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown>(
-  generator: Generator<TOptions, TElement>,
-): Generator<TOptions, TElement> {
-  return generator
-}

package/src/defineLogger.ts

@@ -1,36 +0,0 @@
-import type { Logger, LoggerOptions, UserLogger } from './types.ts'
-
-/**
- * Wraps a logger definition into a typed {@link Logger}.
- *
- * The optional second type parameter `TInstallReturn` allows loggers to return
- * a value from `install` — for example, a sink factory that the caller can
- * forward to hook execution.
- *
- * @example Basic logger
- * ```ts
- * export const myLogger = defineLogger({
- *   name: 'my-logger',
- *   install(context, options) {
- *     context.on('kubb:info', (message) => console.log('ℹ', message))
- *     context.on('kubb:error', (error) => console.error('✗', error.message))
- *   },
- * })
- * ```
- *
- * @example Logger that returns a hook sink factory
- * ```ts
- * export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
- *   name: 'my-logger',
- *   install(context, options) {
- *     // … register event handlers …
- *     return (commandWithArgs) => ({ onStdout: console.log })
- *   },
- * })
- * ```
- */
-export function defineLogger<Options extends LoggerOptions = LoggerOptions, TInstallReturn = void>(
-  logger: UserLogger<Options, TInstallReturn>,
-): Logger<Options, TInstallReturn> {
-  return logger
-}

package/src/defineMiddleware.ts

@@ -1,62 +0,0 @@
-import type { KubbHooks } from './Kubb.ts'
-
-/**
- * A middleware instance produced by calling a factory created with `defineMiddleware`.
- * It declares event handlers under a `hooks` object which are registered on the
- * shared emitter after all plugin hooks, so middleware handlers for any event
- * always fire last.
- */
-export type Middleware = {
-  /**
-   * Unique identifier for this middleware.
-   */
-  name: string
-  /**
-   * Lifecycle event handlers for this middleware.
-   * Any event from the global `KubbHooks` map can be subscribed to here.
-   * Handlers are registered after all plugin handlers, so they always fire last.
-   */
-  hooks: {
-    [K in keyof KubbHooks]?: (...args: KubbHooks[K]) => void | Promise<void>
-  }
-}
-
-/**
- * Creates a middleware factory using the hook-style `hooks` API.
- *
- * Middleware handlers fire after all plugin handlers for any given event, making them ideal for post-processing, logging, and auditing.
- * Per-build state (such as accumulators) belongs inside the factory closure so each `createKubb` invocation gets its own isolated instance.
- *
- * @note The factory can accept typed options. See examples for using options and per-build state patterns.
- *
- * @example
- * ```ts
- * import { defineMiddleware } from '@kubb/core'
- *
- * // Stateless middleware
- * export const logMiddleware = defineMiddleware(() => ({
- *   name: 'log-middleware',
- *   hooks: {
- *     'kubb:build:end'({ files }) {
- *       console.log(`Build complete with ${files.length} files`)
- *     },
- *   },
- * }))
- *
- * // Middleware with options and per-build state
- * export const prefixMiddleware = defineMiddleware((options: { prefix: string } = { prefix: '' }) => {
- *   const seen = new Set<string>()
- *   return {
- *     name: 'prefix-middleware',
- *     hooks: {
- *       'kubb:plugin:end'({ plugin }) {
- *         seen.add(`${options.prefix}${plugin.name}`)
- *       },
- *     },
- *   }
- * })
- * ```
- */
-export function defineMiddleware<TOptions extends object = object>(factory: (options: TOptions) => Middleware): (options?: TOptions) => Middleware {
-  return (options) => factory(options ?? ({} as TOptions))
-}

package/src/defineParser.ts

@@ -1,44 +0,0 @@
-import type { FileNode } from '@kubb/ast'
-
-type PrintOptions = {
-  extname?: FileNode['extname']
-}
-
-export type Parser<TMeta extends object = any> = {
-  name: string
-  /**
-   * File extensions this parser handles.
-   * Use `undefined` to create a catch-all fallback parser.
-   *
-   * @example Handled extensions
-   * `['.ts', '.js']`
-   */
-  extNames: Array<FileNode['extname']> | undefined
-  /**
-   * Convert a resolved file to a string.
-   */
-  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string
-}
-
-/**
- * Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
- *
- * @note Call the returned factory with optional options to instantiate the parser.
- *
- * @example
- * ```ts
- * import { defineParser } from '@kubb/core'
- *
- * export const jsonParser = defineParser({
- *   name: 'json',
- *   extNames: ['.json'],
- *   parse(file) {
- *     const { extractStringsFromNodes } = await import('@kubb/ast')
- *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
- *   },
- * })
- * ```
- */
-export function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta> {
-  return parser
-}

package/src/definePlugin.ts

@@ -1,83 +0,0 @@
-import type { KubbHooks } from './Kubb.ts'
-import type { KubbPluginSetupContext, PluginFactoryOptions } from './types.ts'
-
-/**
- * A plugin object produced by `definePlugin`.
- * Instead of flat lifecycle methods, it groups all handlers under a `hooks:` property
- * (matching Astro's integration naming convention).
- *
- * @template TFactory - The plugin's `PluginFactoryOptions` type.
- */
-export type Plugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /**
-   * Unique name for the plugin, following the same naming convention as `createPlugin`.
-   */
-  name: string
-  /**
-   * Plugins that must be registered before this plugin executes.
-   * An error is thrown at startup when any listed dependency is missing.
-   */
-  dependencies?: Array<string>
-  /**
-   * Controls the execution order of this plugin relative to others.
-   *
-   * - `'pre'`  — runs before all normal plugins.
-   * - `'post'` — runs after all normal plugins.
-   * - `undefined` (default) — runs in declaration order among normal plugins.
-   *
-   * Dependency constraints always take precedence over `enforce`.
-   */
-  enforce?: 'pre' | 'post'
-  /**
-   * The options passed by the user when calling the plugin factory.
-   */
-  options?: TFactory['options']
-  /**
-   * Lifecycle event handlers for this plugin.
-   * Any event from the global `KubbHooks` map can be subscribed to here.
-   */
-  hooks: {
-    [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void>
-  } & {
-    'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>
-  }
-}
-
-/**
- * Returns `true` when `plugin` is a hook-style plugin created with `definePlugin`.
- *
- * Used by `PluginDriver` to distinguish hook-style plugins from legacy `createPlugin` plugins
- * so it can normalize them and register their handlers on the `AsyncEventEmitter`.
- */
-export function isPlugin(plugin: unknown): plugin is Plugin {
-  return typeof plugin === 'object' && plugin !== null && 'hooks' in plugin
-}
-
-/**
- * Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
- *
- * Handlers live in a single `hooks` object (inspired by Astro integrations).
- * All lifecycle events from `KubbHooks` are available for subscription.
- *
- * @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
- * Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
- *
- * @example
- * ```ts
- * import { definePlugin } from '@kubb/core'
- *
- * export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
- *   name: 'plugin-ts',
- *   hooks: {
- *     'kubb:plugin:setup'(ctx) {
- *       ctx.setResolver(resolverTs)
- *     },
- *   },
- * }))
- * ```
- */
-export function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(
-  factory: (options: TFactory['options']) => Plugin<TFactory>,
-): (options?: TFactory['options']) => Plugin<TFactory> {
-  return (options) => factory(options ?? ({} as TFactory['options']))
-}