@kubb/core 4.1.4 → 4.2.1

package/dist/{PluginManager-a3RiDAFC.d.cts → types-DPeNK0FO.d.ts}

@@ -1,10 +1,156 @@
-import { BaseName, Extname, File, Mode, OptionalPath, Path, ResolvedFile } from "./index-CWX6_-da.cjs";
-import { EventEmitter, Logger } from "./logger-OWS6fqk0.cjs";
+import { a as Mode, i as File, n as BaseName, o as OptionalPath, r as Extname, s as ResolvedFile } from "./index-BTe91LHd.js";
+import { n as Logger, o as EventEmitter } from "./logger-BA-za85-.js";
+import { t as PossiblePromise } from "./types-BzI9JlV8.js";
+import { FileManager } from "@kubb/fabric-core";
 
-//#region src/utils/types.d.ts
-type PossiblePromise<T> = Promise<T> | T;
-type ArrayWithLength<T extends number, U extends any[] = []> = U['length'] extends T ? U : ArrayWithLength<T, [true, ...U]>;
-type GreaterThan<T extends number, U extends number> = ArrayWithLength<U> extends [...ArrayWithLength<T>, ...infer _] ? false : true;
+//#region src/PluginManager.d.ts
+type RequiredPluginLifecycle = Required<PluginLifecycle>;
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
+type Executer<H$1 extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  message: string;
+  strategy: Strategy;
+  hookName: H$1;
+  plugin: Plugin;
+  parameters?: unknown[] | undefined;
+  output?: unknown;
+};
+type ParseResult<H$1 extends PluginLifecycleHooks> = RequiredPluginLifecycle[H$1];
+type SafeParseResult<H$1 extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H$1>>> = {
+  result: Result;
+  plugin: Plugin;
+};
+type Options = {
+  logger: Logger;
+  /**
+   * @default Number.POSITIVE_INFINITY
+   */
+  concurrency?: number;
+};
+type Events = {
+  executing: [executer: Executer];
+  executed: [executer: Executer];
+  error: [error: Error];
+};
+type GetFileProps<TOptions$1 = object> = {
+  name: string;
+  mode?: Mode;
+  extname: Extname;
+  pluginKey: Plugin['key'];
+  options?: TOptions$1;
+};
+declare class PluginManager {
+  #private;
+  readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
+  /**
+   * @deprecated do not use from pluginManager
+   */
+  readonly fileManager: FileManager;
+  readonly events: EventEmitter<Events>;
+  readonly config: Config;
+  readonly executed: Array<Executer>;
+  readonly logger: Logger;
+  readonly options: Options;
+  constructor(config: Config, options: Options);
+  getFile<TOptions = object>({
+    name,
+    mode,
+    extname,
+    pluginKey,
+    options
+  }: GetFileProps<TOptions>): File<{
+    pluginKey: Plugin['key'];
+  }>;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => OptionalPath;
+  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
+  }: {
+    pluginKey: Plugin['key'];
+    hookName: H;
+    parameters: PluginParameter<H>;
+    message: string;
+  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPluginSync<H extends PluginLifecycleHooks>({
+    pluginKey,
+    hookName,
+    parameters,
+    message
+  }: {
+    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.
+   */
+  hookFirst<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped,
+    message
+  }: {
+    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.
+   */
+  hookFirstSync<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped,
+    message
+  }: {
+    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
+  }: {
+    hookName: H;
+    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+    message: string;
+  }): Promise<Awaited<TOuput>[]>;
+  /**
+   * Chains plugins
+   */
+  hookSeq<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    message
+  }: {
+    hookName: H;
+    parameters?: PluginParameter<H>;
+    message: string;
+  }): Promise<void>;
+  getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined;
+  getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
+  static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = (T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>])>(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput;
+  static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "buildEnd"];
+}
 //#endregion
 //#region src/types.d.ts
 /**
@@ -137,11 +283,11 @@ TName extends string = string,
 /**
  * Options of the plugin.
  */
-TOptions extends object = object,
+TOptions$1 extends object = object,
 /**
  * Options of the plugin that can be used later on, see `options` inside your plugin config.
  */
-TResolvedOptions extends object = TOptions,
+TResolvedOptions extends object = TOptions$1,
 /**
  * Context that you want to expose to other plugins.
  */
