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

package/dist/index.js

@@ -1,35 +1,22 @@
-import {
-  EventEmitter,
-  LogLevel,
-  createLogger,
-  p,
-  randomCliColour
-} from "./chunk-3OXCZ5DJ.js";
-import {
-  FileManager
-} from "./chunk-SA2GZKXS.js";
 import {
   transformReservedWord
-} from "./chunk-JKZG2IJR.js";
+} from "./chunk-2EU7DMPM.js";
 import {
+  EventEmitter,
+  createLogger
+} from "./chunk-MU3CBCQT.js";
+import {
+  FileManager,
   URLPath,
+  processFiles,
   setUniqueName
-} from "./chunk-5JZNFPUP.js";
+} from "./chunk-L6YLVCKM.js";
 import "./chunk-4X5FFJPJ.js";
-import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet
-} from "./chunk-HMLY7DHA.js";
+import "./chunk-HBQM723K.js";
 
 // src/build.ts
 import { clean, read } from "@kubb/fs";
 
-// src/PluginManager.ts
-import PQueue from "p-queue";
-import { readSync } from "@kubb/fs";
-
 // src/utils/executeStrategies.ts
 function hookSeq(promises) {
   return promises.filter(Boolean).reduce(
@@ -65,11 +52,10 @@ function hookParallel(promises) {
 }
 
 // src/PromiseManager.ts
-var _options;
 var PromiseManager = class {
+  #options = {};
   constructor(options = {}) {
-    __privateAdd(this, _options, {});
-    __privateSet(this, _options, options);
+    this.#options = options;
     return this;
   }
   run(strategy, promises) {
@@ -77,7 +63,7 @@ var PromiseManager = class {
       return hookSeq(promises);
     }
     if (strategy === "first") {
-      return hookFirst(promises, __privateGet(this, _options).nullCheck);
+      return hookFirst(promises, this.#options.nullCheck);
     }
     if (strategy === "parallel") {
       return hookParallel(promises);
@@ -85,7 +71,6 @@ var PromiseManager = class {
     throw new Error(`${strategy} not implemented`);
   }
 };
-_options = new WeakMap();
 function isPromise(result) {
   return !!result && typeof result?.then === "function";
 }
@@ -94,17 +79,11 @@ function isPromiseRejectedResult(result) {
 }
 
 // src/errors.ts
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
-  }
-};
 var ValidationPluginError = class extends Error {
 };
 
 // src/plugin.ts
-import path from "path";
+import path from "node:path";
 
 // src/utils/cache.ts
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
@@ -146,7 +125,7 @@ var pluginCore = createPlugin((options) => {
     name: "core",
     options,
     key: ["core"],
-    api() {
+    context() {
       return {
         get config() {
           return options.config;
@@ -173,7 +152,7 @@ var pluginCore = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path);
+      const root = path.resolve(options.config.root, options.config.output.path);
       return path.resolve(root, baseName);
     },
     resolveName(name) {
@@ -183,74 +162,25 @@ var pluginCore = createPlugin((options) => {
 });
 
 // src/PluginManager.ts
-var _core, _usedPluginNames, _promiseManager, _PluginManager_instances, getSortedPlugins_fn, addExecutedToCallStack_fn, execute_fn, executeSync_fn, catcher_fn, parse_fn;
 var PluginManager = class {
+  plugins;
+  fileManager;
+  events = new EventEmitter();
+  config;
+  executed = [];
+  logger;
+  options;
+  #core;
+  #usedPluginNames = {};
+  #promiseManager;
   constructor(config, options) {
-    __privateAdd(this, _PluginManager_instances);
-    this.events = new EventEmitter();
-    this.executed = [];
-    __privateAdd(this, _core);
-    __privateAdd(this, _usedPluginNames, {});
-    __privateAdd(this, _promiseManager);
-    this.resolvePath = (params) => {
-      if (params.pluginKey) {
-        const paths = this.hookForPluginSync({
-          pluginKey: params.pluginKey,
-          hookName: "resolvePath",
-          parameters: [params.baseName, params.mode, params.options]
-        });
-        if (paths && paths?.length > 1) {
-          this.logger.emit("debug", [
-            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Paths: ${JSON.stringify(paths, void 0, 2)}
-
-Falling back on the first item.
-`
-          ]);
-        }
-        return paths?.at(0);
-      }
-      return this.hookFirstSync({
-        hookName: "resolvePath",
-        parameters: [params.baseName, params.mode, params.options]
-      }).result;
-    };
-    this.resolveName = (params) => {
-      if (params.pluginKey) {
-        const names = this.hookForPluginSync({
-          pluginKey: params.pluginKey,
-          hookName: "resolveName",
-          parameters: [params.name, params.type]
-        });
-        if (names && names?.length > 1) {
-          this.logger.emit("debug", [
-            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Names: ${JSON.stringify(names, void 0, 2)}
-
-Falling back on the first item.
-`
-          ]);
-        }
-        return transformReservedWord(names?.at(0) || params.name);
-      }
-      const name = this.hookFirstSync({
-        hookName: "resolveName",
-        parameters: [params.name, params.type]
-      }).result;
-      return transformReservedWord(name);
-    };
     this.config = config;
+    this.options = options;
     this.logger = options.logger;
-    this.queue = new PQueue({ concurrency: 1 });
-    this.fileManager = new FileManager({
-      task: options.task,
-      queue: this.queue
-    });
-    __privateSet(this, _promiseManager, new PromiseManager({
+    this.fileManager = new FileManager();
+    this.#promiseManager = new PromiseManager({
       nullCheck: (state) => !!state?.result
-    }));
+    });
     const plugins = config.plugins || [];
     const core = pluginCore({
       config,
@@ -259,34 +189,89 @@ Falling back on the first item.
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).bind(this)
+      getPlugins: this.#getSortedPlugins.bind(this)
     });
-    __privateSet(this, _core, __privateMethod(this, _PluginManager_instances, parse_fn).call(this, core, this, core.api.call(null)));
-    this.plugins = [__privateGet(this, _core), ...plugins].map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, parse_fn).call(this, plugin, this, __privateGet(this, _core).api);
+    this.#core = this.#parse(core, this, core.context.call(null));
+    this.plugins = [this.#core, ...plugins].map((plugin) => {
+      return this.#parse(plugin, this, this.#core.context);
     });
     return this;
   }
   getFile({ name, mode, extName, pluginKey, options }) {
-    let source = "";
     const baseName = `${name}${extName}`;
     const path2 = this.resolvePath({ baseName, mode, pluginKey, options });
     if (!path2) {
       throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
     }
-    try {
-      source = readSync(path2);
-    } catch (_e) {
-    }
     return {
       path: path2,
       baseName,
       meta: {
         pluginKey
       },
-      source
+      sources: []
     };
   }
+  resolvePath = (params) => {
+    if (params.pluginKey) {
+      const paths = this.hookForPluginSync({
+        pluginKey: params.pluginKey,
+        hookName: "resolvePath",
+        parameters: [params.baseName, params.mode, params.options],
+        message: `Resolving path '${params.baseName}'`
+      });
+      if (paths && paths?.length > 1) {
+        this.logger.emit("debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [
+            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Paths: ${JSON.stringify(paths, void 0, 2)}
+
+Falling back on the first item.
+`
+          ]
+        });
+      }
+      return paths?.at(0);
+    }
+    return this.hookFirstSync({
+      hookName: "resolvePath",
+      parameters: [params.baseName, params.mode, params.options],
+      message: `Resolving path '${params.baseName}'`
+    }).result;
+  };
+  //TODO refactor by using the order of plugins and the cache of the fileManager instead of guessing and recreating the name/path
+  resolveName = (params) => {
+    if (params.pluginKey) {
+      const names = this.hookForPluginSync({
+        pluginKey: params.pluginKey,
+        hookName: "resolveName",
+        parameters: [params.name, params.type],
+        message: `Resolving name '${params.name}' and type '${params.type}'`
+      });
+      if (names && names?.length > 1) {
+        this.logger.emit("debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [
+            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Names: ${JSON.stringify(names, void 0, 2)}
+
+Falling back on the first item.
+`
+          ]
+        });
+      }
+      return transformReservedWord(names?.at(0) || params.name);
+    }
+    const name = this.hookFirstSync({
+      hookName: "resolveName",
+      parameters: [params.name, params.type],
+      message: `Resolving name '${params.name}' and type '${params.type}'`
+    }).result;
+    return transformReservedWord(name);
+  };
   /**
    * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
    */
@@ -296,21 +281,26 @@ Falling back on the first item.
   /**
    * Run a specific hookName for plugin x.
    */
-  hookForPlugin({
+  async hookForPlugin({
     pluginKey,
     hookName,
-    parameters
+    parameters,
+    message
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
+    this.logger.emit("progress_start", { id: hookName, size: plugins.length, message: "Running plugins..." });
     const promises = plugins.map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+      return this.#execute({
         strategy: "hookFirst",
         hookName,
         parameters,
-        plugin
+        plugin,
+        message
       });
     }).filter(Boolean);
-    return Promise.all(promises);
+    const items = await Promise.all(promises);
+    this.logger.emit("progress_stop", { id: hookName });
+    return items;
   }
   /**
    * Run a specific hookName for plugin x.
@@ -318,17 +308,20 @@ Falling back on the first item.
   hookForPluginSync({
     pluginKey,
     hookName,
-    parameters
+    parameters,
+    message
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
-    return plugins.map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, executeSync_fn).call(this, {
+    const result = plugins.map((plugin) => {
+      return this.#executeSync({
         strategy: "hookFirst",
         hookName,
         parameters,
-        plugin
+        plugin,
+        message
       });
     }).filter(Boolean);
+    return result;
   }
   /**
    * First non-null result stops and will return it's value.
@@ -336,17 +329,21 @@ Falling back on the first item.
   async hookFirst({
     hookName,
     parameters,
-    skipped
+    skipped,
+    message
   }) {
-    const promises = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this).filter((plugin) => {
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
       return skipped ? skipped.has(plugin) : true;
-    }).map((plugin) => {
+    });
+    this.logger.emit("progress_start", { id: hookName, size: plugins.length });
+    const promises = plugins.map((plugin) => {
       return async () => {
-        const value = await __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+        const value = await this.#execute({
           strategy: "hookFirst",
           hookName,
           parameters,
-          plugin
+          plugin,
+          message
         });
         return Promise.resolve({
           plugin,
@@ -354,7 +351,9 @@ Falling back on the first item.
         });
       };
     });
-    return __privateGet(this, _promiseManager).run("first", promises);
+    const result = await this.#promiseManager.run("first", promises);
+    this.logger.emit("progress_stop", { id: hookName });
+    return result;
   }
   /**
    * First non-null result stops and will return it's value.
@@ -362,19 +361,21 @@ Falling back on the first item.
   hookFirstSync({
     hookName,
     parameters,
-    skipped
+    skipped,
+    message
   }) {
     let parseResult = null;
-    for (const plugin of __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this)) {
-      if (skipped?.has(plugin)) {
-        continue;
-      }
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true;
+    });
+    for (const plugin of plugins) {
       parseResult = {
-        result: __privateMethod(this, _PluginManager_instances, executeSync_fn).call(this, {
+        result: this.#executeSync({
           strategy: "hookFirst",
           hookName,
           parameters,
-          plugin
+          plugin,
+          message
         }),
         plugin
       };
@@ -389,23 +390,28 @@ Falling back on the first item.
    */
   async hookParallel({
     hookName,
-    parameters
+    parameters,
+    message
   }) {
-    const promises = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this).map((plugin) => {
-      return () => __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+    const plugins = this.#getSortedPlugins(hookName);
+    this.logger.emit("progress_start", { id: hookName, size: plugins.length });
+    const promises = plugins.map((plugin) => {
+      return () => this.#execute({
         strategy: "hookParallel",
         hookName,
         parameters,
-        plugin
+        plugin,
+        message
       });
     });
-    const results = await __privateGet(this, _promiseManager).run("parallel", promises);
+    const results = await this.#promiseManager.run("parallel", promises);
     results.forEach((result, index) => {
       if (isPromiseRejectedResult(result)) {
-        const plugin = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this)[index];
-        __privateMethod(this, _PluginManager_instances, catcher_fn).call(this, result.reason, plugin, hookName);
+        const plugin = this.#getSortedPlugins(hookName)[index];
+        this.#catcher(result.reason, plugin, hookName);
       }
     });
