@kubb/core 3.0.0-alpha.9 → 3.0.0-beta.10

package/README.md

@@ -13,12 +13,8 @@
 [![Coverage][coverage-src]][coverage-href]
 [![License][license-src]][license-href]
 
-<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-<!-- ALL-CONTRIBUTORS-BADGE:END -->
-</p>
-
 <h4>
-    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/alpha/examples/typescript" target="_blank">View Demo</a>
+    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/main//examples/typescript" target="_blank">View Demo</a>
     <span> · </span>
       <a href="https://kubb.dev/" target="_blank">Documentation</a>
     <span> · </span>
@@ -28,6 +24,19 @@
   </h4>
 </div>
 
+## Supporting Kubb
+
+Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+
+- [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+
+<p align="center">
+  <a href="https://github.com/sponsors/stijnvanhulle">
+    <img src="https://raw.githubusercontent.com/stijnvanhulle/sponsors/main/sponsors.svg" alt="My sponsors" />
+  </a>
+</p>
+
+
 <!-- Badges -->
 
 [npm-version-src]: https://img.shields.io/npm/v/@kubb/core?flat&colorA=18181B&colorB=f58517

package/dist/{FileManager-B0GJlthB.d.cts → FileManager-Cn8nSj1H.d.ts}

@@ -2,16 +2,12 @@ import { write, read } from '@kubb/fs';
 import * as KubbFile from '@kubb/fs/types';
 import { ResolvedFile } from '@kubb/fs/types';
 import { PossiblePromise, GreaterThan } from '@kubb/types';
-import { E as EventEmitter, L as Logger } from './logger-BWFeedRk.cjs';
+import { E as EventEmitter, L as Logger } from './logger-DvbHXjIO.js';
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
-/**
- * Get the type of the first argument in a function.
- * @example Arg0<(a: string, b: number) => void> -> string
- */
-type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
-type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    message: string;
     strategy: Strategy;
     hookName: H;
     plugin: Plugin;
@@ -27,20 +23,20 @@ type Options = {
     logger: Logger;
 };
 type Events = {
-    execute: [executer: Executer];
+    executing: [executer: Executer];
     executed: [executer: Executer];
     error: [error: Error];
 };
 type GetFileProps<TOptions = object> = {
     name: string;
     mode?: KubbFile.Mode;
-    extName: KubbFile.Extname;
+    extname: KubbFile.Extname;
     pluginKey: Plugin['key'];
     options?: TOptions;
 };
 declare class PluginManager {
     #private;
-    readonly plugins: PluginWithLifeCycle[];
+    readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
     readonly fileManager: FileManager;
     readonly events: EventEmitter<Events>;
     readonly config: Config;
@@ -48,7 +44,7 @@ declare class PluginManager {
     readonly logger: Logger;
     readonly options: Options;
     constructor(config: Config, options: Options);
-    getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
+    getFile<TOptions = object>({ name, mode, extname, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
         pluginKey: Plugin['key'];
     }>;
     resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
@@ -60,143 +56,141 @@ declare class PluginManager {
     /**
      * Run a specific hookName for plugin x.
      */
-    hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+    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, }: {
+    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, }: {
+    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, }: {
+    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, }: {
+    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, message, }: {
         hookName: H;
         parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+        message: string;
     }): Promise<Awaited<TOuput>[]>;
-    /**
-     * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
-     */
-    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
-        hookName: H;
-        parameters: PluginParameter<H>;
-        reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>;
-    }): Promise<Argument0<H>>;
     /**
      * Chains plugins
      */
-    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
+    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters, message, }: {
         hookName: H;
         parameters?: PluginParameter<H>;
+        message: string;
     }): Promise<void>;
     getPluginsByKey(hookName: keyof PluginLifecycle, 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"];
 }
 
-interface Cache<TStore extends object = object> {
-    delete(id: keyof TStore): boolean;
-    get(id: keyof TStore): TStore[keyof TStore] | null;
-    has(id: keyof TStore): boolean;
-    set(id: keyof TStore, value: unknown): void;
-}
-
 /**
- * Config used in `kubb.config.js`
+ * Config used in `kubb.config.ts`
  *
- * @example import { defineConfig } from '@kubb/core'
+ * @example
+ * import { defineConfig } from '@kubb/core'
  * export default defineConfig({
  * ...
  * })
  */
 type UserConfig = Omit<Config, 'root' | 'plugins'> & {
     /**
-     * Project root directory. Can be an absolute path, or a path relative from
-     * the location of the config file itself.
+     * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
      * @default process.cwd()
      */
     root?: string;
     /**
-     * Plugin type should be a Kubb plugin
+     * An array of Kubb plugins used for generation. Each plugin may have additional configurable options (defined within the plugin itself). If a plugin relies on another plugin, an error will occur if the required dependency is missing. Refer to “pre” for more details.
      */
     plugins?: Array<Omit<UnknownUserPlugin, 'context'>>;
 };
 type InputPath = {
     /**
-     * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
+     * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
      */
     path: string;
 };
 type InputData = {
     /**
-     * `string` or `object` containing the data.
+     * A `string` or `object` that contains your Swagger/OpenAPI data.
      */
     data: string | unknown;
 };
 type Input = InputPath | InputData;
