@kubb/core 4.36.1 → 5.0.0-alpha.10

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as UserPlugin, B as AsyncEventEmitter, C as Printer, D as UnknownUserPlugin, E as ResolvePathParams, F as DefineStorage, I as defineStorage, L as formatters, M as KubbEvents, N as PluginManager, O as UserConfig, P as getMode, R as linters, S as PluginWithLifeCycle, T as ResolveNameParams, V as URLPath, _ as PluginFactoryOptions, a as Config, b as PluginLifecycleHooks, c as Group, d as Logger, f as LoggerContext, g as PluginContext, h as Plugin, i as BarrelType, j as UserPluginWithLifeCycle, k as UserLogger, l as InputData, m as Output, n as AdapterFactoryOptions, o as DevtoolsOptions, p as LoggerOptions, r as AdapterSource, s as GetPluginFactoryOptions, t as Adapter, u as InputPath, v as PluginKey, w as PrinterFactoryOptions, x as PluginParameter, y as PluginLifecycle, z as logLevel } from "./types-D30QAz2y.js";
+import { A as UserConfig, B as Storage, C as PluginWithLifeCycle, D as ResolveOptionsContext, E as ResolveNameParams, F as CoreGeneratorV2, G as AsyncEventEmitter, H as formatters, I as Generator, L as ReactGeneratorV2, M as UserPlugin, N as UserPluginWithLifeCycle, O as ResolvePathParams, P as UserResolver, R as defineGenerator, S as PluginParameter, T as PrinterFactoryOptions, U as linters, V as createStorage, W as logLevel, _ as Plugin, a as AdapterFactoryOptions, b as PluginLifecycle, c as Config, d as InputData, f as InputPath, g as Output, h as LoggerOptions, i as Adapter, j as UserLogger, k as Resolver, l as DevtoolsOptions, m as LoggerContext, n as PluginDriver, o as AdapterSource, p as Logger, r as getMode, s as BarrelType, u as Group, v as PluginContext, w as Printer, x as PluginLifecycleHooks, y as PluginFactoryOptions, z as KubbEvents } from "./PluginDriver-BkFepPdm.js";
 import { definePrinter } from "@kubb/ast";