+    this.logger.emit("progress_stop", { id: hookName });
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   /**
@@ -414,36 +420,70 @@ Falling back on the first item.
   hookReduceArg0({
     hookName,
     parameters,
-    reduce
+    reduce,
+    message
   }) {
     const [argument0, ...rest] = parameters;
+    const plugins = this.#getSortedPlugins(hookName);
     let promise = Promise.resolve(argument0);
-    for (const plugin of __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this)) {
+    for (const plugin of plugins) {
       promise = promise.then((arg0) => {
-        const value = __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+        const value = this.#execute({
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
-          plugin
+          plugin,
+          message
         });
         return value;
-      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
+      }).then((result) => reduce.call(this.#core.context, argument0, result, plugin));
     }
     return promise;
   }
   /**
    * Chains plugins
    */
-  async hookSeq({ hookName, parameters }) {
-    const promises = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this).map((plugin) => {
-      return () => __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+  async hookSeq({
+    hookName,
+    parameters,
+    message
+  }) {
+    const plugins = this.#getSortedPlugins(hookName);
+    this.logger.emit("progress_start", { id: hookName, size: plugins.length });
+    const promises = plugins.map((plugin) => {
+      return () => this.#execute({
         strategy: "hookSeq",
         hookName,
         parameters,
-        plugin
+        plugin,
+        message
       });
     });
-    return __privateGet(this, _promiseManager).run("seq", promises);
+    await this.#promiseManager.run("seq", promises);
+    this.logger.emit("progress_stop", { id: hookName });
+  }
+  #getSortedPlugins(hookName) {
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+    if (hookName) {
+      return plugins.filter((item) => item[hookName]);
+    }
+    return plugins.map((plugin) => {
+      if (plugin.pre) {
+        const isValid = plugin.pre.every((pluginName) => plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+        if (!isValid) {
+          throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
+        }
+      }
+      return plugin;
+    }).sort((a, b) => {
+      if (b.pre?.includes(a.name)) {
+        return 1;
+      }
+      if (b.post?.includes(a.name)) {
+        return -1;
+      }
+      return 0;
+    });
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
@@ -460,14 +500,146 @@ Falling back on the first item.
     if (!pluginByPluginName?.length) {
       const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
       if (corePlugin) {
-        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`]);
+        this.logger.emit("debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`]
+        });
       } else {
-        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`]);
+        this.logger.emit("debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`]
+        });
       }
       return corePlugin ? [corePlugin] : [];
     }
     return pluginByPluginName;
   }
