@kubb/core 3.0.0-alpha.3 → 3.0.0-alpha.31

package/README.md

@@ -13,10 +13,6 @@
 [![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>
     <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-BW--rO8q.d.ts → FileManager-Dnafk2I5.d.ts}

@@ -1,19 +1,8 @@
-import PQueue from 'p-queue';
 import { write, read } from '@kubb/fs';
 import * as KubbFile from '@kubb/fs/types';
-import { BaseName, File, UUID } from '@kubb/fs/src/types.ts';
+import { ResolvedFile } from '@kubb/fs/types';
 import { PossiblePromise, GreaterThan } from '@kubb/types';
-import { DirectoryTreeOptions } from 'directory-tree';
-import { E as EventEmitter, L as Logger } from './logger-DChjnJMn.js';
-
-type BarrelManagerOptions = {
-    treeNode?: DirectoryTreeOptions;
-    isTypeOnly?: boolean;
-    /**
-     * Add .ts or .js
-     */
-    extName?: KubbFile.Extname;
-};
+import { E as EventEmitter, L as Logger } from './logger-DvbHXjIO.js';
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 /**
@@ -23,6 +12,7 @@ type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    message: string;
     strategy: Strategy;
     hookName: H;
     plugin: Plugin;
@@ -34,36 +24,32 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
     result: Result;
     plugin: Plugin;
 };
-type Options$1 = {
+type Options = {
     logger: Logger;
-    /**
-     * Task for the FileManager
-     */
-    task: (file: ResolvedFile) => Promise<ResolvedFile>;
 };
 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;
     readonly executed: Array<Executer>;
     readonly logger: Logger;