-import { Fabric } from "@kubb/react-fabric";
-import { KubbFile } from "@kubb/fabric-core/types";
+import { Node } from "@kubb/ast/types";
+import { Fabric, KubbFile } from "@kubb/fabric-core/types";
 
 //#region src/build.d.ts
 type BuildOptions = {
@@ -16,7 +16,7 @@ type BuildOutput = {
   }>;
   fabric: Fabric;
   files: Array<KubbFile.ResolvedFile>;
-  pluginManager: PluginManager;
+  driver: PluginDriver;
   pluginTimings: Map<string, number>;
   error?: Error;
   sources: Map<KubbFile.Path, string>;
@@ -24,7 +24,7 @@ type BuildOutput = {
 type SetupResult = {
   events: AsyncEventEmitter<KubbEvents>;
   fabric: Fabric;
-  pluginManager: PluginManager;
+  driver: PluginDriver;
   sources: Map<KubbFile.Path, string>;
 };
 declare function setup(options: BuildOptions): Promise<SetupResult>;
@@ -72,91 +72,100 @@ declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>
  */
 declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
 //#endregion
-//#region src/defineAdapter.d.ts
+//#region src/createAdapter.d.ts
+/**
+ * Builder type for an {@link Adapter} — takes options and returns the adapter instance.
+ */
 type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
 /**
- * Wraps an adapter builder to make the options parameter optional.
+ * Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
  *
  * @example
- * ```ts
- * export const adapterOas = defineAdapter<OasAdapter>((options) => {
- *   const { validate = true, dateType = 'string' } = options
+ * export const myAdapter = createAdapter<MyAdapter>((options) => {
  *   return {
- *     name: adapterOasName,
- *     options: { validate, dateType, ... },
- *     parse(source) { ... },
+ *     name: 'my-adapter',
+ *     options,
+ *     async parse(source) { ... },
  *   }
  * })
- * ```
+ *
+ * // instantiate
+ * const adapter = myAdapter({ validate: true })
  */
-declare function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
 //#endregion
-//#region src/defineLogger.d.ts
-declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
-//#endregion
-//#region src/definePlugin.d.ts
+//#region src/createPlugin.d.ts
+/**
+ * Builder type for a {@link UserPluginWithLifeCycle} — takes options and returns the plugin instance.
+ */
 type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>;
 /**
- * Wraps a plugin builder to make the options parameter optional.
+ * Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
+ *
+ * @example
+ * export const myPlugin = createPlugin<MyPlugin>((options) => {
+ *   return {
+ *     name: 'my-plugin',
+ *     options,
+ *     resolvePath(baseName) { ... },
+ *     resolveName(name, type) { ... },
+ *   }
+ * })
+ *
+ * // instantiate
+ * const plugin = myPlugin({ output: { path: 'src/gen' } })
  */
-declare function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
 //#endregion
-//#region src/PackageManager.d.ts
-type PackageJSON = {
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-};
-type DependencyName = string;
-type DependencyVersion = string;
-declare class PackageManager {
-  #private;
-  constructor(workspace?: string);
-  set workspace(workspace: string);
-  get workspace(): string | undefined;
-  normalizeDirectory(directory: string): string;
-  getLocation(path: string): string;
-  import(path: string): Promise<unknown>;
-  getPackageJSON(): Promise<PackageJSON | undefined>;
-  getPackageJSONSync(): PackageJSON | undefined;
-  static setVersion(dependency: DependencyName, version: DependencyVersion): void;
-  getVersion(dependency: DependencyName | RegExp): Promise<DependencyVersion | undefined>;
-  getVersionSync(dependency: DependencyName | RegExp): DependencyVersion | undefined;
-  isValid(dependency: DependencyName | RegExp, version: DependencyVersion): Promise<boolean>;
-  isValidSync(dependency: DependencyName | RegExp, version: DependencyVersion): boolean;
-}
+//#region src/defineLogger.d.ts
+/**
+ * Wraps a logger definition into a typed {@link Logger}.
+ *
+ * @example
+ * export const myLogger = defineLogger({
+ *   name: 'my-logger',
+ *   install(context, options) {
+ *     context.on('info', (message) => console.log('ℹ', message))
+ *     context.on('error', (error) => console.error('✗', error.message))
+ *   },
+ * })
+ */
+declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
 //#endregion
-//#region src/utils/executeStrategies.d.ts
-type PromiseFunc$1<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2;
-type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc$1<infer X, infer Y>> ? X | Y : never;
-type SeqOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>;
+//#region src/defineResolver.d.ts
 /**
- * Chains promises
+ * Builder type for the plugin-specific resolver fields.
+ * `default` and `resolveOptions` are optional — built-in fallbacks are used when omitted.
  */
-type HookFirstOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>;
+type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<T['resolver'], 'default' | 'resolveOptions'> & Partial<Pick<T['resolver'], 'default' | 'resolveOptions'>> & ThisType<T['resolver']>;
 /**
- * Chains promises, first non-null result stops and returns
+ * Default option resolver — applies include/exclude filters and merges any matching override options.
+ * Returns `null` when the node is filtered out.
  */
-type HookParallelOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>;
+declare function defaultResolveOptions<TOptions>(node: Node, {
+  options,
+  exclude,
+  include,
+  override
+}: ResolveOptionsContext<TOptions>): TOptions | null;
 /**
- * Runs an array of promise functions with optional concurrency limit.
+ * Defines a resolver for a plugin, with built-in defaults for name casing and include/exclude/override filtering.
+ * Override `default` or `resolveOptions` in the builder to customize the behavior.
+ *
+ * @example
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   resolveName(name) {
+ *     return this.default(name, 'function')
+ *   },
+ *   resolveTypedName(name) {
+ *     return this.default(name, 'type')
+ *   },
+ *   resolveParamName(node, param) {
+ *     return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+ *   },
+ * }))
  */
-type Strategy = 'seq' | 'first' | 'parallel';
-type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = TStrategy extends 'first' ? HookFirstOutput<TInput, TValue> : TStrategy extends 'seq' ? SeqOutput<TInput, TValue> : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue> : never;
-//#endregion
-//#region src/PromiseManager.d.ts
-type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
-type Options<TState = unknown> = {
-  nullCheck?: (state: TState) => boolean;
-};
-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, {
-    concurrency
-  }?: {
-    concurrency?: number;
-  }): TOutput;
-}
+declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
 //#endregion
 //#region src/storages/fsStorage.d.ts
 /**
@@ -182,7 +191,7 @@ declare class PromiseManager<TState = unknown> {
  * })
  * ```
  */
