@kubb/core 1.0.0-beta.9 → 1.0.1

package/dist/index.cjs

@@ -6,31 +6,37 @@ var module$1 = require('module');
 var pathParser2 = require('path');
 var fs = require('fs');
 var rimraf = require('rimraf');
-var uuid = require('uuid');
 var dirTree = require('directory-tree');
-var uniq = require('lodash.uniq');
+var crypto = require('crypto');
+var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pathParser2__default = /*#__PURE__*/_interopDefault(pathParser2);
-var rimraf__default = /*#__PURE__*/_interopDefault(rimraf);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
-var uniq__default = /*#__PURE__*/_interopDefault(uniq);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
-module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('out.js', document.baseURI).href)));
+module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('out.js', document.baseURI).href)));
 
-// src/utils/isURL.ts
-function isURL(data) {
-  try {
-    const url = new URL(data);
-    if (url?.href) {
-      return true;
-    }
-  } catch (error) {
-    return false;
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.pluginManager = options.pluginManager;
   }
-  return false;
-}
+};
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors;
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.errors = options.errors;
+    this.pluginManager = options.pluginManager;
+  }
+};
 
 // src/utils/isPromise.ts
 function isPromise(result) {
@@ -53,17 +59,6 @@ async function write(data, path) {
   }
   return safeWriteFileToPath(path, data);
 }
