unplugin-kubb 4.0.0 → 4.0.2

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

@@ -1,54 +1,238 @@
+import { t as __name } from "./chunk-CIm-hhu7.js";
 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;
+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. (e.g., format or lint).
+   * The callback should be invoked when the command completes.
+   */
+  'hook:start': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+  }];
+  /**
+   * Emitted when a single hook execution completes.
+   */
+  'hook:end': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+    success: boolean;
+    error: Error | null;
   }];
-  progressed: [{
-    id: string;
-    message?: 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;
   }];
-  progress_stop: [{
-    id: string;
+  /**
+   * 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.
+   * Duration in ms
+   */
+  'plugin:end': [plugin: Plugin, meta: {
+    duration: number;
+    success: boolean;
+    error?: Error;
   }];
-};
-type Logger = {
   /**
-   * Optional config name to show in CLI output
+   * Emitted when plugin hook progress tracking starts.
+   * Contains the hook name and list of plugins to execute.
    */
-  name?: string;
-  logLevel: LogLevel;
-  consola?: ConsolaInstance;
-  on: EventEmitter<Events$1>['on'];
-  emit: EventEmitter<Events$1>['emit'];
-  writeLogs: () => Promise<string[]>;
-};
+  '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;
@@ -130,22 +314,24 @@ type Config<TInput = Input> = {
      * @default prettier
      *
      * Possible values:
+     * - 'auto': Automatically detects and uses biome or prettier (in that order of preference).
      * - 'prettier': Uses Prettier for code formatting.
      * - 'biome': Uses Biome for code formatting.
      *
      */
-    format?: 'prettier' | 'biome' | false;
+    format?: 'auto' | 'prettier' | 'biome' | 'oxfmt' | false;
     /**
      * Specifies the linter that should be used to analyze the code.
      * The accepted values indicate different linting tools.
      *
      * Possible values:
+     * - 'auto': Automatically detects and uses biome, oxlint, or eslint (in that order of preference).
      * - 'eslint': Represents the use of ESLint, a widely used JavaScript linter.
      * - 'biome': Represents the Biome linter, a modern tool for code scanning.
      * - 'oxlint': Represents the Oxlint tool for linting purposes.
      *
      */
-    lint?: 'eslint' | 'biome' | 'oxlint' | false;
+    lint?: 'auto' | 'eslint' | 'biome' | 'oxlint' | false;
     /**
      * Override the extension to the generated imports and exports, by default each plugin will add an extension
      * @default { '.ts': '.ts'}
@@ -163,6 +349,13 @@ type Config<TInput = Input> = {
      * @default 'simple'
      */
     defaultBanner?: 'simple' | 'full' | false;
+    /**
+     * Whether to override existing external files if they already exist.
+     * When setting the option in the global configuration, all plugins inherit the same behavior by default.
+     * However, all plugins also have an `output.override` option, which can be used to override the behavior for a specific plugin.
+     * @default false
+     */
+    override?: boolean;
   };
   /**
    * An array of Kubb plugins that will be used in the generation.
@@ -314,8 +507,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 +526,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 +533,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 +548,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 +565,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 +583,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 +595,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 +607,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 +646,4 @@ type Options = {
 };
 //#endregion
 export { Options as t };
-//# sourceMappingURL=types-BNmRHGEx.d.cts.map
+//# sourceMappingURL=types-CUVJ-CBJ.d.ts.map

package/dist/types.d.cts

@@ -1,2 +1,2 @@
-import { t as Options } from "./types-BNmRHGEx.cjs";
+import { t as Options } from "./types-C-ZTDGdJ.cjs";
 export { Options };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { t as Options } from "./types-D54bCl1u.js";
+import { t as Options } from "./types-CUVJ-CBJ.js";
 export { Options };

package/dist/vite.cjs

@@ -1,4 +1,9 @@
-require('./src-CV35pUck.cjs');
-const require_vite = require('./vite-DruCA3WT.cjs');
+const require_src = require('./src-BiN2tznZ.cjs');
+let unplugin = require("unplugin");
 
-module.exports = require_vite.vite_default;
+//#region src/vite.ts
+var vite_default = (0, unplugin.createVitePlugin)(require_src.unpluginFactory);
+
+//#endregion
+module.exports = vite_default;
+//# sourceMappingURL=vite.cjs.map

package/dist/vite.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.cjs","names":["unpluginFactory"],"sources":["../src/vite.ts"],"sourcesContent":["import { createVitePlugin } from 'unplugin'\n\nimport { unpluginFactory } from './index.ts'\n\nexport default createVitePlugin(unpluginFactory)\n"],"mappings":";;;;AAIA,kDAAgCA,4BAAgB"}

package/dist/vite.d.cts

@@ -1,7 +1,7 @@
-import { t as Options } from "./types-BNmRHGEx.cjs";
-import * as unplugin0 from "unplugin";
+import { n as __name, t as Options } from "./types-C-ZTDGdJ.cjs";
+import * as vite0 from "vite";
 
 //#region src/vite.d.ts
-declare const _default: (options?: Options | undefined) => unplugin0.VitePlugin<any> | unplugin0.VitePlugin<any>[];
+declare const _default: (options?: Options | undefined) => vite0.Plugin<any> | vite0.Plugin<any>[];
 export = _default;
 //# sourceMappingURL=vite.d.cts.map

package/dist/vite.d.ts

@@ -1,8 +1,9 @@
-import { t as Options } from "./types-D54bCl1u.js";
-import * as unplugin0 from "unplugin";
+import { t as __name } from "./chunk-CIm-hhu7.js";
+import { t as Options } from "./types-CUVJ-CBJ.js";
+import * as vite0 from "vite";
 
 //#region src/vite.d.ts
-declare const _default: (options?: Options | undefined) => unplugin0.VitePlugin<any> | unplugin0.VitePlugin<any>[];
+declare const _default: (options?: Options | undefined) => vite0.Plugin<any> | vite0.Plugin<any>[];
 //#endregion
 export { _default as default };
 //# sourceMappingURL=vite.d.ts.map

package/dist/vite.js

@@ -1,4 +1,9 @@
-import "./src-wEqIY2rq.js";
-import { t as vite_default } from "./vite-DkSw2hsC.js";
+import { r as unpluginFactory } from "./src-CiUcBKSs.js";
+import { createVitePlugin } from "unplugin";
 
-export { vite_default as default };
+//#region src/vite.ts
+var vite_default = createVitePlugin(unpluginFactory);
+
+//#endregion
+export { vite_default as default };
+//# sourceMappingURL=vite.js.map

package/dist/vite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.js","names":[],"sources":["../src/vite.ts"],"sourcesContent":["import { createVitePlugin } from 'unplugin'\n\nimport { unpluginFactory } from './index.ts'\n\nexport default createVitePlugin(unpluginFactory)\n"],"mappings":";;;;AAIA,mBAAe,iBAAiB,gBAAgB"}

package/dist/webpack.cjs

@@ -1,4 +1,9 @@
-require('./src-CV35pUck.cjs');
-const require_webpack = require('./webpack-NglPEtfi.cjs');
+const require_src = require('./src-BiN2tznZ.cjs');
+let unplugin = require("unplugin");
 
-module.exports = require_webpack.webpack_default;
+//#region src/webpack.ts
+var webpack_default = (0, unplugin.createWebpackPlugin)(require_src.unpluginFactory);
+
+//#endregion
+module.exports = webpack_default;
+//# sourceMappingURL=webpack.cjs.map

package/dist/webpack.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.cjs","names":["unpluginFactory"],"sources":["../src/webpack.ts"],"sourcesContent":["import type { UnpluginFactoryOutput } from 'unplugin'\nimport { createWebpackPlugin } from 'unplugin'\nimport type { WebpackPluginInstance } from 'webpack'\nimport { unpluginFactory } from './index.ts'\nimport type { Options } from './types.ts'\n\n// resolves issue for: The inferred type of 'default' cannot be named without a reference to 'node_modules/webpack'. This is likely not portable. A type annotation is necessary.\nexport default createWebpackPlugin(unpluginFactory) as unknown as UnpluginFactoryOutput<Options, WebpackPluginInstance>\n"],"mappings":";;;;AAOA,wDAAmCA,4BAAgB"}

package/dist/webpack.d.cts

@@ -1,4 +1,4 @@
-import { t as Options } from "./types-BNmRHGEx.cjs";
+import { n as __name, t as Options } from "./types-C-ZTDGdJ.cjs";
 import { UnpluginFactoryOutput } from "unplugin";
 import { WebpackPluginInstance } from "webpack";
 

package/dist/webpack.d.ts

@@ -1,4 +1,5 @@
-import { t as Options } from "./types-D54bCl1u.js";
+import { t as __name } from "./chunk-CIm-hhu7.js";
+import { t as Options } from "./types-CUVJ-CBJ.js";
 import { UnpluginFactoryOutput } from "unplugin";
 import { WebpackPluginInstance } from "webpack";
 

package/dist/webpack.js

@@ -1,4 +1,9 @@
-import "./src-wEqIY2rq.js";
-import { t as webpack_default } from "./webpack-kTaImLW0.js";
+import { r as unpluginFactory } from "./src-CiUcBKSs.js";
+import { createWebpackPlugin } from "unplugin";
 
-export { webpack_default as default };
+//#region src/webpack.ts
+var webpack_default = createWebpackPlugin(unpluginFactory);
+
+//#endregion
+export { webpack_default as default };
+//# sourceMappingURL=webpack.js.map

package/dist/webpack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.js","names":[],"sources":["../src/webpack.ts"],"sourcesContent":["import type { UnpluginFactoryOutput } from 'unplugin'\nimport { createWebpackPlugin } from 'unplugin'\nimport type { WebpackPluginInstance } from 'webpack'\nimport { unpluginFactory } from './index.ts'\nimport type { Options } from './types.ts'\n\n// resolves issue for: The inferred type of 'default' cannot be named without a reference to 'node_modules/webpack'. This is likely not portable. A type annotation is necessary.\nexport default createWebpackPlugin(unpluginFactory) as unknown as UnpluginFactoryOutput<Options, WebpackPluginInstance>\n"],"mappings":";;;;AAOA,sBAAe,oBAAoB,gBAAgB"}