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

package/dist/FileManager-BW--rO8q.d.ts

@@ -0,0 +1,437 @@
+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 { 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;
+};
+
+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 Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    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$1 = {
+    logger: Logger;
+    /**
+     * Task for the FileManager
+     */
+    task: (file: ResolvedFile) => Promise<ResolvedFile>;
+};
+type Events = {
+    execute: [executer: Executer];
+    executed: [executer: Executer];
+    error: [error: Error];
+};
+type GetFileProps<TOptions = object> = {
+    name: string;
+    mode?: KubbFile.Mode;
+    extName: KubbFile.Extname;
+    pluginKey: Plugin['key'];
+    options?: TOptions;
+};
+declare class PluginManager {
+    #private;
+    readonly plugins: PluginWithLifeCycle[];
+    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<{
+        pluginKey: Plugin['key'];
+    }>;
+    resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.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, }: {
+        pluginKey: Plugin['key'];
+        hookName: H;
+        parameters: PluginParameter<H>;
+    }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
+    /**
+     * Run a specific hookName for plugin x.
+     */
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+        pluginKey: Plugin['key'];
+        hookName: H;
+        parameters: PluginParameter<H>;
+    }): Array<ReturnType<ParseResult<H>>> | null;
+    /**
+     * First non-null result stops and will return it's value.
+     */
+    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: PluginParameter<H>;
+        skipped?: ReadonlySet<Plugin> | null;
+    }): Promise<SafeParseResult<H>>;
+    /**
+     * First non-null result stops and will return it's value.
+     */
+    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: PluginParameter<H>;
+        skipped?: ReadonlySet<Plugin> | null;
+    }): 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, }: {
+        hookName: H;
+        parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+    }): 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 }: {
+        hookName: H;
+        parameters?: PluginParameter<H>;
+    }): 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`
+ *
+ * @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.
+     * @default process.cwd()
+     */
+    root?: string;
+    /**
+     * Plugin type should be a Kubb plugin
+     */
+    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`.
+     */
+    path: string;
+};
+type InputData = {
+    /**
+     * `string` or `object` containing the data.
+     */
+    data: string | unknown;
+};
+type Input = InputPath | InputData;
+/**
+ * @private
+ */
+type Config<TInput = Input> = {
+    /**
+     * Optional config name to show in CLI output
+     */
+    name?: string;
+    /**
+     * Project root directory. Can be an absolute path, or a path relative from
+     * the location of the config file itself.
+     * @default process.cwd()
+     */
+    root: string;
+    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.
+         */
+        path: string;
+        /**
+         * Clean output directory before each build.
+         */
+        clean?: boolean;
+        /**
+         * Write files to the fileSystem
+         * This is being used for the playground.
+         * @default true
+         */
+        write?: boolean;
+    };
+    /**
+     * 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.
+     */
+    plugins?: Array<Plugin>;
+    /**
+     * Hooks that will be called when a specific action is triggered in Kubb.
+     */
+    hooks?: {
+        /**
+         * Hook that will be triggered at the end of all executions.
+         * Useful for running Prettier or ESLint to format/lint your code.
+         */
+        done?: string | Array<string>;
+    };
+};
+type PluginFactoryOptions<
+/**
+ * Name to be used for the plugin, this will also be used for they key.
+ */
+TName extends string = string, 
+/**
+ * Options of the plugin.
+ */
+TOptions extends object = object, 
+/**
+ * Options of the plugin that can be used later on, see `options` inside your plugin config.
+ */
+TResolvedOptions extends object = TOptions, 
+/**
+ * Context that you want to expose to other plugins.
+ */
+TContext = any, 
+/**
+ * When calling `resolvePath` you can specify better types.
+ */
+TResolvePathOptions extends object = object> = {
+    name: TName;
+    /**
+     * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
+     */
+    key: PluginKey<TName | string>;
+    options: TOptions;
+    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> = {
+    /**
+     * 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'];
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    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.
+     */
+    pre?: Array<string>;
+    /**
+     * 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 ? {
+    context?: never;
+} : {
+    context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
+});
+type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>;
+type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+    /**
+     * Unique name used for the plugin
+     * @example @kubb/typescript
+     */
+    name: TOptions['name'];
+    /**
+     * Internal key used when a developer uses more than one of the same plugin
+     * @private
+     */
+    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.
+     */
+    pre?: Array<string>;
+    /**
+     * 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>;
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    options: TOptions['resolvedOptions'];
+} & (TOptions['context'] extends never ? {
+    context?: never;
+} : {
+    context: TOptions['context'];
+});
+type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
+type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+    /**
+     * Start of the lifecycle of a plugin.
+     * @type hookParallel
+     */
+    buildStart?: (this: PluginContext<TOptions>, 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: string, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.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;
+    /**
+     * End of the plugin lifecycle.
+     * @type hookParallel
+     */
+    buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+};
+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;
+    mode?: KubbFile.Mode;
+    /**
+     * Options to be passed to 'resolvePath' 3th parameter
+     */
+    options?: TOptions;
+};
+type ResolveNameParams = {
+    name: string;
+    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)
+     * `type` is a special type for TypeScript(use of PascalCase)
+     */
+    type?: 'file' | 'function' | 'type';
+};
+type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+    config: Config;
+    cache: Cache<PluginCache>;
+    fileManager: FileManager;
+    pluginManager: PluginManager;
+    addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.File>>;
+    resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
+    resolveName: (params: ResolveNameParams) => string;
+    logger: Logger;
+    /**
+     * All plugins
+     */
+    plugins: Plugin[];
+    /**
+     * Current plugin
+     */
+    plugin: Plugin<TOptions>;
+};
+
+type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = File<TMeta, TBaseName> & {
+    /**
+     * @default crypto.randomUUID()
+     */
+    id: UUID;
+    /**
+     * Contains the first part of the baseName, generated based on baseName
+     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     */
+    name: string;
+};
+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 AddIndexesProps = {
+    /**
+     * Root based on root and output.path specified in the config
+     */
+    root: string;
+    /**
+     * 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>;
+};
+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>>;
+    static getMode(path: string | undefined | null): KubbFile.Mode;
+    static get extensions(): Array<KubbFile.Extname>;
+    static isJavascript(baseName: string): boolean;
+}
+
+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 };