@@ -155,24 +301,24 @@ TResolvePathOptions extends object = object> = {
    * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
    */
   key: PluginKey<TName | string>;
-  options: TOptions;
+  options: TOptions$1;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
 };
 type PluginKey<TName> = [name: TName, identifier?: string | number];
 type GetPluginFactoryOptions<TPlugin extends UserPlugin> = TPlugin extends UserPlugin<infer X> ? X : never;
-type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type UserPlugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
    * @example @kubb/typescript
    */
-  name: TOptions['name'];
+  name: TOptions$1['name'];
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions['resolvedOptions'];
+  options: TOptions$1['resolvedOptions'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -182,24 +328,24 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
    * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
    */
   post?: Array<string>;
-} & (TOptions['context'] extends never ? {
+} & (TOptions$1['context'] extends never ? {
   context?: never;
 } : {
-  context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
+  context: (this: TOptions$1['name'] extends 'core' ? null : Omit<PluginContext<TOptions$1>, 'addFile'>) => TOptions$1['context'];
 });
-type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type UserPluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions$1> & PluginLifecycle<TOptions$1>;
 type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>;
-type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type Plugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * @example @kubb/typescript
    */
-  name: TOptions['name'];
+  name: TOptions$1['name'];
   /**
    * Internal key used when a developer uses more than one of the same plugin
    * @private
    */
-  key: TOptions['key'];
+  key: TOptions$1['key'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -212,49 +358,49 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions['resolvedOptions'];
-} & (TOptions['context'] extends never ? {
+  options: TOptions$1['resolvedOptions'];
+} & (TOptions$1['context'] extends never ? {
   context?: never;
 } : {
-  context: TOptions['context'];
+  context: TOptions$1['context'];
 });
-type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
-type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions$1> & PluginLifecycle<TOptions$1>;
+type PluginLifecycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Start of the lifecycle of a plugin.
    * @type hookParallel
    */
-  buildStart?: (this: PluginContext<TOptions>, Config: Config) => PossiblePromise<void>;
+  buildStart?: (this: PluginContext<TOptions$1>, Config: Config) => PossiblePromise<void>;
   /**
    * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
    * Options can als be included.
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: BaseName, mode?: Mode, options?: TOptions['resolvePathOptions']) => OptionalPath;
+  resolvePath?: (this: PluginContext<TOptions$1>, baseName: BaseName, mode?: Mode, options?: TOptions$1['resolvePathOptions']) => OptionalPath;
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
    * @type hookFirst
    * @example ('pet') => 'Pet'
    */
-  resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+  resolveName?: (this: PluginContext<TOptions$1>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
   /**
    * End of the plugin lifecycle.
    * @type hookParallel
    */
-  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  buildEnd?: (this: PluginContext<TOptions$1>) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
-type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
-type ResolvePathParams<TOptions = object> = {
+type PluginParameter<H$1 extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H$1]>;
+type ResolvePathParams<TOptions$1 = object> = {
   pluginKey?: Plugin['key'];
   baseName: BaseName;
   mode?: Mode;
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
-  options?: TOptions;
+  options?: TOptions$1;
 };
 type ResolveNameParams = {
   name: string;
@@ -267,12 +413,15 @@ type ResolveNameParams = {
    */
   type?: 'file' | 'function' | 'type' | 'const';
 };
-type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginContext<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config;
+  /**
+   * @deprecated
+   */
   fileManager: FileManager;
   pluginManager: PluginManager;
   addFile: (...file: Array<File>) => Promise<Array<ResolvedFile>>;
-  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => OptionalPath;
+  resolvePath: (params: ResolvePathParams<TOptions$1['resolvePathOptions']>) => OptionalPath;
   resolveName: (params: ResolveNameParams) => string;
   logger: Logger;
   /**
@@ -282,12 +431,12 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   /**
    * Current plugin
    */
-  plugin: Plugin<TOptions>;
+  plugin: Plugin<TOptions$1>;
 };
 /**
  * Specify the export location for the files and define the behavior of the output
  */
-type Output<TOptions> = {
+type Output<TOptions$1> = {
   /**
    * Path to the output folder or file that will contain the generated code
    */
@@ -300,11 +449,11 @@ type Output<TOptions> = {
   /**
    * Add a banner text in the beginning of every file
    */
-  banner?: string | ((options: TOptions) => string);
+  banner?: string | ((options: TOptions$1) => string);
   /**
    * Add a footer text in the beginning of every file
    */
-  footer?: string | ((options: TOptions) => string);
+  footer?: string | ((options: TOptions$1) => string);
 };
 type GroupContext = {
   group: string;
@@ -320,213 +469,5 @@ type Group = {
   name?: (context: GroupContext) => string;
 };
 //#endregion
-//#region src/FileManager.d.ts
-type FileMetaBase = {
-  pluginKey?: Plugin['key'];
-};
-type AddResult<T extends Array<File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>;
-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;
-  };
-  logger?: Logger;
-  meta?: FileMetaBase;
-};
-type WriteFilesProps = {
-  root: Config['root'];
-  extension?: Record<Extname, Extname | ''>;
-  logger?: Logger;
-  dryRun?: boolean;
-};
-declare class FileManager {
-  #private;
-  constructor();
-  add<T extends Array<File> = Array<File>>(...files: T): AddResult<T>;
-  getByPath(path: Path): Promise<ResolvedFile | null>;
-  deleteByPath(path: Path): Promise<void>;
-  clear(): Promise<void>;
-  getFiles(): Promise<Array<ResolvedFile>>;
-  processFiles({
-    dryRun,
-    root,
-    extension,
-    logger
-  }: WriteFilesProps): Promise<Array<ResolvedFile>>;
-  getBarrelFiles({
-    type,
-    meta,
-    root,
-    output,
-    logger
-  }: AddIndexesProps): Promise<File[]>;
-  static getMode(path: string | undefined | null): Mode;
-}
-type GetSourceOptions = {
-  extname?: Extname;
-  logger?: Logger;
-};
-declare function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: ResolvedFile<TMeta>, {
-  logger,
-  extname
-}?: GetSourceOptions): Promise<string>;
-//#endregion
-//#region 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;
-  plugin: Plugin;
-};
-type Options = {
-  logger: Logger;
-  /**
-   * @default Number.POSITIVE_INFINITY
-   */
-  concurrency?: number;
-};
-type Events = {
-  executing: [executer: Executer];
-  executed: [executer: Executer];
-  error: [error: Error];
-};
-type GetFileProps<TOptions = object> = {
-  name: string;
-  mode?: Mode;
-  extname: Extname;
-  pluginKey: Plugin['key'];
-  options?: TOptions;
-};
-declare class PluginManager {
-  #private;
-  readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
-  readonly fileManager: FileManager;
-  readonly events: EventEmitter<Events>;
-  readonly config: Config;
-  readonly executed: Array<Executer>;
-  readonly logger: Logger;
-  readonly options: Options;
-  constructor(config: Config, options: Options);
-  getFile<TOptions = object>({
-    name,
-    mode,
-    extname,
-    pluginKey,
-    options
-  }: GetFileProps<TOptions>): File<{
-    pluginKey: Plugin['key'];
-  }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => OptionalPath;
-  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
-  }: {
-    pluginKey: Plugin['key'];
-    hookName: H;
-    parameters: PluginParameter<H>;
-    message: string;
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPluginSync<H extends PluginLifecycleHooks>({
-    pluginKey,
-    hookName,
-    parameters,
-    message
-  }: {
-    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.
-   */
-  hookFirst<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-    message
-  }: {
-    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.
-   */
-  hookFirstSync<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-    message
-  }: {
-    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
-  }: {
-    hookName: H;
-    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
-    message: string;
-  }): Promise<Awaited<TOuput>[]>;
-  /**
-   * Chains plugins
-   */
-  hookSeq<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    message
-  }: {
-    hookName: H;
-    parameters?: PluginParameter<H>;
-    message: string;
-  }): Promise<void>;
-  getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined;
-  getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
-  static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = (T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>])>(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput;
-  static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "buildEnd"];
-}
-//#endregion
-export { BarrelType, Config, FileManager, FileMetaBase, GetPluginFactoryOptions, Group, InputData, InputPath, Output, Plugin, PluginContext, PluginFactoryOptions, PluginKey, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, PossiblePromise, ResolveNameParams, ResolvePathParams, UserConfig, UserPlugin, UserPluginWithLifeCycle, getSource };
-//# sourceMappingURL=PluginManager-a3RiDAFC.d.cts.map
+export { 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, PluginManager as x, UserPlugin as y };
+//# sourceMappingURL=types-DPeNK0FO.d.ts.map