@kubb/core 5.0.0-beta.40 → 5.0.0-beta.41

package/dist/mocks.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_memoryStorage = require("./memoryStorage-Dkxnid2K.cjs");
+const require_memoryStorage = require("./memoryStorage-DZqlEW7H.cjs");
 let node_path = require("node:path");
 node_path = require_memoryStorage.__toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");

package/dist/mocks.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
-import { It as Adapter, Lt as AdapterFactoryOptions, V as Generator, W as KubbDriver, Z as NormalizedPlugin, gt as Parser, h as Config, tt as PluginFactoryOptions } from "./diagnostics-DhfW8YpT.js";
+import { G as KubbDriver, H as Generator, Lt as Adapter, Q as NormalizedPlugin, Rt as AdapterFactoryOptions, _t as Parser, h as Config, nt as PluginFactoryOptions } from "./diagnostics-Ba-FcsPo.js";
 import { FileNode, InputMeta, OperationNode, SchemaNode, Visitor } from "@kubb/ast";
 
 //#region src/mocks.d.ts

package/dist/mocks.js

@@ -1,5 +1,5 @@
 import "./chunk-C0LytTxp.js";
-import { a as FileManager, i as FileProcessor, m as camelCase, n as KubbDriver, r as _usingCtx, t as memoryStorage } from "./memoryStorage-DTv1Kub1.js";
+import { a as FileManager, i as FileProcessor, m as camelCase, n as KubbDriver, r as _usingCtx, t as memoryStorage } from "./memoryStorage-DA1bnMte.js";
 import path, { resolve } from "node:path";
 import { transform } from "@kubb/ast";
 import { expect } from "vitest";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-beta.40",
