@kubb/core 4.11.3 → 4.12.0

package/dist/{types-DgfEZ3IN.d.ts → types-DZARm27h.d.ts}

@@ -1,39 +1,20 @@
-import { n as Logger, o as EventEmitter } from "./logger-o16AyvGp.js";
 import { Fabric } from "@kubb/react-fabric";
 import { KubbFile } from "@kubb/fabric-core/types";
 
+//#region src/utils/AsyncEventEmitter.d.ts
+declare class AsyncEventEmitter<TEvents extends Record<string, any>> {
+  #private;
+  constructor(maxListener?: number);
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArgs: TEvents[TEventName]) => void): void;
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+  removeAll(): void;
+}
+//#endregion
 //#region src/PluginManager.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
-type ExecutingMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  strategy: Strategy;
-  hookName: H;
-  plugin: Plugin;
-  parameters?: unknown[] | undefined;
-  output?: unknown;
-};
-type ExecutedMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  duration: number;
-  strategy: Strategy;
-  hookName: H;
-  plugin: Plugin;
-  parameters?: unknown[] | undefined;
-  output?: unknown;
-};
-type ErrorMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  hookName: H;
-  duration: number;
-  strategy: Strategy;
-  parameters?: unknown[] | undefined;
-  plugin: Plugin;
-};
-type ProgressStartMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  hookName: H;
-  plugins: Array<Plugin>;
-};
-type ProgressStopMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  hookName: H;
-};
 type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
   result: Result;
@@ -41,19 +22,12 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 };
 type Options = {
   fabric: Fabric;
-  logger: Logger;
+  events: AsyncEventEmitter<KubbEvents>;
   /**
    * @default Number.POSITIVE_INFINITY
    */
   concurrency?: number;
 };
