@kubb/core 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/index.js

@@ -3,25 +3,16 @@ import {
 } from "./chunk-2EU7DMPM.js";
 import {
   EventEmitter,
-  createLogger,
-  p
-} from "./chunk-76UEJFFE.js";
+  createLogger
+} from "./chunk-SCR3LUXT.js";
 import {
   FileManager,
-  processFiles
-} from "./chunk-RIEGCND2.js";
-import {
   URLPath,
+  processFiles,
   setUniqueName
-} from "./chunk-AWAZR3D5.js";
+} from "./chunk-27CPVXAT.js";
 import "./chunk-4X5FFJPJ.js";
-import "./chunk-25NKJ3DV.js";
-import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet
-} from "./chunk-HMLY7DHA.js";
+import "./chunk-HBQM723K.js";
 
 // src/build.ts
 import { clean, read } from "@kubb/fs";
@@ -61,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) {
@@ -73,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);
@@ -81,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,7 +83,7 @@ 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)) {
@@ -163,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) {
@@ -173,75 +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", {
-            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]
-      }).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", {
-            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]
-      }).result;
-      return transformReservedWord(name);
-    };
     this.config = config;
     this.options = options;
     this.logger = options.logger;
     this.fileManager = new FileManager();
-    __privateSet(this, _promiseManager, new PromiseManager({
+    this.#promiseManager = new PromiseManager({
       nullCheck: (state) => !!state?.result
-    }));
+    });
     const plugins = config.plugins || [];
     const core = pluginCore({
       config,
@@ -250,11 +189,11 @@ 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.context.call(null)));
-    this.plugins = [__privateGet(this, _core), ...plugins].map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, parse_fn).call(this, plugin, this, __privateGet(this, _core).context);
+    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;
   }
@@ -273,6 +212,60 @@ Falling back on the first item.
       sources: []
     };
   }
+  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", {
+          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]
+    }).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]
+      });
+      if (names && names?.length > 1) {
+        this.logger.emit("debug", {
+          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]
+    }).result;
+    return transformReservedWord(name);
+  };
   /**
    * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
    */
@@ -290,7 +283,7 @@ Falling back on the first item.
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     this.logger.emit("progress_start", { id: hookName, size: plugins.length });
     const promises = plugins.map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+      return this.#execute({
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -311,7 +304,7 @@ Falling back on the first item.
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     const result = plugins.map((plugin) => {
-      return __privateMethod(this, _PluginManager_instances, executeSync_fn).call(this, {
+      return this.#executeSync({
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -328,13 +321,13 @@ Falling back on the first item.
     parameters,
     skipped
   }) {
-    const plugins = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this, hookName).filter((plugin) => {
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
       return skipped ? skipped.has(plugin) : true;
     });
     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,
@@ -346,7 +339,7 @@ Falling back on the first item.
         });
       };
     });
-    const result = await __privateGet(this, _promiseManager).run("first", promises);
+    const result = await this.#promiseManager.run("first", promises);
     this.logger.emit("progress_stop", { id: hookName });
     return result;
   }
@@ -359,12 +352,12 @@ Falling back on the first item.
     skipped
   }) {
     let parseResult = null;
-    const plugins = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this, hookName).filter((plugin) => {
+    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,
@@ -385,21 +378,21 @@ Falling back on the first item.
     hookName,
     parameters
   }) {
-    const plugins = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this, hookName);
+    const plugins = this.#getSortedPlugins(hookName);
     this.logger.emit("progress_start", { id: hookName, size: plugins.length });
     const promises = plugins.map((plugin) => {
-      return () => __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+      return () => this.#execute({
         strategy: "hookParallel",
         hookName,
         parameters,
         plugin
       });
     });
-    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, hookName)[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 });
@@ -414,18 +407,18 @@ Falling back on the first item.
     reduce
   }) {
     const [argument0, ...rest] = parameters;
-    const plugins = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this, hookName);
+    const plugins = this.#getSortedPlugins(hookName);
     let promise = Promise.resolve(argument0);
     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
         });
         return value;
-      }).then((result) => reduce.call(__privateGet(this, _core).context, argument0, result, plugin));
+      }).then((result) => reduce.call(this.#core.context, argument0, result, plugin));
     }
     return promise;
   }