-    readonly queue: PQueue;
-    constructor(config: Config, options: Options$1);
-    getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
+    readonly options: Options;
+    constructor(config: Config, options: Options);
+    getFile<TOptions = object>({ name, mode, extname, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
         pluginKey: Plugin['key'];
     }>;
     resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
@@ -75,69 +61,69 @@ 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>;
-    }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
+        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, }: {
+    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, message, }: {
         hookName: H;
         parameters: PluginParameter<H>;
         reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>;
+        message: string;
     }): 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`
  *
@@ -160,17 +146,20 @@ type UserConfig = Omit<Config, 'root' | 'plugins'> & {
 };
 type InputPath = {
     /**
-     * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
+     * Define your Swagger/OpenAPI file. This can be an absolute path or a path relative to the `root`.
      */
     path: string;
 };
 type InputData = {
     /**
-     * `string` or `object` containing the data.
+     * `string` or `object` containing your Swagger/OpenAPI data.
      */
     data: string | unknown;
 };
 type Input = InputPath | InputData;
+type OutContext = {};
+type OutExtension = (context: OutContext) => Record<KubbFile.Extname, KubbFile.Extname>;
+type BarrelType = 'all' | 'named';
 /**
  * @private
  */
@@ -180,33 +169,43 @@ type Config<TInput = Input> = {
      */
     name?: string;
     /**
-     * Project root directory. Can be an absolute path, or a path relative from
-     * the location of the config file itself.
+     * Project root directory. This can be an absolute path or a path relative to the location of your `kubb.config.ts` file.
      * @default process.cwd()
      */
     root: string;
+    /**
+     * You can use `input.path` or `input.data` depending on the needs you have.
+     */
     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;
+        /**
+         * Override the extension to the generated imports and exports, default the plugin will add an extension
+         * @default `() => ({ '.ts': '.ts'})`
+         */
+        extension?: OutExtension;
+        /**
+         * Define what needs to exported, here you can also disable the export of barrel files.
+         * @default `'named'`
+         */
+        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>;
     /**
@@ -266,7 +265,7 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
     options: TOptions['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 depended plugins.
+     * Can be used to validate dependent plugins.
      */
     pre?: Array<string>;
     /**
@@ -293,7 +292,7 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     key: TOptions['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 depended plugins.
+     * Can be used to validate dependent plugins.
      */
     pre?: Array<string>;
     /**
@@ -322,7 +321,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.
@@ -338,10 +337,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
@@ -356,14 +354,13 @@ type ResolveNameParams = {
      * `function` can be used used to customize the exported functions(use of camelCase)
      * `type` is a special type for TypeScript(use of PascalCase)
      */
-    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.File>>;
+    addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>;
     resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     logger: Logger;
@@ -376,62 +373,119 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
      */
     plugin: Plugin<TOptions>;
 };
-
-type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = File<TMeta, TBaseName> & {
+type Output = {
+    /**
+     * Output to save the generated files.
+     */
+    path: string;
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files.
+     * @default `'named'`
+     */
+    barrelType?: BarrelType | false;
     /**
-     * @default crypto.randomUUID()
+     * Add a banner text in the beginning of every file
      */
-    id: UUID;
+    banner?: string;
     /**
-     * Contains the first part of the baseName, generated based on baseName
-     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     * Add a footer text in the beginning of every file
      */
+    footer?: string;
+};
+type GroupContext = {
+    group: string;
+};
+type Group = {
+    /**
+     * Tag will group based on the operation tag inside the Swagger file
+     */
+    type: 'tag';
+    /**
+     * Relative path to save the grouped clients.
+     *
+     * @example `${output}/{{tag}}Controller` => `clients/PetController`
+     * @default `({ group }) => `${group}Controller``
+     */
+    name?: (context: GroupContext) => string;
+};
+
+type BarrelData = {
+    file?: KubbFile.File;
+    /**
+     * @deprecated use file instead
+     */
+    type: KubbFile.Mode;
+    path: string;
     name: string;
 };
+declare class TreeNode {
+    #private;
+    data: BarrelData;
+    parent?: TreeNode;
+    children: Array<TreeNode>;
+    constructor(data: BarrelData, parent?: TreeNode);
+    addChild(data: BarrelData): TreeNode;
+    get root(): TreeNode;
+    get leaves(): Array<TreeNode>;
+    forEach(callback: (treeNode: TreeNode) => void): this;
+    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 = {
+    name: string;
+    path: string;
+    file?: KubbFile.File;
+    children: Array<DirectoryTree>;
+};
+
 type FileMetaBase = {
     pluginKey?: Plugin['key'];
 };
-type FileWithMeta<TMeta extends FileMetaBase = FileMetaBase> = KubbFile.File<TMeta>;
-type AddResult<T extends Array<FileWithMeta>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>;
+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
      */
     root: string;
+    files: KubbFile.File[];
     /**
      * Output for plugin
      */
     output: {
         path: string;
-        exportAs?: string;
-        extName?: KubbFile.Extname;
-        exportType?: 'barrel' | 'barrelNamed' | false;
     };
-    logger: Logger;
-    options?: BarrelManagerOptions;
-    meta?: FileWithMeta['meta'];
-};
-type Options = {
-    queue?: PQueue;
-    task?: (file: ResolvedFile) => Promise<ResolvedFile>;
+    group?: {
+        output: string;
+        exportAs: string;
+    };
+    logger?: Logger;
+    meta?: FileMetaBase;
 };
 declare class FileManager {
     #private;
-    constructor({ task, queue }?: Options);
-    get files(): Array<FileWithMeta>;
-    get isExecuting(): boolean;
-    add<T extends Array<FileWithMeta> = Array<FileWithMeta>>(...files: T): AddResult<T>;
-    addIndexes({ root, output, meta, logger, options }: AddIndexesProps): Promise<void>;
-    getCacheByUUID(UUID: KubbFile.UUID): FileWithMeta | undefined;
-    get(path: KubbFile.Path): Array<FileWithMeta> | undefined;
-    remove(path: KubbFile.Path): void;
-    write(...params: Parameters<typeof write>): Promise<string | undefined>;
-    read(...params: Parameters<typeof read>): Promise<string>;
-    static getSource<TMeta extends FileMetaBase = FileMetaBase>(file: FileWithMeta<TMeta>): Promise<string>;
-    static combineFiles<TMeta extends FileMetaBase = FileMetaBase>(files: Array<FileWithMeta<TMeta> | null>): Array<FileWithMeta<TMeta>>;
+    constructor();
+    get files(): Array<KubbFile.ResolvedFile>;
+    get orderedFiles(): Array<KubbFile.ResolvedFile>;
+    get groupedFiles(): DirectoryTree | null;
+    get treeNode(): TreeNode | null;
+    add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T>;
+    clear(): void;
+    getCacheById(id: string): KubbFile.File | undefined;
+    getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined;
+    deleteByPath(path: KubbFile.Path): void;
+    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;
-    static get extensions(): Array<KubbFile.Extname>;
-    static isJavascript(baseName: string): boolean;
 }
+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 };