-type Events = {
-  progress_start: [meta: ProgressStartMeta];
-  progress_stop: [meta: ProgressStopMeta];
-  executing: [meta: ExecutingMeta];
-  executed: [meta: ExecutedMeta];
-  error: [error: Error, meta: ErrorMeta];
-};
 type GetFileProps<TOptions = object> = {
   name: string;
   mode?: KubbFile.Mode;
@@ -64,10 +38,10 @@ type GetFileProps<TOptions = object> = {
 declare function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode;
 declare class PluginManager {
   #private;
-  readonly events: EventEmitter<Events>;
   readonly config: Config;
   readonly options: Options;
   constructor(config: Config, options: Options);
+  get events(): AsyncEventEmitter<KubbEvents>;
   getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, any>;
   get plugins(): Array<Plugin>;
   getFile<TOptions = object>({
@@ -81,10 +55,6 @@ declare class PluginManager {
   }>;
   resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
   resolveName: (params: ResolveNameParams) => string;
-  /**
-   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
-   */
-  on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void;
   /**
    * Run a specific hookName for plugin x.
    */
@@ -157,6 +127,219 @@ declare class PluginManager {
   getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
 }
 //#endregion
+//#region src/Kubb.d.ts
+type DebugEvent = {
+  date: Date;
+  logs: string[];
+  fileName?: string;
+};
+type ProgressStartMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H;
+  plugins: Array<Plugin>;
+};
+type ProgressStopMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H;
+};
+type ExecutingMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: unknown[] | undefined;
+  output?: unknown;
+};
+type ExecutedMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  duration: number;
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: unknown[] | undefined;
+  output?: unknown;
+};
+/**
+ * Events emitted during the Kubb code generation lifecycle.
+ * These events can be listened to for logging, progress tracking, and custom integrations.
+ *
+ * @example
+ * ```typescript
+ * import type { AsyncEventEmitter } from '@kubb/core'
+ * import type { KubbEvents } from '@kubb/core'
+ *
+ * const events: AsyncEventEmitter<KubbEvents> = new AsyncEventEmitter()
+ *
+ * events.on('lifecycle:start', () => {
+ *   console.log('Starting Kubb generation')
+ * })
+ *
+ * events.on('plugin:end', (plugin, duration) => {
+ *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
+ * })
+ * ```
+ */
+interface KubbEvents {
+  /**
+   * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
+   */
+  'lifecycle:start': [version: string];
+  /**
+   * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
+   */
+  'lifecycle:end': [];
+  /**
+   * Emitted when configuration loading starts.
+   */
+  'config:start': [];
+  /**
+   * Emitted when configuration loading is complete.
+   */
+  'config:end': [configs: Array<Config>];
+  /**
+   * Emitted when code generation phase starts.
+   */
+  'generation:start': [config: Config];
+  /**
+   * Emitted when code generation phase completes.
+   */
+  'generation:end': [Config: Config];
+  /**
+   * Emitted with a summary of the generation results.
+   * Contains summary lines, title, and success status.
+   */
+  'generation:summary': [Config: Config, {
+    failedPlugins: Set<{
+      plugin: Plugin;
+      error: Error;
+    }>;
+    status: 'success' | 'failed';
+    hrStart: [number, number];
+    filesCreated: number;
+    pluginTimings?: Map<string, number>;
+  }];
+  /**
+   * Emitted when code formatting starts (e.g., running Biome or Prettier).
+   */
+  'format:start': [];
+  /**
+   * Emitted when code formatting completes.
+   */
+  'format:end': [];
+  /**
+   * Emitted when linting starts.
+   */
+  'lint:start': [];
+  /**
+   * Emitted when linting completes.
+   */
+  'lint:end': [];
+  /**
+   * Emitted when plugin hooks execution starts.
+   */
+  'hooks:start': [];
+  /**
+   * Emitted when plugin hooks execution completes.
+   */
+  'hooks:end': [];
+  /**
+   * Emitted when a single hook execution starts.
+   */
+  'hook:start': [command: string];
+  /**
+   * Emitted to execute a hook command (e.g., format or lint).
+   * The callback should be invoked when the command completes.
+   */
+  'hook:execute': [{
+    command: string | URL;
+    args?: readonly string[];
+  }, cb: () => void];
+  /**
+   * Emitted when a single hook execution completes.
+   */
+  'hook:end': [command: string];
+  /**
+   * Emitted when a new version of Kubb is available.
+   */
+  'version:new': [currentVersion: string, latestVersion: string];
+  /**
+   * Informational message event.
+   */
+  info: [message: string, info?: string];
+  /**
+   * Error event. Emitted when an error occurs during code generation.
+   */
+  error: [error: Error, meta?: Record<string, unknown>];
+  /**
+   * Success message event.
+   */
+  success: [message: string, info?: string];
+  /**
+   * Warning message event.
+   */
+  warn: [message: string, info?: string];
+  /**
+   * Debug event for detailed logging.
+   * Contains timestamp, log messages, and optional filename.
+   */
+  debug: [meta: DebugEvent];
+  /**
+   * Emitted when file processing starts.
+   * Contains the list of files to be processed.
+   */
+  'files:processing:start': [files: Array<KubbFile.ResolvedFile>];
+  /**
+   * Emitted for each file being processed, providing progress updates.
+   * Contains processed count, total count, percentage, and file details.
+   */
+  'file:processing:update': [{
+    /** Number of files processed so far */
+    processed: number;
+    /** Total number of files to process */
+    total: number;
+    /** Processing percentage (0-100) */
+    percentage: number;
+    /** Optional source identifier */
+    source?: string;
+    /** The file being processed */
+    file: KubbFile.ResolvedFile;
+    /**
+     * Kubb configuration (not present in Fabric).
+     * Provides access to the current config during file processing.
+     */
+    config: Config;
+  }];
+  /**
+   * Emitted when file processing completes.
+   * Contains the list of processed files.
+   */
+  'files:processing:end': [files: KubbFile.ResolvedFile[]];
+  /**
+   * Emitted when a plugin starts executing.
+   */
+  'plugin:start': [plugin: Plugin];
+  /**
+   * Emitted when a plugin completes execution.
+   */
+  'plugin:end': [plugin: Plugin, duration: number];
+  /**
+   * Emitted when plugin hook progress tracking starts.
+   * Contains the hook name and list of plugins to execute.
+   */
+  'plugins:hook:progress:start': [meta: ProgressStartMeta];
+  /**
+   * Emitted when plugin hook progress tracking ends.
+   * Contains the hook name that completed.
+   */
+  'plugins:hook:progress:end': [meta: ProgressStopMeta];
+  /**
+   * Emitted when a plugin hook starts processing.
+   * Contains strategy, hook name, plugin, parameters, and output.
+   */
+  'plugins:hook:processing:start': [meta: ExecutingMeta];
+  /**
+   * Emitted when a plugin hook completes processing.
+   * Contains duration, strategy, hook name, plugin, parameters, and output.
+   */
+  'plugins:hook:processing:end': [meta: ExecutedMeta];
+}
+//#endregion
 //#region src/utils/types.d.ts
 type PossiblePromise<T> = Promise<T> | T;
 //#endregion
@@ -431,7 +614,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * merging multiple sources into the same output file
    */
   upsertFile: (...file: Array<KubbFile.File>) => Promise<void>;
-  logger: Logger;
+  events: AsyncEventEmitter<KubbEvents>;
   mode: KubbFile.Mode;
   /**
    * Current plugin
@@ -473,6 +656,30 @@ type Group = {
    */
   name?: (context: GroupContext) => string;
 };