@@ -433,19 +426,46 @@ Falling back on the first item.
    * Chains plugins
    */
   async hookSeq({ hookName, parameters }) {
-    const plugins = __privateMethod(this, _PluginManager_instances, getSortedPlugins_fn).call(this, hookName);
+    const plugins = this.#getSortedPlugins(hookName);
     this.logger.emit("progress_start", { id: hookName, size: plugins.length });
     const promises = plugins.map((plugin) => {
-      return () => __privateMethod(this, _PluginManager_instances, execute_fn).call(this, {
+      return () => this.#execute({
         strategy: "hookSeq",
         hookName,
         parameters,
         plugin
       });
     });
-    await __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) {
+      const containsHookName = plugins.some((item) => item[hookName]);
+      if (!containsHookName) {
+        this.logger.emit("debug", { logs: [`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;
+    });
+  }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
     const [searchPluginName, searchIdentifier] = pluginKey;
@@ -473,6 +493,120 @@ Falling back on the first item.
     }
     return pluginByPluginName;
   }
+  #addExecutedToCallStack(executer) {
+    if (executer) {
+      this.events.emit("executed", executer);
+      this.executed.push(executer);
+      this.logger.emit("progress", { id: executer.hookName, data: `${executer.plugin.name} ${executer.parameters?.join(", ") || ""}` });
+    }
+  }
+  /**
+   * 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
+  }) {
+    const hook = plugin[hookName];
+    let output;
+    if (!hook) {
+      return null;
+    }
+    this.events.emit("execute", { strategy, hookName, parameters, plugin });
+    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
+      });
+      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
+  }) {
+    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({ ...this.#core.context, plugin }, parameters);
+        output = fn;
+        return fn;
+      }
+      output = hook;
+      this.#addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
+      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") {
@@ -492,151 +626,6 @@ Falling back on the first item.
     return ["buildStart", "resolvePath", "resolveName", "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) {
-    const containsHookName = plugins.some((item) => item[hookName]);
-    if (!containsHookName) {
-      this.logger.emit("debug", { logs: [`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);
-    this.logger.emit("progress", { id: executer.hookName, data: `${executer.plugin.name}` });
-  }
-};
-/**
- * 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 promise = new Promise((resolve) => {
-    resolve(void 0);
-  });
-  const task = promise.then(() => {
-    if (typeof hook === "function") {
-      const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).context, 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).context, 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.context && typeof plugin.context === "function") {
-    return {
-      ...plugin,
-      key,
-      context: plugin.context.call(context)
-    };
-  }
-  return {
-    ...plugin,
-    key
-  };
-};
 
 // src/config.ts
 function defineConfig(options) {
@@ -647,6 +636,8 @@ function isInputPath(result) {
 }
 
 // src/build.ts
+import { resolve } from "node:path";
+import { getRelativePath } from "@kubb/fs";
 async function setup(options) {
   const { config, logger = createLogger() } = options;
   try {
@@ -655,12 +646,9 @@ async function setup(options) {
     }
   } 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) {
@@ -669,21 +657,12 @@ async function setup(options) {
   return new PluginManager(config, { logger });
 }
 async function build(options) {
-  const pluginManager = await setup(options);
-  await pluginManager.hookParallel({
-    hookName: "buildStart",
-    parameters: [options.config]
-  });
-  const files = await processFiles({
-    config: options.config,
-    dryRun: !options.config.output.write,
-    files: pluginManager.fileManager.files,
-    logger: pluginManager.logger
-  });
-  await pluginManager.hookParallel({ hookName: "buildEnd" });
+  const { files, pluginManager, error } = await safeBuild(options);
+  if (error) throw error;
   return {
     files,
-    pluginManager
+    pluginManager,
+    error
   };
 }
 async function safeBuild(options) {
@@ -694,6 +673,42 @@ async function safeBuild(options) {
       hookName: "buildStart",
       parameters: [options.config]
     });
+    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,
@@ -701,6 +716,7 @@ async function safeBuild(options) {
       logger: pluginManager.logger
     });
     await pluginManager.hookParallel({ hookName: "buildEnd" });
+    pluginManager.fileManager.clear();
   } catch (e) {
     return {
       files: [],
@@ -715,66 +731,62 @@ async function safeBuild(options) {
 }
 
 // src/Generator.ts
-var _options2, _context;
 var Generator = 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 } from "@kubb/fs";
-var _cache, _cwd, _SLASHES, _PackageManager_instances, match_fn;
-var _PackageManager = class _PackageManager {
+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;
@@ -794,7 +806,7 @@ var _PackageManager = class _PackageManager {
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: __privateGet(this, _cwd)
+      cwd: this.#cwd
     });
     if (!pkgPath) {
       return void 0;
@@ -804,7 +816,7 @@ var _PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: __privateGet(this, _cwd)
+      cwd: this.#cwd
     });
     if (!pkgPath) {
       return void 0;
@@ -813,27 +825,38 @@ var _PackageManager = class _PackageManager {
     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);
@@ -861,23 +884,6 @@ 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 {
   FileManager,
   Generator,