+  #addExecutedToCallStack(executer) {
+    if (executer) {
+      this.events.emit("executed", executer);
+      this.executed.push(executer);
+      this.logger.emit("progressed", { id: executer.hookName, message: `${executer.plugin.name}: ${executer.message}` });
+    }
+  }
+  /**
+   * Run an async plugin hook and return the result.
+   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+   * @param args Arguments passed to the plugin hook.
+   * @param plugin The actual pluginObject to run.
+   */
+  // Implementation signature
+  #execute({
+    strategy,
+    hookName,
+    parameters,
+    plugin,
+    message
+  }) {
+    const hook = plugin[hookName];
+    let output;
+    if (!hook) {
+      return null;
+    }
+    this.events.emit("executing", { strategy, hookName, parameters, plugin, message });
+    const promise = new Promise((resolve2) => {
+      resolve2(void 0);
+    });
+    const task = promise.then(() => {
+      if (typeof hook === "function") {
+        const possiblePromiseResult = hook.apply({ ...this.#core.context, plugin }, parameters);
+        if (isPromise(possiblePromiseResult)) {
+          return Promise.resolve(possiblePromiseResult);
+        }
+        return possiblePromiseResult;
+      }
+      return hook;
+    }).then((result) => {
+      output = result;
+      this.#addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin,
+        message
+      });
+      return result;
+    }).catch((e) => {
+      this.#catcher(e, plugin, hookName);
+      return null;
+    });
+    return task;
+  }
+  /**
+   * Run a sync plugin hook and return the result.
+   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+   * @param args Arguments passed to the plugin hook.
+   * @param plugin The acutal plugin
+   * @param replaceContext When passed, the plugin context can be overridden.
+   */
+  #executeSync({
+    strategy,
+    hookName,
+    parameters,
+    plugin,
+    message
+  }) {
+    const hook = plugin[hookName];
+    let output;
+    if (!hook) {
+      return null;
+    }
+    this.events.emit("executing", { strategy, hookName, parameters, plugin, message });
+    try {
+      if (typeof hook === "function") {
+        const fn = hook.apply({ ...this.#core.context, plugin }, parameters);
+        output = fn;
+        this.#addExecutedToCallStack({
+          parameters,
+          output,
+          strategy,
+          hookName,
+          plugin,
+          message
+        });
+        return fn;
+      }
+      output = hook;
+      this.#addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin,
+        message
+      });
+      return hook;
+    } catch (e) {
+      this.#catcher(e, plugin, hookName);
+      return null;
+    }
+  }
+  #catcher(cause, plugin, hookName) {
+    const text = `${cause.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})`;
+    this.logger.emit("error", text, cause);
+    this.events.emit("error", cause);
+  }
+  #parse(plugin, pluginManager, context) {
+    const usedPluginNames = pluginManager.#usedPluginNames;
+    setUniqueName(plugin.name, usedPluginNames);
+    const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
+    if (plugin.context && typeof plugin.context === "function") {
+      return {
+        ...plugin,
+        key,
+        context: plugin.context.call(context)
+      };
+    }
+    return {
+      ...plugin,
+      key
+    };
+  }
   static getDependedPlugins(plugins, dependedPluginNames) {
     let pluginNames = [];
     if (typeof dependedPluginNames === "string") {
@@ -484,157 +656,8 @@ Falling back on the first item.
     });
   }
   static get hooks() {
-    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
-  }
-};
-_core = new WeakMap();
-_usedPluginNames = new WeakMap();
-_promiseManager = new WeakMap();
-_PluginManager_instances = new WeakSet();
-getSortedPlugins_fn = function(hookName) {
-  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-  if (hookName) {
-    if (this.logger.logLevel === LogLevel.info) {
-      const containsHookName = plugins.some((item) => item[hookName]);
-      if (!containsHookName) {
-        this.logger.emit("warning", `No hook ${hookName} found`);
-      }
-    }
-    return plugins.filter((item) => item[hookName]);
-  }
-  return plugins.map((plugin) => {
-    if (plugin.pre) {
-      const isValid = plugin.pre.every((pluginName) => plugins.find((pluginToFind) => pluginToFind.name === pluginName));
-      if (!isValid) {
-        throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
-      }
-    }
-    return plugin;
-  }).sort((a, b) => {
-    if (b.pre?.includes(a.name)) {
-      return 1;
-    }
-    if (b.post?.includes(a.name)) {
-      return -1;
-    }
-    return 0;
-  });
-};
-addExecutedToCallStack_fn = function(executer) {
-  if (executer) {
-    this.events.emit("executed", executer);
-    this.executed.push(executer);
-  }
-};
-/**
- * Run an async plugin hook and return the result.
- * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
- * @param args Arguments passed to the plugin hook.
- * @param plugin The actual pluginObject to run.
- */
-// Implementation signature
-execute_fn = function({
-  strategy,
-  hookName,
-  parameters,
-  plugin
-}) {
-  const hook = plugin[hookName];
-  let output;
-  if (!hook) {
-    return null;
-  }
-  this.events.emit("execute", { strategy, hookName, parameters, plugin });
-  const task = Promise.resolve().then(() => {
-    if (typeof hook === "function") {
-      const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
-      if (isPromise(possiblePromiseResult)) {
-        return Promise.resolve(possiblePromiseResult);
-      }
-      return possiblePromiseResult;
-    }
-    return hook;
-  }).then((result) => {
-    output = result;
-    __privateMethod(this, _PluginManager_instances, addExecutedToCallStack_fn).call(this, {
-      parameters,
-      output,
-      strategy,
-      hookName,
-      plugin
-    });
-    return result;
-  }).catch((e) => {
-    __privateMethod(this, _PluginManager_instances, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  });
-  return task;
-};
-/**
- * Run a sync plugin hook and return the result.
- * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
- * @param args Arguments passed to the plugin hook.
- * @param plugin The acutal plugin
- * @param replaceContext When passed, the plugin context can be overridden.
- */
-executeSync_fn = function({
-  strategy,
-  hookName,
-  parameters,
-  plugin
-}) {
-  const hook = plugin[hookName];
-  let output;
-  if (!hook) {
-    return null;
-  }
-  this.events.emit("execute", { strategy, hookName, parameters, plugin });
-  try {
-    if (typeof hook === "function") {
-      const fn = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
-      output = fn;
-      return fn;
-    }
-    output = hook;
-    __privateMethod(this, _PluginManager_instances, addExecutedToCallStack_fn).call(this, {
-      parameters,
-      output,
-      strategy,
-      hookName,
-      plugin
-    });
-    return hook;
-  } catch (e) {
-    __privateMethod(this, _PluginManager_instances, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  }
-};
-catcher_fn = function(cause, plugin, hookName) {
-  const text = `${cause.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})`;
-  this.logger.emit("error", text, cause);
-  this.events.emit("error", cause);
-};
-parse_fn = function(plugin, pluginManager, context) {
-  const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
-  setUniqueName(plugin.name, usedPluginNames);
-  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-  if (!plugin.transform) {
-    plugin.transform = function transform(_path, code) {
-      return code;
-    };
+    return ["buildStart", "resolvePath", "resolveName", "buildEnd"];
   }
-  if (plugin.api && typeof plugin.api === "function") {
-    const api = plugin.api.call(context);
-    return {
-      ...plugin,
-      key,
-      api
-    };
-  }
-  return {
-    ...plugin,
-    key
-  };
 };
 
 // src/config.ts
@@ -646,238 +669,168 @@ function isInputPath(result) {
 }
 
 // src/build.ts
-async function transformReducer(_previousCode, result, _plugin) {
-  return result;
-}
+import { join, resolve } from "node:path";
+import { getRelativePath } from "@kubb/fs";
 async function setup(options) {
-  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
-  let count = 0;
+  const { config, logger = createLogger() } = options;
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
     if (isInputPath(config)) {
-      throw new Error(
-        `Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${p.dim(config.input.path)}`,
-        {
-          cause: e
-        }
-      );
+      throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${config.input.path}`, {
+        cause: e
+      });
     }
   }
   if (config.output.clean) {
     await clean(config.output.path);
+    await clean(join(config.root, ".kubb"));
   }
-  const task = async (file) => {
-    const { path: path2 } = file;
-    let source = await FileManager.getSource(file);
-    const { result: loadedResult } = await pluginManager.hookFirst({
-      hookName: "load",
-      parameters: [path2]
-    });
-    if (loadedResult && isPromise(loadedResult)) {
-      source = await loadedResult;
-    }
-    if (loadedResult && !isPromise(loadedResult)) {
-      source = loadedResult;
-    }
-    if (source) {
-      source = await pluginManager.hookReduceArg0({
-        hookName: "transform",
-        parameters: [path2, source],
-        reduce: transformReducer
-      });
-      if (config.output.write || config.output.write === void 0) {
-        if (file.meta?.pluginKey) {
-          await pluginManager.hookForPlugin({
-            pluginKey: file.meta?.pluginKey,
-            hookName: "writeFile",
-            parameters: [path2, source]
-          });
-        }
-        await pluginManager.hookFirst({
-          hookName: "writeFile",
-          parameters: [path2, source]
-        });
-      }
-    }
-    return {
-      ...file,
-      source: source || ""
-    };
-  };
-  const pluginManager = new PluginManager(config, { logger, task });
-  pluginManager.on("execute", (executer) => {
-    const { hookName, parameters, plugin } = executer;
-    if (hookName === "writeFile") {
-      const [code] = parameters;
-      logger.emit("debug", [`PluginKey ${p.dim(JSON.stringify(plugin.key))} 
-with source
-
-${code}`]);
-    }
-  });
-  pluginManager.queue.on("add", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (count === 0) {
-      logger.emit("start", "\u{1F4BE} Writing");
-    }
-  });
-  pluginManager.queue.on("active", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (logger.spinner && pluginManager.queue.size > 0) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
-      logger.spinner.suffixText = p.dim(text);
-    }
-    ++count;
-  });
-  pluginManager.queue.on("completed", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (logger.spinner) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
-      logger.spinner.suffixText = p.dim(text);
-    }
-  });
-  pluginManager.on("executed", (executer) => {
-    const { hookName, plugin, output, parameters } = executer;
-    const logs = [
-      `${randomCliColour(plugin.name)} Executing ${hookName}`,
-      parameters && `${p.bgWhite("Parameters")} ${randomCliColour(plugin.name)} ${hookName}`,
-      JSON.stringify(parameters, void 0, 2),
-      output && `${p.bgWhite("Output")} ${randomCliColour(plugin.name)} ${hookName}`,
-      output
-    ].filter(Boolean);
-    logger.emit("debug", logs);
-  });
-  return pluginManager;
+  return new PluginManager(config, { logger });
 }
 async function build(options) {
-  const pluginManager = await setup(options);
-  const { fileManager, logger } = pluginManager;
-  await pluginManager.hookParallel({
-    hookName: "buildStart",
-    parameters: [options.config]
-  });
-  await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (logger.logLevel === LogLevel.info) {
-    logger.emit("end", "\u{1F4BE} Writing completed");
-  }
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file)
-    }))
-  );
+  const { files, pluginManager, error } = await safeBuild(options);
+  if (error) throw error;
   return {
     files,
-    pluginManager
+    pluginManager,
+    error
   };
 }
 async function safeBuild(options) {
+  let files = [];
   const pluginManager = await setup(options);
-  const { fileManager, logger } = pluginManager;
   try {
+    pluginManager.events.on("executing", ({ plugin, message }) => {
+      pluginManager.logger.emit("debug", { date: /* @__PURE__ */ new Date(), logs: [`Executing pluginKey ${plugin.key?.join(".")} | ${message}`] });
+    });
+    pluginManager.events.on("executed", ({ plugin, message, output }) => {
+      pluginManager.logger.emit("debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [`Executed pluginKey ${plugin.key?.join(".")} | ${message} |  ${JSON.stringify(output, void 0, 2)}`]
+      });
+    });
     await pluginManager.hookParallel({
       hookName: "buildStart",
-      parameters: [options.config]
+      parameters: [options.config],
+      message: "buildStart"
     });
-    await pluginManager.hookParallel({ hookName: "buildEnd" });
-    if (logger.logLevel === LogLevel.info) {
-      logger.emit("end", "\u{1F4BE} Writing completed");
-    }
+    const root = resolve(options.config.root);
+    const rootPath = resolve(root, options.config.output.path, "index.ts");
+    const barrelFiles = pluginManager.fileManager.files.filter((file) => {
+      return file.sources.some((source) => source.isIndexable);
+    });
+    const rootFile = {
+      path: rootPath,
+      baseName: "index.ts",
+      exports: barrelFiles.flatMap((file) => {
+        return file.sources?.map((source) => {
+          if (!file.path || !source.isIndexable) {
+            return void 0;
+          }
+          const plugin = pluginManager.plugins.find((item) => {
+            const meta = file.meta;
+            return item.name === meta?.pluginKey?.[0];
+          });
+          if (plugin?.output?.exportType === false) {
+            return void 0;
+          }
+          if (FileManager.getMode(plugin?.output?.path) === "single") {
+            return void 0;
+          }
+          return {
+            name: options.config.output.exportType === "barrel" ? void 0 : [source.name],
+            path: getRelativePath(rootPath, file.path),
+            isTypeOnly: source.isTypeOnly
+          };
+        }).filter(Boolean);
+      }).filter(Boolean),
+      sources: [],
+      meta: {}
+    };
+    if (options.config.output.exportType) {
+      await pluginManager.fileManager.add(rootFile);
+    }
+    files = await processFiles({
+      config: options.config,
+      dryRun: !options.config.output.write,
+      files: pluginManager.fileManager.files,
+      logger: pluginManager.logger
+    });
+    await pluginManager.hookParallel({ hookName: "buildEnd", message: `Build stopped for ${options.config.name}` });
+    pluginManager.fileManager.clear();
   } catch (e) {
-    const files2 = await Promise.all(
-      fileManager.files.map(async (file) => ({
-        ...file,
-        source: await FileManager.getSource(file)
-      }))
-    );
     return {
-      files: files2,
+      files: [],
       pluginManager,
       error: e
     };
   }
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file)
-    }))
-  );
   return {
     files,
     pluginManager
   };
 }
 
-// src/Generator.ts
-var _options2, _context;
-var Generator = class {
+// src/BaseGenerator.ts
+var BaseGenerator = class {
+  #options = {};
+  #context = {};
   constructor(options, context) {
-    __privateAdd(this, _options2, {});
-    __privateAdd(this, _context, {});
     if (context) {
-      __privateSet(this, _context, context);
+      this.#context = context;
     }
     if (options) {
-      __privateSet(this, _options2, options);
+      this.#options = options;
     }
     return this;
   }
   get options() {
-    return __privateGet(this, _options2);
+    return this.#options;
   }
   get context() {
-    return __privateGet(this, _context);
+    return this.#context;
   }
   set options(options) {
-    __privateSet(this, _options2, { ...__privateGet(this, _options2), ...options });
+    this.#options = { ...this.#options, ...options };
   }
 };
-_options2 = new WeakMap();
-_context = new WeakMap();
 
 // src/PackageManager.ts
-import mod from "module";
-import os from "os";
-import { pathToFileURL } from "url";
+import mod from "node:module";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
 import { findUp, findUpSync } from "find-up";
 import { coerce, satisfies } from "semver";
-import { read as read2, readSync as readSync2 } from "@kubb/fs";
-var _cache, _cwd, _SLASHES, _PackageManager_instances, match_fn;
-var _PackageManager = class _PackageManager {
+import { read as read2, readSync } from "@kubb/fs";
+var PackageManager = class _PackageManager {
+  static #cache = {};
+  #cwd;
+  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
   constructor(workspace) {
-    __privateAdd(this, _PackageManager_instances);
-    __privateAdd(this, _cwd);
-    __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
-      __privateSet(this, _cwd, workspace);
+      this.#cwd = workspace;
     }
     return this;
   }
   set workspace(workspace) {
-    __privateSet(this, _cwd, workspace);
+    this.#cwd = workspace;
   }
   get workspace() {
-    return __privateGet(this, _cwd);
+    return this.#cwd;
   }
   normalizeDirectory(directory) {
-    if (!__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
+    if (!this.#SLASHES.has(directory[directory.length - 1])) {
       return `${directory}/`;
     }
     return directory;
   }
   getLocation(path2) {
     let location = path2;
-    if (__privateGet(this, _cwd)) {
-      const require2 = mod.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
+    if (this.#cwd) {
+      const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
       location = require2.resolve(path2);
     }
     return location;
@@ -891,13 +844,13 @@ var _PackageManager = class _PackageManager {
       const module = await import(location);
       return module?.default ?? module;
     } catch (e) {
-      console.log(e);
+      console.error(e);
       return void 0;
     }
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: __privateGet(this, _cwd)
+      cwd: this.#cwd
     });
     if (!pkgPath) {
       return void 0;
@@ -907,36 +860,47 @@ var _PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: __privateGet(this, _cwd)
+      cwd: this.#cwd
     });
     if (!pkgPath) {
       return void 0;
     }
-    const json = readSync2(pkgPath);
+    const json = readSync(pkgPath);
     return JSON.parse(json);
   }
   static setVersion(dependency, version) {
-    __privateGet(_PackageManager, _cache)[dependency] = version;
+    _PackageManager.#cache[dependency] = version;
+  }
+  #match(packageJSON, dependency) {
+    const dependencies = {
+      ...packageJSON["dependencies"] || {},
+      ...packageJSON["devDependencies"] || {}
+    };
+    if (typeof dependency === "string" && dependencies[dependency]) {
+      return dependencies[dependency];
+    }
+    const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
+    return matchedDependency ? dependencies[matchedDependency] : void 0;
   }
   async getVersion(dependency) {
-    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache)[dependency]) {
-      return __privateGet(_PackageManager, _cache)[dependency];
+    if (typeof dependency === "string" && _PackageManager.#cache[dependency]) {
+      return _PackageManager.#cache[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
       return void 0;
     }
-    return __privateMethod(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
+    return this.#match(packageJSON, dependency);
   }
   getVersionSync(dependency) {
-    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache)[dependency]) {
-      return __privateGet(_PackageManager, _cache)[dependency];
+    if (typeof dependency === "string" && _PackageManager.#cache[dependency]) {
+      return _PackageManager.#cache[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
       return void 0;
     }
-    return __privateMethod(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
+    return this.#match(packageJSON, dependency);
   }
   async isValid(dependency, version) {
     const packageVersion = await this.getVersion(dependency);
@@ -964,30 +928,12 @@ var _PackageManager = class _PackageManager {
     return satisfies(semVer, version);
   }
 };
-_cache = new WeakMap();
-_cwd = new WeakMap();
-_SLASHES = new WeakMap();
-_PackageManager_instances = new WeakSet();
-match_fn = function(packageJSON, dependency) {
-  const dependencies = {
-    ...packageJSON["dependencies"] || {},
-    ...packageJSON["devDependencies"] || {}
-  };
-  if (typeof dependency === "string" && dependencies[dependency]) {
-    return dependencies[dependency];
-  }
-  const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
-  return matchedDependency ? dependencies[matchedDependency] : void 0;
-};
-__privateAdd(_PackageManager, _cache, {});
-var PackageManager = _PackageManager;
 export {
+  BaseGenerator,
   FileManager,
-  Generator,
   PackageManager,
   PluginManager,
   PromiseManager,
-  Warning,
   build,
   createPlugin,
   build as default,