+type BarrelType = 'all' | 'named';
 /**
  * @private
  */
 type Config<TInput = Input> = {
     /**
-     * Optional config name to show in CLI output
+     * The name to display in the CLI output.
      */
     name?: string;
     /**
-     * Project root directory. Can be an absolute path, or a path relative from
-     * the location of the config file itself.
+     * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
      * @default process.cwd()
      */
     root: string;
+    /**
+     * You can use either `input.path` or `input.data`, depending on your specific needs.
+     */
     input: TInput;
     output: {
         /**
-         * Path to be used to export all generated files.
-         * This can be an absolute path, or a path relative based of the defined `root` option.
+         * The path where all generated files will be exported.
+         * This can be an absolute path or a path relative to the specified root option.
          */
         path: string;
         /**
-         * Clean output directory before each build.
+         * Clean the output directory before each build.
          */
         clean?: boolean;
         /**
-         * Write files to the fileSystem
-         * This is being used for the playground.
+         * Save files to the file system.
          * @default true
          */
         write?: boolean;
         /**
-         * Define what needs to exported, here you can also disable the export of barrel files
-         * @default `'barrelNamed'`
+         * Override the extension to the generated imports and exports, by default each plugin will add an extension
+         * @default { '.ts': '.ts'}
+         */
+        extension?: Record<KubbFile.Extname, KubbFile.Extname>;
+        /**
+         * Specify how `index.ts` files should be created. You can also disable the generation of barrel files here. While each plugin has its own `barrelType` option, this setting controls the creation of the root barrel file, such as` src/gen/index.ts`.
+         * @default 'named'
          */
-        exportType?: 'barrel' | 'barrelNamed' | false;
+        barrelType?: BarrelType | false;
     };
     /**
-     * Array of Kubb plugins to use.
-     * The plugin/package can forsee some options that you need to pass through.
-     * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
+     * An array of Kubb plugins that will be used in the generation.
+     * Each plugin may include additional configurable options(defined in the plugin itself).
+     * If a plugin depends on another plugin, an error will be returned if the required dependency is missing. See pre for more details.
      */
     plugins?: Array<Plugin>;
     /**
@@ -281,21 +275,6 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
      * @private
      */
     key: TOptions['key'];
-    output?: {
-        /**
-         * Output to save the clients.
-         */
-        path: string;
-        /**
-         * Add an extension to the generated imports and exports, default it will not use an extension
-         */
-        extName?: KubbFile.Extname;
-        /**
-         * Define what needs to exported, here you can also disable the export of barrel files
-         * @default `'barrelNamed'`
-         */
-        exportType?: 'barrel' | 'barrelNamed' | false;
-    };
     /**
      * 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.
@@ -327,7 +306,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * @type hookFirst
      * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
      */
-    resolvePath?: (this: PluginContext<TOptions>, baseName: string, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath;
+    resolvePath?: (this: PluginContext<TOptions>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath;
     /**
      * Resolve to a name based on a string.
      * Useful when converting to PascalCase or camelCase.
@@ -343,10 +322,9 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
-type PluginCache = Record<string, [number, unknown]>;
 type ResolvePathParams<TOptions = object> = {
     pluginKey?: Plugin['key'];
-    baseName: string;
+    baseName: KubbFile.BaseName;
     mode?: KubbFile.Mode;
     /**
      * Options to be passed to 'resolvePath' 3th parameter
@@ -358,14 +336,14 @@ type ResolveNameParams = {
     pluginKey?: Plugin['key'];
     /**
      * `file` will be used to customize the name of the created file(use of camelCase)
-     * `function` can be used used to customize the exported functions(use of camelCase)
+     * `function` can be used to customize the exported functions(use of camelCase)
      * `type` is a special type for TypeScript(use of PascalCase)
+     * `const` can be used for variables(use of camelCase)
      */
-    type?: 'file' | 'function' | 'type';
+    type?: 'file' | 'function' | 'type' | 'const';
 };
 type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     config: Config;
-    cache: Cache<PluginCache>;
     fileManager: FileManager;
     pluginManager: PluginManager;
     addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>;
@@ -381,6 +359,41 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
      */
     plugin: Plugin<TOptions>;
 };
+/**
+ * Specify the export location for the files and define the behavior of the output
+ */
+type Output = {
+    /**
+     * Path to the output folder or file that will contain the generated code
+     */
+    path: string;
+    /**
+     * Define what needs to be exported, here you can also disable the export of barrel files
+     * @default 'named'
+     */
+    barrelType?: BarrelType | false;
+    /**
+     * Add a banner text in the beginning of every file
+     */
+    banner?: string;
+    /**
+     * Add a footer text in the beginning of every file
+     */
+    footer?: string;
+};
+type GroupContext = {
+    group: string;
+};
+type Group = {
+    /**
+     * Define a type where to group the files on
+     */
+    type: 'tag';
+    /**
+     * Return the name of a group based on the group name, this will be used for the file and name generation
+     */
+    name?: (context: GroupContext) => string;
+};
 
 type BarrelData = {
     file?: KubbFile.File;
@@ -392,17 +405,19 @@ type BarrelData = {
     name: string;
 };
 declare class TreeNode {
+    #private;
     data: BarrelData;
     parent?: TreeNode;
     children: Array<TreeNode>;
     constructor(data: BarrelData, parent?: TreeNode);
     addChild(data: BarrelData): TreeNode;
-    find(data?: BarrelData): TreeNode | null;
-    get leaves(): Array<TreeNode>;
     get root(): TreeNode;
+    get leaves(): Array<TreeNode>;
     forEach(callback: (treeNode: TreeNode) => void): this;
-    filter(callback: (treeNode: TreeNode) => boolean): Array<TreeNode>;
-    map<T>(callback: (treeNode: TreeNode) => T): Array<T>;
+    findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined;
+    forEachDeep(callback: (treeNode: TreeNode) => void): void;
+    filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode>;
+    mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T>;
     static build(files: KubbFile.File[], root?: string): TreeNode | null;
 }
 type DirectoryTree = {
@@ -417,6 +432,7 @@ type FileMetaBase = {
 };
 type AddResult<T extends Array<KubbFile.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
      */
@@ -427,9 +443,6 @@ type AddIndexesProps = {
      */
     output: {
         path: string;
-        extName?: KubbFile.Extname;
-        exportAs?: string;
-        exportType?: 'barrel' | 'barrelNamed' | false;
     };
     group?: {
         output: string;
@@ -450,10 +463,15 @@ declare class FileManager {
     getCacheById(id: string): KubbFile.File | undefined;
     getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined;
     deleteByPath(path: KubbFile.Path): void;
-    getBarrelFiles({ files, meta, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]>;
+    getBarrelFiles({ type, files, meta, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]>;
     write(...params: Parameters<typeof write>): ReturnType<typeof write>;
     read(...params: Parameters<typeof read>): ReturnType<typeof read>;
     static getMode(path: string | undefined | null): KubbFile.Mode;
 }
+type GetSourceOptions = {
+    extname?: KubbFile.Extname;
+    logger?: Logger;
+};
+declare function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: ResolvedFile<TMeta>, { logger, extname }?: GetSourceOptions): Promise<string>;
 
-export { type Config as C, FileManager as F, type GetPluginFactoryOptions as G, type InputPath as I, type PluginContext as P, type ResolvePathParams as R, type UserConfig as U, PluginManager as a, type PluginFactoryOptions as b, type UserPluginWithLifeCycle as c, type FileMetaBase as d, type InputData as e, type PluginKey as f, type UserPlugin as g, type Plugin as h, type PluginWithLifeCycle as i, type PluginLifecycle as j, type PluginLifecycleHooks as k, type PluginParameter as l, type PluginCache as m, type ResolveNameParams as n };
+export { type BarrelType as B, type Config as C, FileManager as F, type GetPluginFactoryOptions as G, type InputPath as I, type Output as O, type PluginContext as P, type ResolvePathParams as R, type UserConfig as U, PluginManager as a, type PluginFactoryOptions as b, type UserPluginWithLifeCycle as c, type FileMetaBase as d, type InputData as e, type PluginKey as f, getSource as g, type UserPlugin as h, type Plugin as i, type PluginWithLifeCycle as j, type PluginLifecycle as k, type PluginLifecycleHooks as l, type PluginParameter as m, type ResolveNameParams as n, type Group as o };