@kubb/core 1.1.4 → 1.1.6

package/dist/index.cjs

@@ -523,6 +523,13 @@ var FileManager = class {
     });
     return files;
   }
+  get cachedFiles() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(item);
+    });
+    return files;
+  }
   async add(file) {
     const cacheItem = { id: crypto__default.default.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
@@ -627,7 +634,7 @@ var PluginManager = class {
     return this.hookFirstSync({
       hookName: "resolvePath",
       parameters: [params.fileName, params.directory, params.options]
-    });
+    }).result;
   };
   resolveName = (params) => {
     if (params.pluginName) {
@@ -640,7 +647,7 @@ var PluginManager = class {
     return this.hookFirstSync({
       hookName: "resolveName",
       parameters: [params.name]
-    });
+    }).result;
   };
   load = async (id) => {
     return this.hookFirst({
@@ -691,15 +698,20 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      promise = promise.then((result) => {
-        if (result != null)
-          return result;
-        return this.execute({
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult;
+        }
+        const value = await this.execute({
           strategy: "hookFirst",
           hookName,
           parameters,
           plugin
         });
+        return Promise.resolve({
+          plugin,
+          result: value
+        });
       });
     }
     return promise;
@@ -713,43 +725,38 @@ var PluginManager = class {
     parameters,
     skipped
   }) {
-    let result = null;
+    let parseResult = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = this.executeSync({
-        strategy: "hookFirst",
-        hookName,
-        parameters,
+      parseResult = {
+        result: this.executeSync({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        }),
         plugin
-      });
-      if (result != null) {
+      };
+      if (parseResult?.result != null) {
         break;
       }
     }
-    return result;
+    return parseResult;
   }
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel({
     hookName,
     parameters
   }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (plugin[hookName]?.sequential) {
-        await Promise.all(parallelPromises);
-        parallelPromises.length = 0;
-        await this.execute({
-          strategy: "hookParallel",
-          hookName,
-          parameters,
-          plugin
-        });
-      } else {
-        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
-        if (promise) {
-          parallelPromises.push(promise);
-        }
+      const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+      if (promise) {
+        parallelPromises.push(promise);
       }
     }
     const results = await Promise.allSettled(parallelPromises);
@@ -759,7 +766,10 @@ var PluginManager = class {
     }
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
-  // chains, reduces returned value, handling the reduced value as the first hook argument
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
   hookReduceArg0({
     hookName,
     parameters,
@@ -768,11 +778,11 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then((argument02) => {
+      promise = promise.then((arg0) => {
         const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
-          parameters: [argument02, ...rest],
+          parameters: [arg0, ...rest],
           plugin
         });
         return value;
@@ -780,7 +790,9 @@ var PluginManager = class {
     }
     return promise;
   }
-  // chains
+  /**
+   * Chains plugins
+   */
   hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -796,7 +808,7 @@ var PluginManager = class {
     return promise.then(noReturn);
   }
   getSortedPlugins(_hookName) {
-    const plugins = [...this.plugins];
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
     return plugins;
   }
   getPlugin(hookName, pluginName) {
@@ -1060,9 +1072,6 @@ ${source}`;
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
-  if (result === null) {
-    return null;
-  }
   return result;
 }
 async function build(options) {
@@ -1080,11 +1089,14 @@ async function build(options) {
   const queueTask = async (id, file) => {
     const { path } = file;
     let code = getFileSource(file);
-    const loadedResult = await pluginManager.hookFirst({
+    const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
       parameters: [path]
     });
-    if (loadedResult) {
+    if (loadedResult && isPromise(loadedResult)) {
+      code = await loadedResult;
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
       code = loadedResult;
     }
     if (code) {

package/dist/index.d.ts

@@ -124,11 +124,12 @@ declare class FileManager {
     private queue?;
     constructor(options?: {
         queue: Queue;
-        task: QueueTask<unknown>;
+        task?: QueueTask<unknown>;
     });
     private getCache;
     getCacheByPath(path: string | undefined): CacheStore | undefined;
     get files(): File[];
+    get cachedFiles(): CacheStore[];
     add(file: File): Promise<File>;
     addOrAppend(file: File): Promise<File>;
     setStatus(id: UUID, status: Status): void;
@@ -154,22 +155,14 @@ type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
     plugin: KubbPlugin;
 };
 type OnExecute<H extends PluginLifecycleHooks = PluginLifecycleHooks> = (this: PluginManager, executer: Executer<H> | undefined) => void;
-
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbPlugin<T>> : KubbPlugin<T>;
-declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => T["nested"] extends true ? KubbPlugin<T>[] : KubbPlugin<T>;
-type Options$1 = {
-    config: PluginContext['config'];
-    fileManager: FileManager;
-    resolvePath: PluginContext['resolvePath'];
-    resolveName: PluginContext['resolveName'];
-    load: PluginContext['load'];
-    getExecuter: () => Executer<PluginLifecycleHooks> | undefined;
+type ParseResult<H extends PluginLifecycleHooks> = PluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+    result: Result;
+    plugin: KubbPlugin;
 };
-type CorePluginOptions = PluginFactoryOptions<Options$1, false, PluginContext>;
-declare const name: "core";
 
 declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<unknown, false, any, Record<string, any>>>];
-type Options = {
+type Options$1 = {
     task: QueueTask;
     onExecute?: OnExecute<PluginLifecycleHooks>;
 };
@@ -177,15 +170,15 @@ declare class PluginManager {
     plugins: KubbPlugin[];
     readonly fileManager: FileManager;
     private readonly onExecute?;
-    readonly core: KubbPlugin<CorePluginOptions>;
+    private readonly core;
     queue: Queue;
     executer: Executer | undefined;
     executed: Executer[];
-    constructor(config: KubbConfig, options: Options);
+    constructor(config: KubbConfig, options: Options$1);
     getExecuter(): Executer | undefined;
     resolvePath: (params: ResolvePathParams) => OptionalPath;
     resolveName: (params: ResolveNameParams) => string | null;
-    load: (id: string) => Promise<TransformResult>;
+    load: (id: string) => Promise<SafeParseResult<"load">>;
     /**
      *
      * Run only hook for a specific plugin name
@@ -194,12 +187,12 @@ declare class PluginManager {
         pluginName: string;
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
-    }): Promise<ReturnType<PluginLifecycle[H]> | null> | null;
+    }): Promise<ReturnType<ParseResult<H>> | null> | null;
     hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
         pluginName: string;
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
-    }): ReturnType<PluginLifecycle[H]> | null;
+    }): ReturnType<ParseResult<H>> | null;
     /**
      *
      * Chains, first non-null result stops and returns
@@ -208,7 +201,7 @@ declare class PluginManager {
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
         skipped?: ReadonlySet<KubbPlugin> | null;
-    }): Promise<ReturnType<PluginLifecycle[H]>>;
+    }): Promise<SafeParseResult<H>>;
     /**
      *
      * Chains, first non-null result stops and returns
@@ -217,22 +210,33 @@ declare class PluginManager {
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
         skipped?: ReadonlySet<KubbPlugin> | null;
-    }): ReturnType<PluginLifecycle[H]>;
+    }): SafeParseResult<H>;
+    /**
+     *
+     * Parallel, runs all plugins
+     */
     hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
         hookName: H;
         parameters?: Parameters<PluginLifecycle[H]> | undefined;
     }): Promise<Awaited<TOuput>[]>;
+    /**
+     *
+     * Chains, reduces returned value, handling the reduced value as the first hook argument
+     */
     hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
-        reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
+        reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
     }): Promise<Argument0<H>>;
+    /**
+     * Chains plugins
+     */
     hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
         hookName: H;
         parameters?: Parameters<PluginLifecycle[H]>;
     }): Promise<void>;
     private getSortedPlugins;
-    private getPlugin;
+    getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin;
     private addExecuter;
     /**
      * Run an async plugin hook and return the result.
@@ -490,7 +494,7 @@ type PluginContext<TOptions = Record<string, any>> = {
     addFile: (...file: File[]) => Promise<File[]>;
     resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath;
     resolveName: (params: ResolveNameParams) => string | null | undefined;
-    load: (id: string) => MaybePromise<TransformResult | void>;
+    load: (id: string) => Promise<SafeParseResult<'load'>>;
 };
 type TransformResult = string | null;
 /**
@@ -518,6 +522,19 @@ declare function build(options: BuildOptions): Promise<BuildOutput>;
  */
 declare const defineConfig: (options: MaybePromise<KubbUserConfig> | ((cliOptions: CLIOptions) => MaybePromise<KubbUserConfig>)) => MaybePromise<KubbUserConfig> | ((cliOptions: CLIOptions) => MaybePromise<KubbUserConfig>);
 
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbPlugin<T>> : KubbPlugin<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => T["nested"] extends true ? KubbPlugin<T>[] : KubbPlugin<T>;
+type Options = {
+    config: PluginContext['config'];
+    fileManager: FileManager;
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
+    load: PluginContext['load'];
+    getExecuter: () => Executer<PluginLifecycleHooks> | undefined;
+};
+type CorePluginOptions = PluginFactoryOptions<Options, false, PluginContext>;
+declare const name: "core";
+
 /**
  * Abstract class that contains the building blocks for plugins to create their own Generator
  * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
@@ -536,4 +553,4 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-export { Argument0, BuildOutput, CLIOptions, Cache, CacheStore, CorePluginOptions, Executer, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, Logger, MaybePromise, OnExecute, OptionalPath, ParallelPluginError, Path, PathMode, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
+export { Argument0, BuildOutput, CLIOptions, Cache, CacheStore, CorePluginOptions, Executer, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, Logger, MaybePromise, OnExecute, OptionalPath, ParallelPluginError, ParseResult, Path, PathMode, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SafeParseResult, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };

package/dist/index.js

@@ -513,6 +513,13 @@ var FileManager = class {
     });
     return files;
   }
+  get cachedFiles() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(item);
+    });
+    return files;
+  }
   async add(file) {
     const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
@@ -617,7 +624,7 @@ var PluginManager = class {
     return this.hookFirstSync({
       hookName: "resolvePath",
       parameters: [params.fileName, params.directory, params.options]
-    });
+    }).result;
   };
   resolveName = (params) => {
     if (params.pluginName) {
@@ -630,7 +637,7 @@ var PluginManager = class {
     return this.hookFirstSync({
       hookName: "resolveName",
       parameters: [params.name]
-    });
+    }).result;
   };
   load = async (id) => {
     return this.hookFirst({
@@ -681,15 +688,20 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      promise = promise.then((result) => {
-        if (result != null)
-          return result;
-        return this.execute({
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult;
+        }
+        const value = await this.execute({
           strategy: "hookFirst",
           hookName,
           parameters,
           plugin
         });
+        return Promise.resolve({
+          plugin,
+          result: value
+        });
       });
     }
     return promise;
@@ -703,43 +715,38 @@ var PluginManager = class {
     parameters,
     skipped
   }) {
-    let result = null;
+    let parseResult = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = this.executeSync({
-        strategy: "hookFirst",
-        hookName,
-        parameters,
+      parseResult = {
+        result: this.executeSync({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        }),
         plugin
-      });
-      if (result != null) {
+      };
+      if (parseResult?.result != null) {
         break;
       }
     }
-    return result;
+    return parseResult;
   }
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel({
     hookName,
     parameters
   }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (plugin[hookName]?.sequential) {
-        await Promise.all(parallelPromises);
-        parallelPromises.length = 0;
-        await this.execute({
-          strategy: "hookParallel",
-          hookName,
-          parameters,
-          plugin
-        });
-      } else {
-        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
-        if (promise) {
-          parallelPromises.push(promise);
-        }
+      const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+      if (promise) {
+        parallelPromises.push(promise);
       }
     }
     const results = await Promise.allSettled(parallelPromises);
@@ -749,7 +756,10 @@ var PluginManager = class {
     }
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
-  // chains, reduces returned value, handling the reduced value as the first hook argument
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
   hookReduceArg0({
     hookName,
     parameters,
@@ -758,11 +768,11 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then((argument02) => {
+      promise = promise.then((arg0) => {
         const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
-          parameters: [argument02, ...rest],
+          parameters: [arg0, ...rest],
           plugin
         });
         return value;
@@ -770,7 +780,9 @@ var PluginManager = class {
     }
     return promise;
   }
-  // chains
+  /**
+   * Chains plugins
+   */
   hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -786,7 +798,7 @@ var PluginManager = class {
     return promise.then(noReturn);
   }
   getSortedPlugins(_hookName) {
-    const plugins = [...this.plugins];
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
     return plugins;
   }
   getPlugin(hookName, pluginName) {
@@ -1050,9 +1062,6 @@ ${source}`;
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
-  if (result === null) {
-    return null;
-  }
   return result;
 }
 async function build(options) {
@@ -1070,11 +1079,14 @@ async function build(options) {
   const queueTask = async (id, file) => {
     const { path } = file;
     let code = getFileSource(file);
-    const loadedResult = await pluginManager.hookFirst({
+    const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
       parameters: [path]
     });
-    if (loadedResult) {
+    if (loadedResult && isPromise(loadedResult)) {
+      code = await loadedResult;
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
       code = loadedResult;
     }
     if (code) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Generator core",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "change-case": "^4.1.2",
     "directory-tree": "^3.5.1",
     "rimraf": "^5.0.1",
-    "@kubb/ts-codegen": "1.1.4"
+    "@kubb/ts-codegen": "1.1.6"
   },
   "devDependencies": {
     "tsup": "^6.7.0",
@@ -55,7 +55,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "engines": {
-    "node": ">=16",
+    "node": ">=18",
     "pnpm": ">=8"
   },
   "scripts": {

package/src/build.ts

@@ -2,6 +2,7 @@
 import { PluginManager } from './managers/pluginManager/index.ts'
 import { clean, isURL, read } from './utils/index.ts'
 import { getFileSource } from './managers/fileManager/index.ts'
+import { isPromise } from './utils/isPromise.ts'
 
 import type { OnExecute } from './managers/pluginManager/index.ts'
 import type { File } from './managers/fileManager/index.ts'
@@ -24,9 +25,6 @@ async function transformReducer(
   result: TransformResult | Promise<TransformResult>,
   _plugin: KubbPlugin
 ): Promise<string | null> {
-  if (result === null) {
-    return null
-  }
   return result
 }
 
@@ -48,13 +46,16 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
   const queueTask = async (id: string, file: File) => {
     const { path } = file
 
-    let code = getFileSource(file)
+    let code: string | null = getFileSource(file)
 
-    const loadedResult = await pluginManager.hookFirst({
+    const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: 'load',
       parameters: [path],
     })
-    if (loadedResult) {
+    if (loadedResult && isPromise(loadedResult)) {
+      code = await loadedResult
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
       code = loadedResult
     }
 

package/src/managers/fileManager/FileManager.ts

@@ -12,7 +12,7 @@ export class FileManager {
 
   private queue?: Queue
 
-  constructor(options?: { queue: Queue; task: QueueTask<unknown> }) {
+  constructor(options?: { queue: Queue; task?: QueueTask<unknown> }) {
     if (options) {
       this.task = options.task
       this.queue = options.queue
@@ -43,6 +43,15 @@ export class FileManager {
     return files
   }
 
+  get cachedFiles() {
+    const files: CacheStore[] = []
+    this.cache.forEach((item) => {
+      files.push(item)
+    })
+
+    return files
+  }
+
   async add(file: File) {
     const cacheItem = { id: crypto.randomUUID(), file, status: 'new' as Status }
 

package/src/managers/pluginManager/PluginManager.ts

@@ -11,7 +11,7 @@ import { Queue } from '../../utils/Queue.ts'
 import { isPromise } from '../../utils/isPromise.ts'
 
 import type { QueueTask } from '../../utils/Queue.ts'
-import type { Argument0, Strategy, Executer, OnExecute } from './types.ts'
+import type { Argument0, Strategy, Executer, OnExecute, ParseResult, SafeParseResult } from './types.ts'
 import type { KubbConfig, KubbPlugin, PluginLifecycleHooks, PluginLifecycle, MaybePromise, ResolvePathParams, ResolveNameParams } from '../../types.ts'
 import type { CorePluginOptions } from '../../plugin.ts'
 
@@ -41,7 +41,7 @@ export class PluginManager {
 
   private readonly onExecute?: OnExecute
 
-  public readonly core: KubbPlugin<CorePluginOptions>
+  private readonly core: KubbPlugin<CorePluginOptions>
 
   public queue: Queue
 
@@ -82,7 +82,7 @@ export class PluginManager {
     return this.hookFirstSync({
       hookName: 'resolvePath',
       parameters: [params.fileName, params.directory, params.options],
-    })
+    }).result
   }
 
   resolveName = (params: ResolveNameParams) => {
@@ -96,7 +96,7 @@ export class PluginManager {
     return this.hookFirstSync({
       hookName: 'resolveName',
       parameters: [params.name],
-    })
+    }).result
   }
 
   load = async (id: string) => {
@@ -118,7 +118,7 @@ export class PluginManager {
     pluginName: string
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
-  }): Promise<ReturnType<PluginLifecycle[H]> | null> | null {
+  }): Promise<ReturnType<ParseResult<H>> | null> | null {
     const plugin = this.getPlugin(hookName, pluginName)
 
     return this.execute({
@@ -137,7 +137,7 @@ export class PluginManager {
     pluginName: string
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
-  }): ReturnType<PluginLifecycle[H]> | null {
+  }): ReturnType<ParseResult<H>> | null {
     const plugin = this.getPlugin(hookName, pluginName)
 
     return this.executeSync({
@@ -160,20 +160,29 @@ export class PluginManager {
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
     skipped?: ReadonlySet<KubbPlugin> | null
-  }): Promise<ReturnType<PluginLifecycle[H]>> {
-    let promise: Promise<ReturnType<PluginLifecycle[H]>> = Promise.resolve(null as ReturnType<PluginLifecycle[H]>)
+  }): Promise<SafeParseResult<H>> {
+    let promise: Promise<SafeParseResult<H>> = Promise.resolve(null as any)
+
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin)) continue
-      promise = promise.then((result) => {
-        if (result != null) return result
-        return this.execute({
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult
+        }
+        const value = await this.execute<H>({
           strategy: 'hookFirst',
           hookName,
           parameters,
           plugin,
-        }) as typeof result
+        })
+
+        return Promise.resolve({
+          plugin,
+          result: value,
+        } as typeof parseResult)
       })
     }
+
     return promise
   }
 
@@ -189,27 +198,33 @@ export class PluginManager {
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
     skipped?: ReadonlySet<KubbPlugin> | null
-  }): ReturnType<PluginLifecycle[H]> {
-    let result = null
+  }): SafeParseResult<H> {
+    let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
 
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin)) continue
 
-      result = this.executeSync<H>({
-        strategy: 'hookFirst',
-        hookName,
-        parameters,
+      parseResult = {
+        result: this.executeSync<H>({
+          strategy: 'hookFirst',
+          hookName,
+          parameters,
+          plugin,
+        }),
         plugin,
-      })
+      } as SafeParseResult<H>
 
-      if (result != null) {
+      if (parseResult?.result != null) {
         break
       }
     }
-    return result as ReturnType<PluginLifecycle[H]>
+    return parseResult as SafeParseResult<H>
   }
 
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
     hookName,
     parameters,
@@ -220,21 +235,21 @@ export class PluginManager {
     const parallelPromises: Promise<TOuput>[] = []
 
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
-        await Promise.all(parallelPromises)
-        parallelPromises.length = 0
-        await this.execute({
-          strategy: 'hookParallel',
-          hookName,
-          parameters,
-          plugin,
-        })
-      } else {
-        const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
-
-        if (promise) {
-          parallelPromises.push(promise)
-        }
+      // TODO implement sequential with `buildStart` as an object({ sequential: boolean; handler: PluginContext["buildStart"] })
+      // if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
+      //   await Promise.all(parallelPromises)
+      //   parallelPromises.length = 0
+      //   await this.execute({
+      //     strategy: 'hookParallel',
+      //     hookName,
+      //     parameters,
+      //     plugin,
+      //   })
+      // }
+      const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
+
+      if (promise) {
+        parallelPromises.push(promise)
       }
     }
     const results = await Promise.allSettled(parallelPromises)
@@ -247,7 +262,10 @@ export class PluginManager {
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
-  // chains, reduces returned value, handling the reduced value as the first hook argument
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
   hookReduceArg0<H extends PluginLifecycleHooks>({
     hookName,
     parameters,
@@ -255,29 +273,30 @@ export class PluginManager {
   }: {
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
-    reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>
+    reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>
   }): Promise<Argument0<H>> {
     const [argument0, ...rest] = parameters
 
     let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise
-        .then((argument0) => {
+        .then((arg0) => {
           const value = this.execute({
             strategy: 'hookReduceArg0',
             hookName,
-            parameters: [argument0, ...rest] as Parameters<PluginLifecycle[H]>,
+            parameters: [arg0, ...rest] as Parameters<PluginLifecycle[H]>,
             plugin,
           })
           return value
         })
-        .then((result) => reduce.call(this.core.api, argument0, result as ReturnType<PluginLifecycle[H]>, plugin)) as Promise<Argument0<H>>
+        .then((result) => reduce.call(this.core.api, argument0, result as ReturnType<ParseResult<H>>, plugin)) as Promise<Argument0<H>>
     }
     return promise
   }
 
-  // chains
-
+  /**
+   * Chains plugins
+   */
   hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: Parameters<PluginLifecycle[H]> }) {
     let promise: Promise<void | null> = Promise.resolve()
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -294,12 +313,12 @@ export class PluginManager {
   }
 
   private getSortedPlugins(_hookName: keyof PluginLifecycle): KubbPlugin[] {
-    const plugins = [...this.plugins]
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
 
     return plugins
   }
 
-  private getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin {
+  public getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin {
     const plugins = [...this.plugins]
 
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName])
@@ -400,7 +419,7 @@ export class PluginManager {
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
     plugin: KubbPlugin
-  }): ReturnType<PluginLifecycle[H]> | null {
+  }): ReturnType<ParseResult<H>> | null {
     const hook = plugin[hookName]
 
     if (!hook) {
@@ -438,7 +457,7 @@ export class PluginManager {
     } catch (e) {
       this.catcher<H>(e as Error, plugin, hookName)
 
-      return null as ReturnType<PluginLifecycle[H]>
+      return null as ReturnType<ParseResult<H>>
     }
   }
 

package/src/managers/pluginManager/types.ts

@@ -15,3 +15,10 @@ export type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
 }
 
 export type OnExecute<H extends PluginLifecycleHooks = PluginLifecycleHooks> = (this: PluginManager, executer: Executer<H> | undefined) => void
+
+export type ParseResult<H extends PluginLifecycleHooks> = PluginLifecycle[H]
+
+export type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+  result: Result
+  plugin: KubbPlugin
+}

package/src/types.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-empty-interface */
-import type { PluginManager } from './managers/index.ts'
+import type { PluginManager, SafeParseResult } from './managers/index.ts'
 import type { FileManager, File } from './managers/fileManager/index.ts'
 import type { Cache } from './utils/cache.ts'
 
@@ -237,7 +237,7 @@ export type PluginContext<TOptions = Record<string, any>> = {
   addFile: (...file: File[]) => Promise<File[]>
   resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath
   resolveName: (params: ResolveNameParams) => string | null | undefined
-  load: (id: string) => MaybePromise<TransformResult | void>
+  load: (id: string) => Promise<SafeParseResult<'load'>>
 }
 
 // null will mean clear the watcher for this key