-async function clean(path) {
-  return new Promise((resolve, reject) => {
-    rimraf__default.default(path, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(true);
-      }
-    });
-  });
-}
 
 // src/utils/cache.ts
 function createPluginCache(cache) {
@@ -99,7 +94,7 @@ function slash(path) {
 }
 function getRelativePath(rootDir, filePath) {
   if (!rootDir || !filePath) {
-    throw new Error("Root and file should be filled in when retrieving the relativePath");
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir} ${filePath}`);
   }
   const relativePath = pathParser2__default.default.relative(rootDir, filePath);
   const path = slash(relativePath).replace("../", "").trimEnd();
@@ -123,16 +118,30 @@ async function read(path) {
   }
 }
 
+// src/utils/isURL.ts
+function isURL(data) {
+  try {
+    const url = new URL(data);
+    if (url?.href) {
+      return true;
+    }
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+
 // src/utils/objectToParameters.ts
 function objectToParameters(data, options = {}) {
+  const { typed } = options;
   return data.reduce((acc, [key, value]) => {
-    if (options.typed) {
-      acc.push(`${key}: ${value}["${key}"], `);
+    if (typed) {
+      acc.push(`${key}: ${value}["${key}"]`);
     } else {
-      acc.push(`${key},`);
+      acc.push(`${key}`);
     }
     return acc;
-  }, []).join("");
+  }, []).join(", ");
 }
 
 // src/utils/nameSorter.ts
@@ -180,7 +189,7 @@ async function timeout(ms) {
   });
 }
 
-// src/utils/queue.ts
+// src/utils/Queue.ts
 var Queue = class {
   queue = [];
   workerCount = 0;
@@ -208,6 +217,213 @@ var Queue = class {
   }
 };
 
+// src/utils/getEncodedText.ts
+function getEncodedText(text) {
+  return text ? text.replaceAll("`", "\\`") : "";
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  return template.replace(/{{(.*?)}}/g, (match) => {
+    const value = data[match.split(/{{|}}/).filter(Boolean)[0].trim()];
+    return value || "";
+  });
+}
+async function clean(path) {
+  return rimraf.rimraf(path);
+}
+var TreeNode = class {
+  data;
+  parent;
+  children = [];
+  constructor(data, parent) {
+    this.data = data;
+    this.parent = parent;
+    return this;
+  }
+  addChild(data) {
+    const child = new TreeNode(data, this);
+    if (!this.children) {
+      this.children = [];
+    }
+    this.children.push(child);
+    return child;
+  }
+  find(data) {
+    if (data === this.data) {
+      return this;
+    }
+    if (this.children) {
+      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
+        target = this.children[i].find(data);
+        if (target) {
+          return target;
+        }
+      }
+    }
+    return null;
+  }
+  leaves() {
+    if (!this.children || this.children.length === 0) {
+      return [this];
+    }
+    const leaves = [];
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        leaves.push.apply(leaves, this.children[i].leaves());
+      }
+    }
+    return leaves;
+  }
+  root() {
+    if (!this.parent) {
+      return this;
+    }
+    return this.parent.root();
+  }
+  forEach(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    callback(this);
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        this.children[i].forEach(callback);
+      }
+    }
+    return this;
+  }
+  static build(path, options = {}) {
+    const filteredTree = dirTree__default.default(path, { extensions: options?.extensions, exclude: options.exclude });
+    if (!filteredTree) {
+      return null;
+    }
+    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
+    const recurse = (node, item) => {
+      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
+      if (item.children?.length) {
+        item.children?.forEach((child) => {
+          recurse(subNode, child);
+        });
+      }
+    };
+    filteredTree.children?.forEach((child) => recurse(treeNode, child));
+    return treeNode;
+  }
+};
+
+// src/utils/transformReservedWord.ts
+var reservedWords = [
+  "abstract",
+  "arguments",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  "Array",
+  "Date",
+  "eval",
+  "function",
+  "hasOwnProperty",
+  "Infinity",
+  "isFinite",
+  "isNaN",
+  "isPrototypeOf",
+  "length",
+  "Math",
+  "name",
+  "NaN",
+  "Number",
+  "Object",
+  "prototype",
+  "String",
+  "toString",
+  "undefined",
+  "valueOf"
+];
+function transformReservedWord(word) {
+  if (word && reservedWords.includes(word)) {
+    return `_${word}`;
+  }
+  return word;
+}
+
+// src/utils/getStackTrace.ts
+function getStackTrace(belowFn) {
+  const oldLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = Infinity;
+  const dummyObject = {};
+  const v8Handler = Error.prepareStackTrace;
+  Error.prepareStackTrace = function prepareStackTrace(dummyObject2, v8StackTrace2) {
+    return v8StackTrace2;
+  };
+  Error.captureStackTrace(dummyObject, belowFn || getStackTrace);
+  const v8StackTrace = dummyObject.stack;
+  Error.prepareStackTrace = v8Handler;
+  Error.stackTraceLimit = oldLimit;
+  return v8StackTrace;
+}
+
 // src/plugin.ts
 function createPlugin(factory) {
   return (options) => {
@@ -231,11 +447,37 @@ var definePlugin = createPlugin((options) => {
       return options.config;
     },
     fileManager,
-    async addFile(file) {
-      return fileManager.addOrAppend(file);
+    async addFile(...files) {
+      const trace = getStackTrace();
+      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
+        if (a.name.length < b.name.length)
+          return 1;
+        if (a.name.length > b.name.length)
+          return -1;
+        return 0;
+      });
+      const pluginName = plugins?.[0].name;
+      return Promise.all(
+        files.map((file) => {
+          const fileWithMeta = {
+            ...file,
+            meta: {
+              ...file.meta || {},
+              pluginName
+            }
+          };
+          if (file.override) {
+            return fileManager.add(fileWithMeta);
+          }
+          return fileManager.addOrAppend(fileWithMeta);
+        })
+      );
     },
     resolvePath,
-    resolveName,
+    resolveName: (params) => {
+      const name2 = resolveName(params);
+      return transformReservedWord(name2);
+    },
     load,
     cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
@@ -243,11 +485,9 @@ var definePlugin = createPlugin((options) => {
     name,
     options,
     api,
-    resolvePath(fileName, directory) {
-      if (!directory) {
-        return null;
-      }
-      return pathParser2__default.default.resolve(directory, fileName);
+    resolvePath(fileName) {
+      const root = pathParser2__default.default.resolve(this.config.root, this.config.output.path);
+      return pathParser2__default.default.resolve(root, fileName);
     },
     resolveName(name2) {
       return name2;
@@ -284,7 +524,7 @@ var FileManager = class {
     return files;
   }
   async add(file) {
-    const cacheItem = { id: uuid.v4(), file, status: "new" };
+    const cacheItem = { id: crypto__default.default.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
     if (this.queue) {
       await this.queue.run(async () => {
@@ -294,14 +534,20 @@ var FileManager = class {
     return file;
   }
   addOrAppend(file) {
+    if (!file.path.endsWith(file.fileName)) ;
     const previousCache = this.getCacheByPath(file.path);
     if (previousCache) {
+      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
+      if (sourceAlreadyExists) {
+        return Promise.resolve(file);
+      }
       this.cache.delete(previousCache.id);
       return this.add({
         ...file,
         source: `${previousCache.file.source}
 ${file.source}`,
-        imports: [...previousCache.file.imports || [], ...file.imports || []]
+        imports: [...previousCache.file.imports || [], ...file.imports || []],
+        exports: [...previousCache.file.exports || [], ...file.exports || []]
       });
     }
     return this.add(file);
@@ -332,141 +578,6 @@ ${file.source}`,
     return read(...params);
   }
 };