+  "version": "5.0.0-beta.41",
   "description": "Core engine for Kubb's plugin-based code generation system. Provides the plugin driver, file manager, defineConfig, and build orchestration used by every Kubb plugin.",
   "keywords": [
     "code-generator",
@@ -58,14 +58,14 @@
   "dependencies": {
     "fflate": "^0.8.3",
     "tinyexec": "~1.1.2",
-    "@kubb/ast": "5.0.0-beta.40"
+    "@kubb/ast": "5.0.0-beta.41"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0",
-    "@kubb/renderer-jsx": "5.0.0-beta.40"
+    "@kubb/renderer-jsx": "5.0.0-beta.41"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.40"
+    "@kubb/renderer-jsx": "5.0.0-beta.41"
   },
   "size-limit": [
     {

package/src/KubbDriver.ts

@@ -473,6 +473,11 @@ export class KubbDriver {
    * A failing plugin contributes an error diagnostic so the rest of the build continues.
    * Every plugin also contributes a `timing` diagnostic.
    *
+   * Plugins run sequentially so `kubb:plugin:end` fires as each plugin completes, instead
+   * of all at once after every plugin has marched through the parallel batches together.
+   * That ordering is what drives the CLI's `Plugins N/M` counter; without it the bar would
+   * sit at the initial value until the very end of the run.
+   *
    * When `entries` is empty or `this.inputNode` is `null`, every entry still gets a
    * `kubb:plugin:end` so middleware listeners (the barrel writer and friends) complete.
    */
@@ -526,22 +531,27 @@ export class KubbDriver {
 
     const emitsSchemaHook = this.hooks.listenerCount('kubb:generate:schema') > 0
     const emitsOperationHook = this.hooks.listenerCount('kubb:generate:operation') > 0
+    const emitsOperationsHook = this.hooks.listenerCount('kubb:generate:operations') > 0
+
+    // Buffer the streaming adapter's nodes once. Each plugin reads the same buffer
+    // instead of re-parsing the document per pass, and the pruning pre-scan below
+    // shares it too (previously it iterated its own copies).
+    const schemasBuffer: Array<SchemaNode> = []
+    for await (const schema of schemas) schemasBuffer.push(schema)
+    const operationsBuffer: Array<OperationNode> = []
+    for await (const operation of operations) operationsBuffer.push(operation)
 
     // Pre-scan: plugins with operation-based includes (but no schemaName include) need
     // the reachable schema set. This requires the full schema graph in memory at once,
-    // since transitive reachability can't be derived from a single node. `allSchemas` is
-    // released as soon as the pre-scan returns, so the main passes get fresh iterators.
+    // since transitive reachability can't be derived from a single node.
     const pruningStates = states.filter(({ plugin }) => {
       const { include } = plugin.options
       return (include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === 'schemaName') ?? false)
     })
 
     if (pruningStates.length > 0) {
-      const allSchemas: Array<SchemaNode> = []
-      for await (const schema of schemas) allSchemas.push(schema)
-
       const includedOpsByState = new Map<PluginState, Array<OperationNode>>(pruningStates.map((state) => [state, []]))
-      for await (const operation of operations) {
+      for (const operation of operationsBuffer) {
         for (const state of pruningStates) {
           const { exclude, include, override } = state.plugin.options
           const options = state.generatorContext.resolver.resolveOptions(operation, { options: state.plugin.options, exclude, include, override })
@@ -550,7 +560,7 @@ export class KubbDriver {
       }
 
       for (const state of pruningStates) {
-        state.allowedSchemaNames = collectUsedSchemaNames(includedOpsByState.get(state) ?? [], allSchemas)
+        state.allowedSchemaNames = collectUsedSchemaNames(includedOpsByState.get(state) ?? [], schemasBuffer)
         includedOpsByState.delete(state)
       }
     }
@@ -628,30 +638,29 @@ export class KubbDriver {
       emit: emitsOperationHook ? (node: OperationNode, ctx: GeneratorContext) => this.hooks.emit('kubb:generate:operation', node, ctx) : null,
     } as const
 
-    // Skip building the aggregated operations array when nothing consumes it. Saves an
-    // N-sized allocation on the common path where plugins only define per-node `gen.operation`.
-    const needsCollectedOperations =
-      this.hooks.listenerCount('kubb:generate:operations') > 0 || states.some((state) => state.generators.some((gen) => !!gen.operations))
-    const collectedOperations: Array<OperationNode> | undefined = needsCollectedOperations ? [] : undefined
-
-    // Run schemas before operations: the two passes share `flushPending` and the
-    // FileProcessor's event emitter, so running them concurrently would interleave
-    // `kubb:files:processing:start|end` events and race on the shared dirty list.
-    await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, schemaDispatch)))), {
-      concurrency: SCHEMA_PARALLEL,
-      flush: flushPending,
-    })
+    for (const state of states) {
+      // Skip building the aggregated operations array when this plugin doesn't consume it.
+      // Saves an N-sized allocation when the plugin only defines per-node `gen.operation`.
+      const needsCollectedOperations = emitsOperationsHook || state.generators.some((gen) => !!gen.operations)
+      const collectedOperations: Array<OperationNode> | undefined = needsCollectedOperations ? [] : undefined
+
+      // Run schemas before operations: the two passes share `flushPending` and the
+      // FileProcessor's event emitter, so running them concurrently would interleave
+      // `kubb:files:processing:start|end` events and race on the shared dirty list.
+      await forBatches(schemasBuffer, (nodes) => Promise.all(nodes.map((node) => dispatchNode(state, node, schemaDispatch))), {
+        concurrency: SCHEMA_PARALLEL,
+        flush: flushPending,
+      })
 
-    await forBatches(
-      operations,
-      (nodes) => {
-        if (needsCollectedOperations) collectedOperations?.push(...nodes)
-        return Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, operationDispatch))))
-      },
-      { concurrency: SCHEMA_PARALLEL, flush: flushPending },
-    )
+      await forBatches(
+        operationsBuffer,
+        (nodes) => {
+          if (needsCollectedOperations) collectedOperations?.push(...nodes)
+          return Promise.all(nodes.map((node) => dispatchNode(state, node, operationDispatch)))
+        },
+        { concurrency: SCHEMA_PARALLEL, flush: flushPending },
+      )
 
