unplugin-kubb 3.2.1 → 4.0.1

package/dist/{types-BNmRHGEx.d.cts → types-BWfxOttU.d.ts}

@@ -1,54 +1,229 @@
 import { KubbFile } from "@kubb/fabric-core/types";
 import { Fabric } from "@kubb/react-fabric";
-import { ConsolaInstance, LogLevel } from "consola";
 
-//#region ../core/src/utils/EventEmitter.d.ts
-declare class EventEmitter<TEvents extends Record<string, any>> {
-  #private;
-  constructor();
-  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
-  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-  removeAll(): void;
-}
-//#endregion
-//#region ../core/src/logger.d.ts
+//#region ../core/src/Kubb.d.ts
 type DebugEvent = {
   date: Date;
   logs: string[];
   fileName?: string;
 };
-type Events$1 = {
-  start: [message: string];
-  success: [message: string];
-  error: [message: string, cause: Error];
-  warning: [message: string];
-  debug: [DebugEvent];
-  info: [message: string];
-  progress_start: [{
-    id: string;
-    size: number;
-    message?: string;
-  }];
-  progressed: [{
-    id: string;
-    message?: 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>;
   }];
-  progress_stop: [{
-    id: string;
+  /**
+   * 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;
   }];
-};
-type Logger = {
   /**
-   * Optional config name to show in CLI output
+   * Emitted when file processing completes.
+   * Contains the list of processed files.
    */
-  name?: string;
-  logLevel: LogLevel;
-  consola?: ConsolaInstance;
-  on: EventEmitter<Events$1>['on'];
-  emit: EventEmitter<Events$1>['emit'];
-  writeLogs: () => Promise<string[]>;
-};
+  '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 ../core/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 ../core/src/utils/types.d.ts
 type PossiblePromise<T> = Promise<T> | T;
@@ -314,8 +489,15 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   fabric: Fabric;
   config: Config;
   pluginManager: PluginManager;
+  /**
+   * Only add when the file does not exist yet
+   */
   addFile: (...file: Array<KubbFile.File>) => Promise<void>;
-  logger: Logger;
+  /**
+   * merging multiple sources into the same output file
+   */
+  upsertFile: (...file: Array<KubbFile.File>) => Promise<void>;
+  events: AsyncEventEmitter<KubbEvents>;
   mode: KubbFile.Mode;
   /**
    * Current plugin
@@ -326,14 +508,6 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
 //#region ../core/src/PluginManager.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
-type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  message: string;
-  strategy: Strategy;
-  hookName: H;
-  plugin: Plugin;
-  parameters?: unknown[] | undefined;
-  output?: unknown;
-};
 type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
   result: Result;
@@ -341,17 +515,12 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 };
 type Options$1 = {
   fabric: Fabric;
-  logger: Logger;
+  events: AsyncEventEmitter<KubbEvents>;
   /**
    * @default Number.POSITIVE_INFINITY
    */
   concurrency?: number;
 };
-type Events = {
-  executing: [executer: Executer];
-  executed: [executer: Executer];
-  error: [error: Error];
-};
 type GetFileProps<TOptions = object> = {
   name: string;
   mode?: KubbFile.Mode;
@@ -361,12 +530,10 @@ type GetFileProps<TOptions = object> = {
 };
 declare class PluginManager {
   #private;
-  readonly events: EventEmitter<Events>;
   readonly config: Config;
-  readonly executed: Array<Executer>;
-  readonly logger: Logger;
   readonly options: Options$1;
   constructor(config: Config, options: Options$1);
+  get events(): AsyncEventEmitter<KubbEvents>;
   getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, any>;
   get plugins(): Array<Plugin>;
   getFile<TOptions = object>({
@@ -380,23 +547,17 @@ 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.
    */
   hookForPlugin<H extends PluginLifecycleHooks>({
     pluginKey,
     hookName,
-    parameters,
-    message
+    parameters
   }: {
     pluginKey: Plugin['key'];
     hookName: H;
     parameters: PluginParameter<H>;
-    message: string;
   }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
   /**
    * Run a specific hookName for plugin x.
@@ -404,13 +565,11 @@ declare class PluginManager {
   hookForPluginSync<H extends PluginLifecycleHooks>({
     pluginKey,
     hookName,
-    parameters,
-    message
+    parameters
   }: {
     pluginKey: Plugin['key'];
     hookName: H;
     parameters: PluginParameter<H>;
-    message: string;
   }): Array<ReturnType<ParseResult<H>>> | null;
   /**
    * First non-null result stops and will return it's value.
@@ -418,13 +577,11 @@ declare class PluginManager {
   hookFirst<H extends PluginLifecycleHooks>({
     hookName,
     parameters,
-    skipped,
-    message
+    skipped
   }: {
     hookName: H;
     parameters: PluginParameter<H>;
     skipped?: ReadonlySet<Plugin> | null;
-    message: string;
   }): Promise<SafeParseResult<H>>;
   /**
    * First non-null result stops and will return it's value.
@@ -432,37 +589,31 @@ declare class PluginManager {
   hookFirstSync<H extends PluginLifecycleHooks>({
     hookName,
     parameters,
-    skipped,
-    message
+    skipped
   }: {
     hookName: H;
     parameters: PluginParameter<H>;
     skipped?: ReadonlySet<Plugin> | null;
-    message: string;
   }): SafeParseResult<H>;
   /**
    * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
    */
   hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
     hookName,
-    parameters,
-    message
+    parameters
   }: {
     hookName: H;
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
-    message: string;
   }): Promise<Awaited<TOuput>[]>;
   /**
    * Chains plugins
    */
   hookSeq<H extends PluginLifecycleHooks>({
     hookName,
-    parameters,
-    message
+    parameters
   }: {
     hookName: H;
     parameters?: PluginParameter<H>;
-    message: string;
   }): Promise<void>;
   getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined;
   getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
@@ -477,4 +628,4 @@ type Options = {
 };
 //#endregion
 export { Options as t };
-//# sourceMappingURL=types-BNmRHGEx.d.cts.map
+//# sourceMappingURL=types-BWfxOttU.d.ts.map