@kubb/core 4.32.4 → 4.33.1

package/dist/index.d.ts

@@ -1,23 +1,8 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as AsyncEventEmitter, C as UserLogger, D as KubbEvents, O as PluginManager, S as UserConfig, T as UserPluginWithLifeCycle, _ as PluginLifecycleHooks, a as InputData, b as ResolveNameParams, c as Logger, d as Output, f as Plugin, g as PluginLifecycle, h as PluginKey, i as Group, k as getMode, l as LoggerContext, m as PluginFactoryOptions, n as Config, o as InputPath, p as PluginContext, r as GetPluginFactoryOptions, s as LogLevel, t as BarrelType, u as LoggerOptions, v as PluginParameter, w as UserPlugin, x as ResolvePathParams, y as PluginWithLifeCycle } from "./types-f_no0d7G.js";
-import { a as getBarrelFiles, c as isInputPath, i as FileMetaBase, n as PackageManagerName, o as CLIOptions, r as detectPackageManager, s as defineConfig, t as PackageManagerInfo } from "./packageManager-_7I0WFQU.js";
+import { A as linters, C as UserLogger, D as PluginManager, E as KubbEvents, M as AsyncEventEmitter, O as getMode, S as UserConfig, T as UserPluginWithLifeCycle, _ as PluginParameter, a as InputData, b as ResolvePathParams, c as LoggerContext, d as Plugin, f as PluginContext, g as PluginLifecycleHooks, h as PluginLifecycle, i as Group, j as logLevel, k as formatters, l as LoggerOptions, m as PluginKey, n as Config, o as InputPath, p as PluginFactoryOptions, r as GetPluginFactoryOptions, s as Logger, t as BarrelType, u as Output, v as PluginWithLifeCycle, w as UserPlugin, x as UnknownUserPlugin, y as ResolveNameParams } from "./types-DfjjJb2r.js";
 import { Fabric } from "@kubb/react-fabric";
 import { KubbFile } from "@kubb/fabric-core/types";
 
-//#region src/BaseGenerator.d.ts
-/**
- * Abstract class that contains the building blocks for plugins to create their own Generator
- * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
- */
-declare abstract class BaseGenerator<TOptions = unknown, TContext = unknown> {
-  #private;
-  constructor(options?: TOptions, context?: TContext);
-  get options(): TOptions;
-  get context(): TContext;
-  set options(options: TOptions);
-  abstract build(...params: unknown[]): unknown;
-}
-//#endregion
 //#region src/build.d.ts
 type BuildOptions = {
   config: UserConfig;
@@ -45,6 +30,44 @@ declare function setup(options: BuildOptions): Promise<SetupResult>;
 declare function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
 declare function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
 //#endregion
+//#region src/config.d.ts
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
+  /** Path to `kubb.config.js` */config?: string; /** Enable watch mode for input files */
+  watch?: boolean;
+  /**
+   * Logging verbosity for CLI usage.
+   *
+   * - `silent`: hide non-essential logs
+   * - `info`: show general logs (non-plugin-related)
+   * - `debug`: include detailed plugin lifecycle logs
+   * @default 'silent'
+   */
+  logLevel?: 'silent' | 'info' | 'debug'; /** Run Kubb with Bun */
+  bun?: boolean;
+};
+/**
+ * Helper for defining a Kubb configuration.
+ *
+ * Accepts either:
+ * - A config object or array of configs
+ * - A function returning the config(s), optionally async,
+ *   receiving the CLI options as argument
+ *
+ * @example
+ * export default defineConfig(({ logLevel }) => ({
+ *   root: 'src',
+ *   plugins: [myPlugin()],
+ * }))
+ */
+declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>)): typeof config;
+/**
+ * Type guard to check if a given config has an `input.path`.
+ */
+declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
+//#endregion
 //#region src/defineLogger.d.ts
 declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
 //#endregion
