@kubb/core 3.0.0-alpha.2 → 3.0.0-alpha.20

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-DQtWE_rp.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,15 +24,11 @@ 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];
 };
@@ -55,14 +41,14 @@ type GetFileProps<TOptions = object> = {
 };
 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);
+    readonly options: Options;
+    constructor(config: Config, options: Options);
     getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
         pluginKey: Plugin['key'];
     }>;
@@ -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`
  *
@@ -202,6 +188,11 @@ type Config<TInput = Input> = {
          * @default true
          */
         write?: boolean;
+        /**
+         * Define what needs to exported, here you can also disable the export of barrel files
+         * @default `'barrelNamed'`
+         */
+        exportType?: 'barrel' | 'barrelNamed' | false;
     };
     /**
      * Array of Kubb plugins to use.
@@ -266,7 +257,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 +284,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>;
     /**
@@ -360,10 +351,9 @@ type ResolveNameParams = {
 };
 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 +366,112 @@ 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;
+    /**
+     * Name to be used for the `export * as {{exportAs}} from './'`
+     */
+    exportAs?: 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;
     /**
-     * @default crypto.randomUUID()
+     * Add a footer text in the beginning of every file
      */
-    id: UUID;
+    footer?: string;
     /**
-     * Contains the first part of the baseName, generated based on baseName
-     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     * Add a banner text in the beginning of every file
      */
+    banner?: 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 = {
     /**
      * 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;
+        exportAs?: string;
         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({ 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 = {
+    logger?: Logger;
+};
+declare function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: ResolvedFile<TMeta>, { logger }?: 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 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 PluginCache as n, type ResolveNameParams as o };