+declare const LogLevel: {
+  readonly silent: number;
+  readonly error: 0;
+  readonly warn: 1;
+  readonly info: 3;
+  readonly verbose: 4;
+  readonly debug: 5;
+};
+type LoggerOptions = {
+  /**
+   * @default 3
+   */
+  logLevel: (typeof LogLevel)[keyof typeof LogLevel];
+};
+/**
+ * Shared context passed to all plugins, parsers, and Fabric internals.
+ */
+interface LoggerContext extends AsyncEventEmitter<KubbEvents> {}
+type Install<TOptions = unknown> = (context: LoggerContext, options?: TOptions) => void | Promise<void>;
+type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
+  name: string;
+  install: Install<TOptions>;
+};
+type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Omit<Logger<TOptions>, 'logLevel'>;
 //#endregion
-export { getMode as C, PluginManager as S, ResolvePathParams as _, InputData as a, UserPluginWithLifeCycle as b, Plugin as c, PluginKey as d, PluginLifecycle as f, ResolveNameParams as g, PluginWithLifeCycle as h, Group as i, PluginContext as l, PluginParameter as m, Config as n, InputPath as o, PluginLifecycleHooks as p, GetPluginFactoryOptions as r, Output as s, BarrelType as t, PluginFactoryOptions as u, UserConfig as v, PossiblePromise as x, UserPlugin as y };
-//# sourceMappingURL=types-DgfEZ3IN.d.ts.map
+export { AsyncEventEmitter as A, UserLogger as C, KubbEvents as D, PossiblePromise as E, PluginManager as O, UserConfig as S, UserPluginWithLifeCycle as T, PluginLifecycleHooks as _, InputData as a, ResolveNameParams as b, Logger as c, Output as d, Plugin as f, PluginLifecycle as g, PluginKey as h, Group as i, getMode as k, LoggerContext as l, PluginFactoryOptions as m, Config as n, InputPath as o, PluginContext as p, GetPluginFactoryOptions as r, LogLevel as s, BarrelType as t, LoggerOptions as u, PluginParameter as v, UserPlugin as w, ResolvePathParams as x, PluginWithLifeCycle as y };
+//# sourceMappingURL=types-DZARm27h.d.ts.map