@@ -69,7 +92,7 @@ declare class PackageManager {
   get workspace(): string | undefined;
   normalizeDirectory(directory: string): string;
   getLocation(path: string): string;
-  import(path: string): Promise<any | undefined>;
+  import(path: string): Promise<unknown>;
   getPackageJSON(): Promise<PackageJSON | undefined>;
   getPackageJSONSync(): PackageJSON | undefined;
   static setVersion(dependency: DependencyName, version: DependencyVersion): void;
@@ -99,10 +122,10 @@ type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc
 //#endregion
 //#region src/PromiseManager.d.ts
 type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
-type Options<TState = any> = {
+type Options<TState = unknown> = {
   nullCheck?: (state: TState) => boolean;
 };
-declare class PromiseManager<TState = any> {
+declare class PromiseManager<TState = unknown> {
   #private;
   constructor(options?: Options<TState>);
   run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(strategy: TStrategy, promises: TInput, {
@@ -112,5 +135,112 @@ declare class PromiseManager<TState = any> {
   }): TOutput;
 }
 //#endregion
-export { BarrelType, BaseGenerator, type CLIOptions, Config, type FileMetaBase, GetPluginFactoryOptions, Group, InputData, InputPath, KubbEvents, LogLevel, Logger, LoggerContext, LoggerOptions, Output, PackageManager, type PackageManagerInfo, type PackageManagerName, Plugin, PluginContext, PluginFactoryOptions, PluginKey, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, PromiseManager, ResolveNameParams, ResolvePathParams, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, build, build as default, defineConfig, defineLogger, definePlugin, detectPackageManager, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
+//#region src/utils/FunctionParams.d.ts
+type FunctionParamsASTWithoutType = {
+  name?: string;
+  type?: string;
+  /**
+   * @default true
+   */
+  required?: boolean;
+  /**
+   * @default true
+   */
+  enabled?: boolean;
+  default?: string;
+};
+type FunctionParamsASTWithType = {
+  name?: never;
+  type: string;
+  /**
+   * @default true
+   */
+  required?: boolean;
+  /**
+   * @default true
+   */
+  enabled?: boolean;
+  default?: string;
+};
+/**
+ * @deprecated
+ */
+type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
+/**
+ * @deprecated
+ */
+declare class FunctionParams {
+  #private;
+  get items(): FunctionParamsAST[];
+  add(item: FunctionParamsAST | Array<FunctionParamsAST | FunctionParamsAST[] | undefined> | undefined): FunctionParams;
+  static toObject(items: FunctionParamsAST[]): FunctionParamsAST;
+  toObject(): FunctionParamsAST;
+  static toString(items: (FunctionParamsAST | FunctionParamsAST[])[]): string;
+  toString(): string;
+}
+//#endregion
+//#region src/utils/formatters.d.ts
+type Formatter = keyof typeof formatters;
+/**
+ * Detect which formatter is available in the system.
+ *
+ * @returns Promise that resolves to the first available formatter or undefined if none are found
+ *
+ * @remarks
+ * Checks in order of preference: biome, oxfmt, prettier.
+ * Uses the `--version` flag to detect if each formatter command is available.
+ * This is a reliable method as all supported formatters implement this flag.
+ *
+ * @example
+ * ```typescript
+ * const formatter = await detectFormatter()
+ * if (formatter) {
+ *   console.log(`Using ${formatter} for formatting`)
+ * } else {
+ *   console.log('No formatter found')
+ * }
+ * ```
+ */
+declare function detectFormatter(): Promise<Formatter | undefined>;
+//#endregion
+//#region src/utils/getBarrelFiles.d.ts
+type FileMetaBase = {
+  pluginKey?: Plugin['key'];
+};
+type AddIndexesProps = {
+  type: BarrelType | false | undefined;
+  /**
+   * Root based on root and output.path specified in the config
+   */
+  root: string;
+  /**
+   * Output for plugin
+   */
+  output: {
+    path: string;
+  };
+  group?: {
+    output: string;
+    exportAs: string;
+  };
+  meta?: FileMetaBase;
+};
+declare function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, {
+  type,
+  meta,
+  root,
+  output
+}: AddIndexesProps): Promise<KubbFile.File[]>;
+//#endregion
+//#region src/utils/getConfigs.d.ts
+/**
+ * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+ */
+declare function getConfigs(config: ReturnType<typeof defineConfig> | UserConfig, args: CLIOptions): Promise<Array<Config>>;
+//#endregion
+//#region src/utils/linters.d.ts
+type Linter = keyof typeof linters;
+declare function detectLinter(): Promise<Linter | undefined>;
+//#endregion
+export { BarrelType, type CLIOptions, Config, type FileMetaBase, FunctionParams, type FunctionParamsAST, GetPluginFactoryOptions, Group, InputData, InputPath, KubbEvents, Logger, LoggerContext, LoggerOptions, Output, PackageManager, Plugin, PluginContext, PluginFactoryOptions, PluginKey, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, PromiseManager, ResolveNameParams, ResolvePathParams, UnknownUserPlugin, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, build, build as default, defineConfig, defineLogger, definePlugin, detectFormatter, detectLinter, formatters, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, safeBuild, setup };
 //# sourceMappingURL=index.d.ts.map