-var TreeNode = class {
-  data;
-  parent;
-  children = [];
-  constructor(data, parent) {
-    this.data = data;
-    this.parent = parent;
-    return this;
-  }
-  addChild(data) {
-    const child = new TreeNode(data, this);
-    if (!this.children) {
-      this.children = [];
-    }
-    this.children.push(child);
-    return child;
-  }
-  find(data) {
-    if (data === this.data) {
-      return this;
-    }
-    if (this.children) {
-      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
-        target = this.children[i].find(data);
-        if (target) {
-          return target;
-        }
-      }
-    }
-    return null;
-  }
-  leaves() {
-    if (!this.children || this.children.length === 0) {
-      return [this];
-    }
-    const leaves = [];
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        leaves.push.apply(leaves, this.children[i].leaves());
-      }
-    }
-    return leaves;
-  }
-  root() {
-    if (!this.parent) {
-      return this;
-    }
-    return this.parent.root();
-  }
-  forEach(callback) {
-    if (typeof callback !== "function") {
-      throw new TypeError("forEach() callback must be a function");
-    }
-    callback(this);
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        this.children[i].forEach(callback);
-      }
-    }
-    return this;
-  }
-  static build(path, options = {}) {
-    const filteredTree = dirTree__default.default(path, { extensions: options?.extensions, exclude: options.exclude });
-    if (!filteredTree) {
-      return null;
-    }
-    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
-    const recurse = (node, item) => {
-      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
-      if (item.children?.length) {
-        item.children?.forEach((child) => {
-          recurse(subNode, child);
-        });
-      }
-    };
-    filteredTree.children?.forEach((child) => recurse(treeNode, child));
-    return treeNode;
-  }
-};
-function combineFiles(files) {
-  return files.filter(Boolean).reduce((acc, curr) => {
-    if (!curr) {
-      return acc;
-    }
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex];
-      acc[prevIndex] = {
-        ...curr,
-        source: `${prev.source}
-${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []]
-      };
-    } else {
-      acc.push(curr);
-    }
-    return acc;
-  }, []);
-}
-function getFileSource(file) {
-  if (!file.fileName.endsWith(".ts")) {
-    return file.source;
-  }
-  const imports = [];
-  file.imports?.forEach((curr) => {
-    const exists = imports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      imports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? uniq__default.default(curr.name) : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
-      imports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = uniq__default.default([...exists.name, ...curr.name]);
-      }
-    }
-  });
-  const importSource = imports.reduce((prev, curr) => {
-    if (Array.isArray(curr.name)) {
-      return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}{ ${curr.name.join(", ")} } from "${curr.path}";`;
-    }
-    return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}${curr.name} from "${curr.path}";`;
-  }, "");
-  if (importSource) {
-    return `${importSource}
-${file.source}`;
-  }
-  return file.source;
-}
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -483,13 +594,13 @@ var hooks = Object.keys(hookNames);
 var PluginManager = class {
   plugins;
   fileManager;
-  logger;
-  config;
+  onExecute;
   core;
   queue;
+  executer;
+  executed = [];
   constructor(config, options) {
-    this.logger = options.logger;
-    this.config = config;
+    this.onExecute = options.onExecute;
     this.queue = new Queue(10);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     this.core = definePlugin({
@@ -497,10 +608,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       load: this.load,
       resolvePath: this.resolvePath,
-      resolveName: this.resolveName
+      resolveName: this.resolveName,
+      getExecuter: this.getExecuter.bind(this)
     });
     this.plugins = [this.core, ...config.plugins || []];
   }
+  getExecuter() {
+    return this.executer;
+  }
   resolvePath = (params) => {
     if (params.pluginName) {
       return this.hookForPluginSync({
@@ -543,7 +658,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.run({
+    return this.execute({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -556,7 +671,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.runSync({
+    return this.executeSync({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -579,7 +694,7 @@ var PluginManager = class {
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.run({
+        return this.execute({
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -602,7 +717,7 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = this.runSync({
+      result = this.executeSync({
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -624,18 +739,25 @@ var PluginManager = class {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.run({
+        await this.execute({
           strategy: "hookParallel",
           hookName,
           parameters,
           plugin
         });
       } else {
-        const promise = this.run({ strategy: "hookParallel", hookName, parameters, plugin });
-        parallelPromises.push(promise);
+        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+        if (promise) {
+          parallelPromises.push(promise);
+        }
       }
     }
-    return Promise.all(parallelPromises);
+    const results = await Promise.allSettled(parallelPromises);
+    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (errors.length) {
+      throw new ParallelPluginError("Error", { errors, pluginManager: this });
+    }
+    return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   // chains, reduces returned value, handling the reduced value as the first hook argument
   hookReduceArg0({
@@ -646,14 +768,15 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(
-        (argument02) => this.run({
+      promise = promise.then((argument02) => {
+        const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
           parameters: [argument02, ...rest],
           plugin
-        }).then((result) => reduce.call(this.core.api, argument02, result, plugin))
-      );
+        });
+        return value;
+      }).then((result) => reduce.call(this.core.api, argument0, result, plugin));
     }
     return promise;
   }
@@ -662,7 +785,7 @@ var PluginManager = class {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        () => this.run({
+        () => this.execute({
           strategy: "hookSeq",
           hookName,
           parameters,
@@ -680,13 +803,16 @@ var PluginManager = class {
     const plugins = [...this.plugins];
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName]);
     if (!pluginByPluginName) {
-      if (this.config.logLevel === "warn" && this.logger?.spinner) {
-        this.logger.spinner.info(`Plugin hook with ${hookName} not found for plugin ${pluginName}`);
-      }
       return this.core;
     }
     return pluginByPluginName;
   }
+  addExecuter(executer) {
+    this.onExecute?.call(this, executer);
+    if (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`.
@@ -694,36 +820,42 @@ var PluginManager = class {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  run({
+  execute({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     return Promise.resolve().then(() => {
-      if (typeof hook !== "function") {
-        return hook;
-      }
-      if (this.config.logLevel === "info" && this.logger?.spinner) {
-        this.logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`;
-      }
-      const hookResult = hook.apply(this.core.api, parameters);
-      if (!hookResult?.then) {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      if (typeof hook === "function") {
+        const hookResult = hook.apply(this.core.api, parameters);
+        if (isPromise(hookResult)) {
+          return Promise.resolve(hookResult).then((result) => {
+            this.addExecuter({
+              strategy,
+              hookName,
+              plugin
+            });
+            return result;
+          });
         }
         return hookResult;
       }
-      return Promise.resolve(hookResult).then((result) => {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
-        }
-        return result;
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
       });
+      return hook;
     }).catch((e) => {
       this.catcher(e, plugin, hookName);
     });
@@ -735,18 +867,37 @@ var PluginManager = class {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  runSync({
+  executeSync({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     try {
-      if (typeof hook !== "function") {
-        return hook;
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      if (typeof hook === "function") {
+        const fn = hook.apply(this.core.api, parameters);
+        this.addExecuter({
+          strategy,
+          hookName,
+          plugin
+        });
+        return fn;
       }
-      return hook.apply(this.core.api, parameters);
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
+      });
+      return hook;
     } catch (e) {
       this.catcher(e, plugin, hookName);
       return null;
@@ -755,7 +906,7 @@ var PluginManager = class {
   catcher(e, plugin, hookName) {
     const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
 `;
-    throw new Error(text, { cause: e });
+    throw new PluginError(text, { cause: e, pluginManager: this });
   }
 };
 function noReturn() {
@@ -779,6 +930,133 @@ function validatePlugins(plugins, dependedPluginNames) {
   });
   return true;
 }
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
+  }
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
+    }
+    if (item.children?.length > 1) {
+      const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+      const exports = item.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        fileName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          fileName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    item.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    if (!curr) {
+      return acc;
+    }
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: `${prev.source}
+${curr.source}`,
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const exists = imports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
+      exports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  const importSource = tsCodegen.print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = tsCodegen.print(exportNodes);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
@@ -787,8 +1065,13 @@ async function transformReducer(_previousCode, result, _plugin) {
   }
   return result;
 }
-async function buildImplementation(options, done) {
+async function build(options) {
   const { config, logger } = options;
+  try {
+    await read(config.input.path);
+  } catch (e) {
+    throw new Error("Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
+  }
   if (config.output.clean) {
     await clean(config.output.path);
   }
@@ -816,7 +1099,17 @@ async function buildImplementation(options, done) {
       }
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask });
+  const onExecute = (executer) => {
+    if (!executer) {
+      return;
+    }
+    const { strategy, hookName, plugin } = executer;
+    if (config.logLevel === "info" && logger?.spinner) {
+      logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
+`;
+    }
+  };
+  const pluginManager = new PluginManager(config, { task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -827,23 +1120,7 @@ async function buildImplementation(options, done) {
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  setTimeout(() => {
-    done({ files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) });
-  }, 500);
-  pluginManager.fileManager.add({
-    path: isURL(config.input.path) ? config.input.path : pathParser2__default.default.resolve(config.root, config.input.path),
-    fileName: isURL(config.input.path) ? "input" : config.input.path,
-    source: isURL(config.input.path) ? config.input.path : await read(pathParser2__default.default.resolve(config.root, config.input.path))
-  });
-}
-function build(options) {
-  return new Promise(async (resolve, reject) => {
-    try {
-      await buildImplementation(options, resolve);
-    } catch (e) {
-      reject(e);
-    }
-  });
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager };
 }
 
 // src/config.ts
@@ -875,6 +1152,8 @@ var src_default = build;
 
 exports.FileManager = FileManager;
 exports.Generator = Generator;
+exports.ParallelPluginError = ParallelPluginError;
+exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
 exports.Queue = Queue;
 exports.SchemaGenerator = SchemaGenerator;
@@ -888,9 +1167,11 @@ exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
 exports.defineConfig = defineConfig;
+exports.getEncodedText = getEncodedText;
 exports.getFileSource = getFileSource;
 exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
+exports.getStackTrace = getStackTrace;
 exports.getUniqueName = getUniqueName;
 exports.hooks = hooks;
 exports.isPromise = isPromise;
@@ -899,8 +1180,9 @@ exports.name = name;
 exports.nameSorter = nameSorter;
 exports.objectToParameters = objectToParameters;
 exports.read = read;
+exports.renderTemplate = renderTemplate;
 exports.timeout = timeout;
+exports.transformReservedWord = transformReservedWord;
 exports.validatePlugins = validatePlugins;
 exports.write = write;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map
+exports.writeIndexes = writeIndexes;