-declare const fsStorage: (options?: Record<string, never> | undefined) => DefineStorage;
+declare const fsStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
 //#region src/storages/memoryStorage.d.ts
 /**
@@ -202,7 +211,7 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Define
  * })
  * ```
  */
-declare const memoryStorage: (options?: Record<string, never> | undefined) => DefineStorage;
+declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
 //#region src/utils/FunctionParams.d.ts
 type FunctionParamsASTWithoutType = {
@@ -232,11 +241,11 @@ type FunctionParamsASTWithType = {
   default?: string;
 };
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 declare class FunctionParams {
   #private;
@@ -274,7 +283,7 @@ declare function detectFormatter(): Promise<Formatter | undefined>;
 //#endregion
 //#region src/utils/getBarrelFiles.d.ts
 type FileMetaBase = {
-  pluginKey?: Plugin['key'];
+  pluginName?: string;
 };
 type AddIndexesProps = {
   type: BarrelType | false | undefined;
@@ -299,7 +308,7 @@ declare function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, {
   meta,
   root,
   output
-}: AddIndexesProps): Promise<KubbFile.File[]>;
+}: AddIndexesProps): Promise<Array<KubbFile.File>>;
 //#endregion
 //#region src/utils/getConfigs.d.ts
 /**
@@ -311,5 +320,10 @@ declare function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions):
 type Linter = keyof typeof linters;
 declare function detectLinter(): Promise<Linter | undefined>;
 //#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, type CLIOptions, Config, type ConfigInput, DefineStorage, DevtoolsOptions, type FileMetaBase, FunctionParams, type FunctionParamsAST, GetPluginFactoryOptions, Group, InputData, InputPath, KubbEvents, Logger, LoggerContext, LoggerOptions, Output, PackageManager, Plugin, PluginContext, PluginFactoryOptions, PluginKey, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, Printer, PrinterFactoryOptions, PromiseManager, ResolveNameParams, ResolvePathParams, URLPath, UnknownUserPlugin, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, build, build as default, defineAdapter, defineConfig, defineLogger, definePlugin, definePrinter, defineStorage, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, setup };
+//#region src/utils/packageJSON.d.ts
+type DependencyName = string;
+type DependencyVersion = string;
+declare function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean;
+//#endregion
+export { Adapter, AdapterFactoryOptions, AdapterSource, BarrelType, type CLIOptions, Config, type ConfigInput, CoreGeneratorV2, DevtoolsOptions, type FileMetaBase, FunctionParams, type FunctionParamsAST, Generator, Group, InputData, InputPath, KubbEvents, Logger, LoggerContext, LoggerOptions, Output, Plugin, PluginContext, PluginDriver, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginParameter, PluginWithLifeCycle, Printer, PrinterFactoryOptions, ReactGeneratorV2, ResolveNameParams, ResolveOptionsContext, ResolvePathParams, Resolver, Storage, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, UserResolver, build, build as default, createAdapter, createPlugin, createStorage, defaultResolveOptions, defineConfig, defineGenerator, defineLogger, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, satisfiesDependency, setup };
 //# sourceMappingURL=index.d.ts.map