-    for (const state of states) {
       if (!state.failed && needsCollectedOperations) {
         try {
           const { plugin, generatorContext, generators } = state

package/src/createKubb.ts

@@ -464,6 +464,7 @@ export interface KubbHooks {
   'kubb:hooks:start': []
   'kubb:hooks:end': []
   'kubb:hook:start': [ctx: KubbHookStartContext]
+  'kubb:hook:line': [ctx: KubbHookLineContext]
   'kubb:hook:end': [ctx: KubbHookEndContext]
   'kubb:info': [ctx: KubbInfoContext]
   'kubb:error': [ctx: KubbErrorContext]
@@ -718,6 +719,21 @@ export type KubbHookStartContext = {
   args?: ReadonlyArray<string>
 }
 
+/**
+ * Emitted for each line streamed from a hook's stdout while it runs.
+ * A logger correlates the line to its active UI element via `id`.
+ */
+export type KubbHookLineContext = {
+  /**
+   * Identifier matching the corresponding `kubb:hook:start` event.
+   */
+  id: string
+  /**
+   * A single streamed stdout line, without its trailing newline.
+   */
+  line: string
+}
+
 export type KubbHookEndContext = {
   /**
    * Optional identifier matching the corresponding `kubb:hook:start` event.
@@ -739,6 +755,14 @@ export type KubbHookEndContext = {
    * Error thrown by the command, or `null` on success.
    */
   error: Error | null
+  /**
+   * Captured stdout from the process, populated when it exits non-zero.
+   */
+  stdout?: string
+  /**
+   * Captured stderr from the process, populated when it exits non-zero.
+   */
+  stderr?: string
 }
 
 /**

package/src/defineLogger.ts

@@ -34,29 +34,27 @@ export type LoggerContext = AsyncEventEmitter<KubbHooks>
 /**
  * Logger contract. A logger receives the build's event emitter and subscribes
  * to whichever lifecycle events it wants to forward to its destination
- * (console, file, remote sink).
+ * (console, file, remote service).
  */
-export type Logger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = {
+export type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
   /**
    * Display name used in diagnostics.
    */
   name: string
   /**
-   * Called once per build with the shared event emitter. Subscribe to events
-   * here. The return value (if any) is forwarded to whoever installed the
-   * logger, which is handy for sink factories.
+   * Called once per build with the shared event emitter. Subscribe to the
+   * lifecycle events the logger wants to forward to its destination.
    */
-  install: (context: LoggerContext, options?: TOptions) => TInstallReturn | Promise<TInstallReturn>
+  install: (context: LoggerContext, options?: TOptions) => void | Promise<void>
 }
 
-export type UserLogger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = Logger<TOptions, TInstallReturn>
+export type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOptions>
 
 /**
- * Defines a typed logger. Use the second type parameter to declare a return
- * value from `install`, which is handy when the logger exposes a sink factory
- * or cleanup callback to the caller.
+ * Defines a typed logger. The `install` method subscribes to lifecycle events
+ * on the shared emitter and forwards them to the logger's destination.
  *
- * @example Basic logger
+ * @example
  * ```ts
  * import { defineLogger } from '@kubb/core'
  *
@@ -68,23 +66,7 @@ export type UserLogger<TOptions extends LoggerOptions = LoggerOptions, TInstallR
  *   },
  * })
  * ```
- *
- * @example Logger that returns a hook sink factory
- * ```ts
- * import { defineLogger, type LoggerOptions } from '@kubb/core'
- * import type { HookSinkFactory } from './sinks'
- *
- * export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
- *   name: 'my-logger',
- *   install(context) {
- *     // … register event handlers …
- *     return () => ({ onStdout: console.log })
- *   },
- * })
- * ```
  */
-export function defineLogger<Options extends LoggerOptions = LoggerOptions, TInstallReturn = void>(
-  logger: UserLogger<Options, TInstallReturn>,
-): Logger<Options, TInstallReturn> {
+export function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options> {
   return logger
 }

package/src/types.ts

@@ -31,6 +31,7 @@ export type {
   KubbGenerationEndContext,
   KubbGenerationStartContext,
   KubbHookEndContext,
+  KubbHookLineContext,
   KubbHookStartContext,
   KubbHooks,
   KubbInfoContext,