@kubb/core 1.15.0-canary.20231027T174910 → 1.15.0-canary.20231027T200912

package/dist/index.js

@@ -1,18 +1,18 @@
 import mod, { createRequire } from 'module';
 import pc3 from 'picocolors';
+export { default as pc } from 'picocolors';
+import crypto from 'crypto';
 import fs2, { remove } from 'fs-extra';
-import seedrandom from 'seedrandom';
-import { switcher } from 'js-runtime';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
-import crypto2 from 'crypto';
-import path, { resolve, dirname, extname } from 'path';
-import { print } from '@kubb/parser';
-import * as factory from '@kubb/parser/factory';
-import isEqual from 'lodash.isequal';
 import { orderBy } from 'natural-orderby';
+import { performance } from 'perf_hooks';
+import seedrandom from 'seedrandom';
+import pathParser from 'path';
+import { switcher } from 'js-runtime';
 import dirTree from 'directory-tree';
+import { createImportDeclaration, print, createExportDeclaration } from '@kubb/parser';
+import isEqual from 'lodash.isequal';
 import { EventEmitter as EventEmitter$1 } from 'events';
-import { performance } from 'perf_hooks';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
@@ -27,45 +27,110 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
+
+// src/utils/cache.ts
+function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
+  return {
+    set(id, value) {
+      Store[id] = [0, value];
+    },
+    get(id) {
+      const item = Store[id];
+      if (!item) {
+        return null;
+      }
+      item[0] = 0;
+      return item[1];
+    },
+    has(id) {
+      const item = Store[id];
+      if (!item) {
+        return false;
+      }
+      item[0] = 0;
+      return true;
+    },
+    delete(id) {
+      return delete Store[id];
+    }
+  };
+}
+async function clean(path) {
+  return remove(path);
+}
+var FunctionParams = class {
+  type;
+  items = [];
+  constructor(type) {
+    this.type = type;
+    return this;
+  }
+  add(item) {
+    if (!item) {
+      return this;
+    }
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => this.items.push(it));
+      return this;
+    }
+    this.items.push(item);
+    return this;
+  }
+  toString() {
+    const sortedData = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
+    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
+      if (!name) {
+        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        return acc;
+      }
+      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
+      if (type) {
+        if (required) {
+          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        } else {
+          acc.push(`${parameterName}?: ${type}`);
+        }
+      } else {
+        acc.push(`${parameterName}`);
+      }
+      return acc;
+    }, []).join(", ");
   }
-});
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
 };
-async function clean(path3) {
-  return remove(path3);
+
+// src/utils/getUniqueName.ts
+function getUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    originalName += used;
+  }
+  data[originalName] = 1;
+  return originalName;
 }
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
-};
-function createLogger({ logLevel, name, spinner }) {
+
+// src/utils/isPromise.ts
+function isPromise(result) {
+  return typeof result?.then === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+
+// src/utils/jsdoc.ts
+function createJSDocBlockText({ comments }) {
+  const filteredComments = comments.filter(Boolean);
+  if (!filteredComments.length) {
+    return "";
+  }
+  return `/**
+ * ${filteredComments.join("\n * ")}
+ */`;
+}
+function createLogger(spinner) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -91,8 +156,6 @@ function createLogger({ logLevel, name, spinner }) {
     }
   };
   const logger = {
-    name,
-    logLevel,
     log,
     error,
     warn,
@@ -102,6 +165,75 @@ function createLogger({ logLevel, name, spinner }) {
   };
   return logger;
 }
+
+// src/utils/nameSorter.ts
+function nameSorter(a, b) {
+  if (a.name < b.name) {
+    return -1;
+  }
+  if (a.name > b.name) {
+    return 1;
+  }
+  return 0;
+}
+var Queue = class {
+  #queue = [];
+  #workerCount = 0;
+  #maxParallel;
+  #debug = false;
+  constructor(maxParallel, debug = false) {
+    this.#maxParallel = maxParallel;
+    this.#debug = debug;
+  }
+  run(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
+    return new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        reject("Aborted");
+      });
+      this.#queue.push(item);
+      this.#work();
+    });
+  }
+  runSync(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
+    new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+      });
+      this.#queue.push(item);
+      this.#work();
+    });
+  }
+  get hasJobs() {
+    return this.#workerCount > 0 || this.#queue.length > 0;
+  }
+  get count() {
+    return this.#workerCount;
+  }
+  #work() {
+    if (this.#workerCount >= this.#maxParallel) {
+      return;
+    }
+    this.#workerCount++;
+    let entry;
+    while (entry = this.#queue.shift()) {
+      const { reject, resolve, job, name, description } = entry;
+      if (this.#debug) {
+        performance.mark(name + "_start");
+      }
+      job().then((result) => {
+        resolve(result);
+        if (this.#debug) {
+          performance.mark(name + "_stop");
+          performance.measure(description, name + "_start", name + "_stop");
+        }
+      }).catch((err) => reject(err));
+    }
+    this.#workerCount--;
+  }
+};
 var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
 function randomColour(text, colours = defaultColours) {
   if (!text) {
@@ -128,22 +260,46 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
+function slash(path, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  }
+  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+  }
+  const relativePath = pathParser.relative(rootDir, filePath);
+  const path = slash(relativePath, platform);
+  if (path.startsWith("../")) {
+    return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)));
+  }
+  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`;
+}
+function getPathMode(path) {
+  if (!path) {
+    return "directory";
+  }
+  return pathParser.extname(path) ? "file" : "directory";
+}
 var reader = switcher(
   {
-    node: async (path3) => {
-      return fs2.readFile(path3, { encoding: "utf8" });
+    node: async (path) => {
+      return fs2.readFile(path, { encoding: "utf8" });
     },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
+    bun: async (path) => {
+      const file = Bun.file(path);
       return file.text();
     }
   },
   "node"
 );
-switcher(
+var syncReader = switcher(
   {
-    node: (path3) => {
-      return fs2.readFileSync(path3, { encoding: "utf8" });
+    node: (path) => {
+      return fs2.readFileSync(path, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -151,115 +307,79 @@ switcher(
   },
   "node"
 );
-async function read(path3) {
-  return reader(path3);
+async function read(path) {
+  return reader(path);
 }
-var URLPath = class {
-  constructor(path3) {
-    this.path = path3;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
-        return true;
-      }
-    } catch (error) {
-      return false;
-    }
-    return false;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
-  }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
-    };
-    if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
-      }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-    }
-    return object;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
+function readSync(path) {
+  return syncReader(path);
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  const matches = template.match(/{{(.*?)}}/g);
+  return matches?.reduce((prev, curr) => {
+    const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
+    if (index === void 0) {
+      return prev;
     }
-    return `\`${newPath}\``;
-  }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
+    const value = data[index];
+    if (value === void 0) {
+      return prev;
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+    return prev.replace(curr, () => {
+      if (typeof value === "boolean") {
+        return `${value.toString()}` || "false";
+      }
+      return value || "";
+    }).trim();
+  }, template) || "";
+}
+
+// src/utils/SummaryError.ts
+var SummaryError = class extends Error {
+  summary;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "SummaryError";
+    this.summary = options.summary || [];
   }
 };
 
-// src/config.ts
-function defineConfig(options) {
-  return options;
-}
-function isInputPath(result) {
-  return !!result && "path" in result;
-}
+// src/utils/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout2;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled) {
+        return void 0;
+      }
+      if (wait) {
+        return void 0;
+      }
+      const val = fn(...args);
+      wait = true;
+      timeout2 = setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout2);
+    }
+  ];
+};
 
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     setTimeout(() => {
-      resolve2(true);
+      resolve(true);
     }, ms);
   });
 }
@@ -269,17 +389,6 @@ function combineCodes(codes) {
   return codes.join("\n");
 }
 
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
-  }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
-}
-
 // src/utils/transformers/escape.ts
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
@@ -305,39 +414,6 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/indent.ts
-function createIndent(size) {
-  return Array.from({ length: size + 1 }).join(" ");
-}
-
-// src/utils/transformers/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-
-// src/utils/transformers/searchAndReplace.ts
-function searchAndReplace(options) {
-  const { text, replaceBy, prefix = "", key } = options;
-  const searchValues = options.searchValues?.(prefix, key) || [
-    `${prefix}["${key}"]`,
-    `${prefix}['${key}']`,
-    `${prefix}[\`${key}\`]`,
-    `${prefix}"${key}"`,
-    `${prefix}'${key}'`,
-    `${prefix}\`${key}\``,
-    new RegExp(`${prefix}${key}`, "g")
-  ];
-  return searchValues.reduce((prev, searchValue) => {
-    return prev.toString().replaceAll(searchValue, replaceBy);
-  }, text);
-}
-
 // src/utils/transformers/transformReservedWord.ts
 var reservedWords = [
   "abstract",
@@ -430,83 +506,11 @@ function transformReservedWord(word) {
   }
   return word;
 }
-
-// src/utils/transformers/index.ts
-var transformers = {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  nameSorter,
-  searchAndReplace,
-  JSDoc: {
-    createJSDocBlockText
-  }
-};
-async function saveCreateDirectory(path3) {
-  const passedPath = dirname(resolve(path3));
-  await fs2.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path3, data) => {
-      try {
-        await fs2.stat(resolve(path3));
-        const oldContent = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-        if (oldContent?.toString() === data?.toString()) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path3);
-      await fs2.writeFile(resolve(path3), data, { encoding: "utf-8" });
-      const savedData = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path3}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-      }
-      return savedData;
-    },
-    bun: async (path3, data) => {
-      try {
-        await saveCreateDirectory(path3);
-        await Bun.write(resolve(path3), data);
-        const file = Bun.file(resolve(path3));
-        const savedData = await file.text();
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path3}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-        }
-        return savedData;
-      } catch (e) {
-        console.log(e, resolve(path3));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path3) {
-  if (data.trim() === "") {
-    return void 0;
-  }
-  return writer(path3, data.trim());
-}
 var TreeNode = class _TreeNode {
+  data;
+  parent;
+  children = [];
   constructor(data, parent) {
-    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -566,16 +570,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path3, options = {}) {
+  static build(path, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
       const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) });
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
         if (item.children?.length) {
           item.children?.forEach((child) => {
             recurse(subNode, child);
@@ -590,287 +594,227 @@ var TreeNode = class _TreeNode {
   }
 };
 
-// src/BarrelManager.ts
-var _options;
-var BarrelManager = class {
-  constructor(options = {}) {
-    __privateAdd(this, _options, {});
-    __privateSet(this, _options, options);
+// src/utils/uniqueIdFactory.ts
+var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
+var URLPath = class {
+  path;
+  constructor(path) {
+    this.path = path;
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        return true;
       }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
-    if (!tree) {
-      return null;
+    } catch (error) {
+      return false;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
-        return [];
-      }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && indexPath.includes("index")) {
-            return void 0;
-          }
-          return {
-            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
-            isTypeOnly
-          };
-        }).filter(Boolean);
-        files2.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
-        });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
-        });
-      }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
-      });
-      return files2;
-    };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
+    return false;
   }
-};
-_options = new WeakMap();
-
-// src/FileManager.ts
-var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
-var _FileManager = class _FileManager {
-  constructor(options) {
-    __privateAdd(this, _validate);
-    __privateAdd(this, _add);
-    __privateAdd(this, _addOrAppend);
-    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
-    __privateAdd(this, _task, void 0);
-    __privateAdd(this, _isWriting, false);
-    /**
-     * Timeout between writes
-     */
-    __privateAdd(this, _timeout, 0);
-    __privateAdd(this, _queue, void 0);
-    if (options) {
-      __privateSet(this, _task, options.task);
-      __privateSet(this, _queue, options.queue);
-      __privateSet(this, _timeout, options.timeout || 0);
-    }
-    return this;
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
   }
-  get files() {
-    const files = [];
-    __privateGet(this, _cache).forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
+  get object() {
+    return this.toObject();
   }
-  get isExecuting() {
-    return __privateGet(this, _queue)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
+  get params() {
+    return this.getParams();
   }
-  async add(...files) {
-    const promises = files.map((file) => {
-      __privateMethod(this, _validate, validate_fn).call(this, file);
-      if (file.override) {
-        return __privateMethod(this, _add, add_fn).call(this, file);
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type !== "template") {
+        throw new Error("Type should be `template` when using stringiyf");
       }
-      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
-    });
-    const resolvedFiles = await Promise.all(promises);
-    if (files.length > 1) {
-      return resolvedFiles;
+      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
     }
-    return resolvedFiles[0];
+    return object;
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
-    if (!files) {
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
       return void 0;
     }
-    return await Promise.all(
-      files.map((file) => {
-        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
-          ...file,
-          meta: meta ? meta : file.meta
-        });
-      })
-    );
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
+      params[pathParam] = pathParam;
+    }, this.path);
+    return params;
   }
-  getCacheByUUID(UUID) {
-    let cache;
-    __privateGet(this, _cache).forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
-    });
-    return cache;
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
   }
-  get(path3) {
-    return __privateGet(this, _cache).get(path3);
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  remove(path3) {
-    const cacheItem = this.get(path3);
-    if (!cacheItem) {
-      return;
+};
+async function saveCreateDirectory(path) {
+  const passedPath = pathParser.dirname(pathParser.resolve(path));
+  await fs2.mkdir(passedPath, { recursive: true });
+}
+var writer = switcher(
+  {
+    node: async (path, data) => {
+      try {
+        await fs2.stat(path);
+        const oldContent = await fs2.readFile(path, { encoding: "utf-8" });
+        if (oldContent?.toString() === data) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path);
+      return fs2.writeFile(pathParser.resolve(path), data, { encoding: "utf-8" });
+    },
+    bun: async (path, data) => {
+      try {
+        await saveCreateDirectory(path);
+        await Bun.write(pathParser.resolve(path), data);
+      } catch (e) {
+        console.log(e, pathParser.resolve(path));
+      }
     }
-    __privateGet(this, _cache).delete(path3);
-  }
-  async write(...params) {
-    if (!__privateGet(this, _isWriting)) {
-      __privateSet(this, _isWriting, true);
-      const text = await write(...params);
-      __privateSet(this, _isWriting, false);
-      return text;
+  },
+  "node"
+);
+async function write(data, path) {
+  return writer(path, data);
+}
+function getIndexes(root, extName, options = {}) {
+  const extMapper = {
+    ".ts": {
+      extensions: /\.ts/,
+      exclude: [/schemas/, /json/]
+    },
+    ".json": {
+      extensions: /\.json/,
+      exclude: []
     }
-    await timeout(__privateGet(this, _timeout));
-    return this.write(...params);
-  }
-  async read(...params) {
-    return read(...params);
+  };
+  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
+  if (!tree) {
+    return null;
   }
-  // statics
-  static getSource(file) {
-    if (!_FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source;
+  const fileReducer = (files2, currentTree) => {
+    if (!currentTree.children) {
+      return [];
     }
-    const exports = file.exports ? combineExports(file.exports) : [];
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-    const exportNodes = exports.map(
-      (item) => factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    );
-    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
-  }
-  static combineFiles(files) {
-    return files.filter(Boolean).reduce((acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
+    if (currentTree.children?.length > 1) {
+      const path = pathParser.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.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,
+        baseName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      currentTree.children?.forEach((child) => {
+        const path = pathParser.resolve(currentTree.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          baseName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    currentTree.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
       const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
-        return acc;
-      }
       if (prev) {
         acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
+          ...curr,
+          source: prev.source && curr.source ? `${prev.source}
+${curr.source}` : "",
+          imports: [...prev.imports || [], ...curr.imports || []],
+          exports: [...prev.exports || [], ...curr.exports || []],
+          env: { ...prev.env || {}, ...curr.env || {} }
         };
       }
-      return acc;
-    }, []);
-  }
-  static getMode(path3) {
-    if (!path3) {
-      return "directory";
+    } else {
+      acc.push(curr);
     }
-    return extname(path3) ? "file" : "directory";
-  }
-  static get extensions() {
-    return [".js", ".ts", ".tsx"];
-  }
-  static isExtensionAllowed(baseName) {
-    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
-  }
-};
-_cache = new WeakMap();
-_task = new WeakMap();
-_isWriting = new WeakMap();
-_timeout = new WeakMap();
-_queue = new WeakMap();
-_validate = new WeakSet();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
-  }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-  }
-};
-_add = new WeakSet();
-add_fn = async function(file) {
-  const controller = new AbortController();
-  const resolvedFile = { id: crypto2.randomUUID(), ...file };
-  __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-  if (__privateGet(this, _queue)) {
-    await __privateGet(this, _queue).run(
-      async () => {
-        var _a;
-        return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
-      },
-      { controller }
-    );
-  }
-  return resolvedFile;
-};
-_addOrAppend = new WeakSet();
-addOrAppend_fn = async function(file) {
-  const previousCaches = __privateGet(this, _cache).get(file.path);
-  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
-  if (previousCache) {
-    __privateGet(this, _cache).delete(previousCache.path);
-    return __privateMethod(this, _add, add_fn).call(this, {
-      ...file,
-      source: previousCache.source && file.source ? `${previousCache.source}
-${file.source}` : "",
-      imports: [...previousCache.imports || [], ...file.imports || []],
-      exports: [...previousCache.exports || [], ...file.exports || []],
-      env: { ...previousCache.env || {}, ...file.env || {} }
-    });
-  }
-  return __privateMethod(this, _add, add_fn).call(this, file);
-};
-var FileManager = _FileManager;
+    return acc;
+  }, []);
+}
+var extensions = [".js", ".ts", ".tsx"];
+function isExtensionAllowed(baseName) {
+  return extensions.some((extension) => baseName.endsWith(extension));
+}
 function combineExports(exports) {
-  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
+  return exports.reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathAndIsTypeOnly) {
-      return prev;
-    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -892,16 +836,12 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
-  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
+  return imports.reduce((prev, curr) => {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
     const hasImportInSource = (importName) => {
-      if (!source) {
-        return true;
-      }
-      const checker = (name2) => name2 && !!source.includes(name2);
+      const checker = (name2) => name2 && !!source.includes(`${name2}`);
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
@@ -909,10 +849,6 @@ function combineImports(imports, exports, source) {
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
     const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathNameAndIsTypeOnly) {
-      return prev;
-    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -934,7 +870,43 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
-  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
+}
+function createFileSource(file) {
+  let { source } = file;
+  if (!isExtensionAllowed(file.baseName)) {
+    return file.source;
+  }
+  const exports = file.exports ? combineExports(file.exports) : [];
+  const imports = file.imports ? combineImports(file.imports, exports, source) : [];
+  const importNodes = imports.map((item) => createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+  const importSource = print(importNodes);
+  const exportNodes = exports.map((item) => createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
+  const exportSource = print(exportNodes);
+  source = getEnvSource(file.source, file.env);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
+function searchAndReplace(options) {
+  const { text, replaceBy, prefix = "", key } = options;
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, "g")
+  ];
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy);
+  }, text);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -951,128 +923,132 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
-var _emitter;
-var EventEmitter = class {
-  constructor() {
-    __privateAdd(this, _emitter, new EventEmitter$1());
-    __privateGet(this, _emitter).setMaxListeners(100);
+
+// src/managers/fileManager/FileManager.ts
+var FileManager = class {
+  #cache = /* @__PURE__ */ new Map();
+  #task;
+  #queue;
+  constructor(options) {
+    if (options) {
+      this.#task = options.task;
+      this.#queue = options.queue;
+    }
+    return this;
   }
-  emit(eventName, ...eventArg) {
-    __privateGet(this, _emitter).emit(eventName, ...eventArg);
+  get extensions() {
+    return extensions;
   }
-  on(eventName, handler) {
-    __privateGet(this, _emitter).on(eventName, handler);
-  }
-  off(eventName, handler) {
-    __privateGet(this, _emitter).off(eventName, handler);
+  get files() {
+    const files = [];
+    this.#cache.forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
   }
-  removeAll() {
-    __privateGet(this, _emitter).removeAllListeners();
+  get isExecuting() {
+    return this.#queue?.hasJobs ?? false;
   }
-};
-_emitter = new WeakMap();
-var _queue2, _workerCount, _maxParallel, _debug, _work, work_fn;
-var Queue = class {
-  constructor(maxParallel, debug = false) {
-    __privateAdd(this, _work);
-    __privateAdd(this, _queue2, []);
-    this.eventEmitter = new EventEmitter();
-    __privateAdd(this, _workerCount, 0);
-    __privateAdd(this, _maxParallel, void 0);
-    __privateAdd(this, _debug, false);
-    __privateSet(this, _maxParallel, maxParallel);
-    __privateSet(this, _debug, debug);
-  }
-  run(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
-        reject("Aborted");
-      });
-      __privateGet(this, _queue2).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
+  async add(file) {
+    const controller = new AbortController();
+    const resolvedFile = { id: crypto.randomUUID(), ...file };
+    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+    if (this.#queue) {
+      try {
+        await this.#queue.run(
+          async () => {
+            return this.#task?.(resolvedFile);
+          },
+          { controller }
+        );
+      } catch {
+        return resolvedFile;
+      }
+    }
+    return resolvedFile;
   }
-  runSync(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
+  async addOrAppend(file) {
+    const previousCaches = this.#cache.get(file.path);
+    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+    if (previousCache) {
+      this.#cache.delete(previousCache.path);
+      return this.add({
+        ...file,
+        source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+        imports: [...previousCache.imports || [], ...file.imports || []],
+        exports: [...previousCache.exports || [], ...file.exports || []],
+        env: { ...previousCache.env || {}, ...file.env || {} }
       });
-      __privateGet(this, _queue2).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
+    }
+    return this.add(file);
   }
-  get hasJobs() {
-    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
+  async addIndexes(root, extName = ".ts", options = {}) {
+    const files = await getIndexes(root, extName, options);
+    if (!files) {
+      return void 0;
+    }
+    return Promise.all(
+      files.map((file) => {
+        if (file.override) {
+          return this.add(file);
+        }
+        return this.addOrAppend(file);
+      })
+    );
   }
-  get count() {
-    return __privateGet(this, _workerCount);
+  #append(path, file) {
+    const previousFiles = this.#cache.get(path) || [];
+    this.#cache.set(path, [...previousFiles, file]);
   }
-};
-_queue2 = new WeakMap();
-_workerCount = new WeakMap();
-_maxParallel = new WeakMap();
-_debug = new WeakMap();
-_work = new WeakSet();
-work_fn = function() {
-  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
-    return;
-  }
-  __privateWrapper(this, _workerCount)._++;
-  let entry;
-  while (entry = __privateGet(this, _queue2).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
-    if (__privateGet(this, _debug)) {
-      performance.mark(name + "_start");
-    }
-    job().then((result) => {
-      this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
-      if (__privateGet(this, _debug)) {
-        performance.mark(name + "_stop");
-        performance.measure(description, name + "_start", name + "_stop");
-      }
-    }).catch((err) => {
-      this.eventEmitter.emit("jobFailed", err);
-      reject(err);
+  getCacheByUUID(UUID) {
+    let cache;
+    this.#cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
     });
+    return cache;
   }
-  __privateWrapper(this, _workerCount)._--;
-};
-
-// src/utils/uniqueName.ts
-function setUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    return originalName;
+  get(path) {
+    return this.#cache.get(path);
   }
-  data[originalName] = 1;
-  return originalName;
-}
-
-// src/errors.ts
-var PluginError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
+  remove(path) {
+    const cacheItem = this.get(path);
+    if (!cacheItem) {
+      return;
+    }
+    this.#cache.delete(path);
+  }
+  async write(...params) {
+    if (this.#queue) {
+      return this.#queue.run(async () => {
+        return write(...params);
+      });
+    }
+    return write(...params);
+  }
+  async read(...params) {
+    if (this.#queue) {
+      return this.#queue.run(async () => {
+        return read(...params);
+      });
+    }
+    return read(...params);
   }
 };
+
+// src/managers/pluginManager/ParallelPluginError.ts
 var ParallelPluginError = class extends Error {
+  errors = [];
+  pluginManager;
   constructor(message, options) {
     super(message, { cause: options.cause });
-    this.errors = [];
     this.name = "ParallelPluginError";
     this.errors = options.errors;
     this.pluginManager = options.pluginManager;
@@ -1092,54 +1068,30 @@ var ParallelPluginError = class extends Error {
     })?.cause;
   }
 };
-var SummaryError = class extends Error {
+
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  cause;
   constructor(message, options) {
     super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
-};
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
+    this.name = "PluginError";
+    this.cause = options.cause;
+    this.pluginManager = options.pluginManager;
   }
 };
-var ValidationPluginError = class extends Error {
-};
-
-// src/utils/cache.ts
-function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
-  return {
-    set(id, value) {
-      Store[id] = [0, value];
-    },
-    get(id) {
-      const item = Store[id];
-      if (!item) {
-        return null;
-      }
-      item[0] = 0;
-      return item[1];
-    },
-    has(id) {
-      const item = Store[id];
-      if (!item) {
-        return false;
-      }
-      item[0] = 0;
-      return true;
-    },
-    delete(id) {
-      return delete Store[id];
-    }
-  };
-}
-
-// src/plugin.ts
-function createPlugin(factory2) {
+function createPlugin(factory) {
   return (options) => {
-    return factory2(options);
+    const plugin = factory(options);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
+    }
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
+    }
+    return plugin;
   };
 }
 var pluginName = "core";
@@ -1148,8 +1100,6 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
-    key: ["controller", "core"],
-    kind: "controller",
     api() {
       return {
         get config() {
@@ -1158,18 +1108,18 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
-        get plugin() {
-          return options.plugin;
-        },
         logger,
         fileManager,
         pluginManager,
         async addFile(...files) {
-          const resolvedFiles = await fileManager.add(...files);
-          if (!Array.isArray(resolvedFiles)) {
-            return [resolvedFiles];
-          }
-          return resolvedFiles;
+          return Promise.all(
+            files.map((file) => {
+              if (file.override) {
+                return fileManager.add(file);
+              }
+              return fileManager.addOrAppend(file);
+            })
+          );
         },
         resolvePath,
         resolveName,
@@ -1177,133 +1127,75 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      return path.resolve(root, baseName);
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      return pathParser.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-
-// src/utils/executeStrategies.ts
-function hookSeq(promises) {
-  return promises.reduce(
-    (promise, func) => {
-      if (!func || typeof func !== "function") {
-        throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-      }
-      return promise.then((result) => {
-        const calledFunc = func();
-        if (calledFunc) {
-          return calledFunc.then(Array.prototype.concat.bind(result));
-        }
-      });
-    },
-    Promise.resolve([])
-  );
-}
-
-// src/PromiseManager.ts
-var _options2;
-var PromiseManager = class {
-  constructor(options = {}) {
-    __privateAdd(this, _options2, {});
-    __privateSet(this, _options2, options);
-    return this;
+var EventEmitter = class {
+  constructor() {
+    this.#emitter.setMaxListeners(100);
   }
-  run(strategy, promises) {
-    if (strategy === "seq") {
-      return hookSeq(promises);
-    }
-    throw new Error(`${strategy} not implemented`);
+  #emitter = new EventEmitter$1();
+  emit(eventName, ...eventArg) {
+    this.#emitter.emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    this.#emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.#emitter.off(eventName, handler);
+  }
+  removeAll() {
+    this.#emitter.removeAllListeners();
   }
 };
-_options2 = new WeakMap();
-function isPromise(result) {
-  return !!result && typeof result?.then === "function";
-}
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
+
+// src/managers/pluginManager/pluginParser.ts
+var usedPluginNames = {};
+function pluginParser(plugin, context) {
+  const key = [plugin.kind, plugin.name, getUniqueName(plugin.name, usedPluginNames).split(plugin.name).at(1)];
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      key,
+      api
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
 }
 
-// src/PluginManager.ts
-var _core, _usedPluginNames, _promiseManager, _getSortedPlugins, getSortedPlugins_fn, _addExecutedToCallStack, addExecutedToCallStack_fn, _execute, execute_fn, _executeSync, executeSync_fn, _catcher, catcher_fn, _parse, parse_fn;
+// src/managers/pluginManager/PluginManager.ts
+var hookNames = {
+  validate: 1,
+  buildStart: 1,
+  resolvePath: 1,
+  resolveName: 1,
+  load: 1,
+  transform: 1,
+  writeFile: 1,
+  buildEnd: 1
+};
+var hooks = Object.keys(hookNames);
 var PluginManager = class {
+  plugins;
+  fileManager;
+  eventEmitter = new EventEmitter();
+  queue;
+  executed = [];
+  logger;
+  #core;
   constructor(config, options) {
-    __privateAdd(this, _getSortedPlugins);
-    __privateAdd(this, _addExecutedToCallStack);
-    /**
-     * 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
-    __privateAdd(this, _execute);
-    /**
-     * 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.
-     */
-    __privateAdd(this, _executeSync);
-    __privateAdd(this, _catcher);
-    __privateAdd(this, _parse);
-    this.eventEmitter = new EventEmitter();
-    this.executed = [];
-    __privateAdd(this, _core, void 0);
-    __privateAdd(this, _usedPluginNames, {});
-    __privateAdd(this, _promiseManager, void 0);
-    this.resolvePath = (params) => {
-      if (params.pluginKey) {
-        const paths = this.hookForPluginSync({
-          pluginKey: params.pluginKey,
-          hookName: "resolvePath",
-          parameters: [params.baseName, params.directory, params.options]
-        });
-        if (paths && paths?.length > 1) {
-          throw new Error(
-            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Paths: ${JSON.stringify(paths, void 0, 2)}`
-          );
-        }
-        return paths?.at(0);
-      }
-      return this.hookFirstSync({
-        hookName: "resolvePath",
-        parameters: [params.baseName, params.directory, 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) {
-          throw new Error(
-            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Names: ${JSON.stringify(names, void 0, 2)}`
-          );
-        }
-        return transformReservedWord(names?.at(0) || params.name);
-      }
-      const name = this.hookFirstSync({
-        hookName: "resolveName",
-        parameters: [params.name, params.type]
-      }).result;
-      return transformReservedWord(name);
-    };
     this.logger = options.logger;
-    this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
-    __privateSet(this, _promiseManager, new PromiseManager());
-    const plugins = config.plugins || [];
+    this.queue = new Queue(100, options.debug);
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1311,14 +1203,44 @@ Names: ${JSON.stringify(names, void 0, 2)}`
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
-    });
-    __privateSet(this, _core, __privateMethod(this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
-    this.plugins = [__privateGet(this, _core), ...plugins].map((plugin) => {
-      return __privateMethod(this, _parse, parse_fn).call(this, plugin, this, __privateGet(this, _core).api);
+      getPlugins: this.#getSortedPlugins.bind(this),
+      plugin: void 0
     });
+    this.#core = pluginParser(core, core.api.call(null));
+    this.plugins = [this.#core, ...config.plugins || []].reduce((prev, plugin) => {
+      const convertedApi = pluginParser(plugin, this.#core?.api);
+      return [...prev, convertedApi];
+    }, []);
     return this;
   }
+  resolvePath = (params) => {
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolvePath",
+        parameters: [params.baseName, params.directory, params.options]
+      });
+    }
+    return this.hookFirstSync({
+      hookName: "resolvePath",
+      parameters: [params.baseName, params.directory, params.options]
+    }).result;
+  };
+  resolveName = (params) => {
+    if (params.pluginName) {
+      const name2 = this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolveName",
+        parameters: [params.name, params.type]
+      });
+      return transformReservedWord(name2 || params.name);
+    }
+    const name = this.hookFirstSync({
+      hookName: "resolveName",
+      parameters: [params.name, params.type]
+    }).result;
+    return transformReservedWord(name);
+  };
   on(eventName, handler) {
     this.eventEmitter.on(eventName, handler);
   }
@@ -1326,35 +1248,30 @@ Names: ${JSON.stringify(names, void 0, 2)}`
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginKey,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    const promises = plugins.map((plugin) => {
-      return __privateMethod(this, _execute, execute_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
-    return Promise.all(promises);
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.#execute({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
   }
   hookForPluginSync({
-    pluginKey,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    return plugins.map((plugin) => {
-      return __privateMethod(this, _executeSync, executeSync_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.#executeSync({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1365,7 +1282,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     skipped
   }) {
     let promise = Promise.resolve(null);
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+    for (const plugin of this.#getSortedPlugins()) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
@@ -1373,7 +1290,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
         if (parseResult?.result != null) {
           return parseResult;
         }
-        const value = await __privateMethod(this, _execute, execute_fn).call(this, {
+        const value = await this.#execute({
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1398,12 +1315,12 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     skipped
   }) {
     let parseResult = null;
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+    for (const plugin of this.#getSortedPlugins()) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
       parseResult = {
-        result: __privateMethod(this, _executeSync, executeSync_fn).call(this, {
+        result: this.#executeSync({
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1425,8 +1342,8 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     parameters
   }) {
     const parallelPromises = [];
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      const promise = __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
+    for (const plugin of this.#getSortedPlugins()) {
+      const promise = this.#execute({ strategy: "hookParallel", hookName, parameters, plugin });
       if (promise) {
         parallelPromises.push(promise);
       }
@@ -1453,16 +1370,16 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }) {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+    for (const plugin of this.#getSortedPlugins()) {
       promise = promise.then((arg0) => {
-        const value = __privateMethod(this, _execute, execute_fn).call(this, {
+        const value = this.#execute({
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
           plugin
         });
         return value;
-      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
+      }).then((result) => reduce.call(this.#core.api, argument0, result, plugin));
     }
     return promise;
   }
@@ -1470,192 +1387,160 @@ Names: ${JSON.stringify(names, void 0, 2)}`
    * Chains plugins
    */
   hookSeq({ hookName, parameters }) {
-    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
-      return () => __privateMethod(this, _execute, execute_fn).call(this, {
-        strategy: "hookSeq",
-        hookName,
-        parameters,
-        plugin
+    let promise = Promise.resolve();
+    for (const plugin of this.#getSortedPlugins()) {
+      promise = promise.then(() => {
+        this.#execute({
+          strategy: "hookSeq",
+          hookName,
+          parameters,
+          plugin
+        });
       });
-    });
-    return __privateGet(this, _promiseManager).run("seq", promises);
+    }
+    return promise.then(noReturn);
+  }
+  #getSortedPlugins(hookName) {
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+    if (hookName) {
+      return plugins.filter((item) => item[hookName]);
+    }
+    return plugins;
   }
-  getPluginsByKey(hookName, pluginKey) {
+  getPlugin(hookName, pluginName2) {
     const plugins = [...this.plugins];
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
-    const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [kind, name, identifier] = item.key;
-      const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const kindCheck = kind === searchKind;
-      const nameCheck = name === searchPluginName;
-      if (searchIdentifier) {
-        return identifierCheck && kindCheck && nameCheck;
-      }
-      return kindCheck && nameCheck;
-    });
-    if (!pluginByPluginName?.length) {
-      const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === "info") {
-        if (corePlugin) {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
-        } else {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`);
-        }
-      }
-      return corePlugin ? [corePlugin] : [];
+    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
+    if (!pluginByPluginName) {
+      return this.#core;
     }
     return pluginByPluginName;
   }
-  static getDependedPlugins(plugins, dependedPluginNames) {
-    let pluginNames = [];
-    if (typeof dependedPluginNames === "string") {
-      pluginNames = [dependedPluginNames];
-    } else {
-      pluginNames = dependedPluginNames;
+  #addExecutedToCallStack(executer) {
+    if (executer) {
+      this.eventEmitter.emit("execute", executer);
+      this.executed.push(executer);
     }
-    return pluginNames.map((pluginName2) => {
-      const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
-      if (!plugin) {
-        throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
-      }
-      return plugin;
-    });
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  static get hooks() {
-    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
   }
-};
-_core = new WeakMap();
-_usedPluginNames = new WeakMap();
-_promiseManager = new WeakMap();
-_getSortedPlugins = new WeakSet();
-getSortedPlugins_fn = function(hookName) {
-  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-  if (hookName) {
-    if (this.logger.logLevel === "info") {
-      const containsHookName = plugins.some((item) => item[hookName]);
-      if (!containsHookName) {
-        this.logger.warn(`No hook ${hookName} found`);
-      }
+  /**
+   * 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;
     }
-    return plugins.filter((item) => item[hookName]);
-  }
-  return plugins;
-};
-_addExecutedToCallStack = new WeakSet();
-addExecutedToCallStack_fn = function(executer) {
-  if (executer) {
-    this.eventEmitter.emit("executed", executer);
-    this.executed.push(executer);
-  }
-};
-_execute = new WeakSet();
-execute_fn = function({
-  strategy,
-  hookName,
-  parameters,
-  plugin
-}) {
-  const hook = plugin[hookName];
-  let output;
-  if (!hook) {
-    return null;
-  }
-  this.eventEmitter.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);
+    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+    const task = Promise.resolve().then(() => {
+      if (typeof hook === "function") {
+        const possiblePromiseResult = hook.apply({ ...this.#core.api, plugin }, parameters);
+        if (isPromise(possiblePromiseResult)) {
+          return Promise.resolve(possiblePromiseResult);
+        }
+        return possiblePromiseResult;
       }
-      return possiblePromiseResult;
-    }
-    return hook;
-  }).then((result) => {
-    output = result;
-    return result;
-  }).catch((e) => {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  }).finally(() => {
-    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
-      parameters,
-      output,
-      strategy,
-      hookName,
-      plugin
+      return hook;
+    }).then((result) => {
+      output = result;
+      return result;
+    }).catch((e) => {
+      this.#catcher(e, plugin, hookName);
+      return null;
+    }).finally(() => {
+      this.#addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
     });
-  });
-  return task;
-};
-_executeSync = new WeakSet();
-executeSync_fn = function({
-  strategy,
-  hookName,
-  parameters,
-  plugin
-}) {
-  const hook = plugin[hookName];
-  let output;
-  if (!hook) {
-    return null;
+    return task;
   }
-  this.eventEmitter.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;
+  /**
+   * 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.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+    try {
+      if (typeof hook === "function") {
+        const fn = hook.apply(this.#core.api, parameters);
+        output = fn;
+        return fn;
+      }
+      output = hook;
+      return hook;
+    } catch (e) {
+      this.#catcher(e, plugin, hookName);
+      return null;
+    } finally {
+      this.#addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
     }
-    output = hook;
-    return hook;
-  } catch (e) {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  } finally {
-    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
-      parameters,
-      output,
-      strategy,
-      hookName,
-      plugin
-    });
   }
-};
-_catcher = new WeakSet();
-catcher_fn = function(e, plugin, hookName) {
-  const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
+  #catcher(e, plugin, hookName) {
+    const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
 `;
-  const pluginError = new PluginError(text, { cause: e, pluginManager: this });
-  this.eventEmitter.emit("error", pluginError);
-  throw pluginError;
-};
-_parse = new WeakSet();
-parse_fn = function(plugin, pluginManager, context) {
-  const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
-  setUniqueName(plugin.name, usedPluginNames);
-  const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-  if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
-    pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
-  }
-  if (!plugin.transform) {
-    plugin.transform = function transform(code) {
-      return code;
-    };
-  }
-  if (plugin.api && typeof plugin.api === "function") {
-    const api = plugin.api.call(context);
-    return {
-      ...plugin,
-      key,
-      api
-    };
+    const pluginError = new PluginError(text, { cause: e, pluginManager: this });
+    this.eventEmitter.emit("error", pluginError);
+    throw pluginError;
   }
-  return {
-    ...plugin,
-    key
-  };
+};
+function noReturn() {
+}
+
+// src/managers/pluginManager/validate.ts
+var ValidationPluginError = class extends Error {
+};
+function getDependedPlugins(plugins, dependedPluginNames) {
+  let pluginNames = [];
+  if (typeof dependedPluginNames === "string") {
+    pluginNames = [dependedPluginNames];
+  } else {
+    pluginNames = dependedPluginNames;
+  }
+  return pluginNames.map((pluginName2) => {
+    const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
+    if (!plugin) {
+      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
+    }
+    return plugin;
+  });
+}
+
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
 };
 
 // src/build.ts
@@ -1663,13 +1548,13 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
+  const { config, logLevel, logger = createLogger() } = options;
   try {
-    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
+    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
-    if (isInputPath(config)) {
+    if ("path" in config.input) {
       throw new Error(
         "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3.dim(config.input.path),
         {
@@ -1682,11 +1567,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path: path3 } = file;
-    let code = FileManager.getSource(file);
+    const { path } = file;
+    let code = createFileSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path3]
+      parameters: [path]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1697,53 +1582,28 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path3],
+        parameters: [code, path],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
-        if (file.meta?.pluginKey) {
-          return pluginManager.hookForPlugin({
-            pluginKey: file.meta?.pluginKey,
-            hookName: "writeFile",
-            parameters: [transformedCode, path3]
-          });
-        }
-        return pluginManager.hookFirst({
+        await pluginManager.hookParallel({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [transformedCode, path]
         });
       }
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
+  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
   const { plugins, fileManager } = pluginManager;
   pluginManager.on("execute", (executer) => {
-    const { hookName, parameters, plugin } = executer;
-    if (hookName === "writeFile" && logger.spinner) {
-      const [code] = parameters;
-      if (logger.logLevel === LogLevel.info) {
-        logger.spinner.start(`\u{1F4BE} Writing`);
-      }
-      if (logger.logLevel === "debug") {
-        logger.info(`PluginKey ${pc3.dim(JSON.stringify(plugin.key))} 
-with source
-
-${code}`);
-      }
-    }
-  });
-  pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
     const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (logger.logLevel === LogLevel.info && logger.spinner) {
-      if (hookName === "writeFile") {
-        const [_code, path3] = parameters;
-        logger.spinner.suffixText = pc3.dim(path3);
-      } else {
+    if (logLevel === LogLevel.info) {
+      if (logger.spinner) {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logger.logLevel === LogLevel.debug) {
+    if (logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1763,72 +1623,74 @@ ${code}`);
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (!fileManager.isExecuting && logger.spinner) {
-    logger.spinner.suffixText = "";
-    logger.spinner.succeed(`\u{1F4BE} Writing completed`);
-  }
-  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
+  return { files: fileManager.files.map((file) => ({ ...file, source: createFileSource(file) })), pluginManager };
+}
+
+// src/config.ts
+function defineConfig(options) {
+  return options;
 }
 
-// src/Generator.ts
-var _options3, _context;
+// src/generators/Generator.ts
 var Generator = class {
+  #options = {};
+  #context = {};
   constructor(options, context) {
-    __privateAdd(this, _options3, {});
-    __privateAdd(this, _context, {});
     if (context) {
-      __privateSet(this, _context, context);
+      this.#context = context;
     }
     if (options) {
-      __privateSet(this, _options3, options);
+      this.#options = options;
     }
     return this;
   }
   get options() {
-    return __privateGet(this, _options3);
+    return this.#options;
   }
   get context() {
-    return __privateGet(this, _context);
+    return this.#context;
   }
   set options(options) {
-    __privateSet(this, _options3, { ...__privateGet(this, _options3), ...options });
+    this.#options = { ...this.#options, ...options };
   }
 };
-_options3 = new WeakMap();
-_context = new WeakMap();
-var _cache2, _cwd, _SLASHES;
-var _PackageManager = class _PackageManager {
+
+// src/generators/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
+var PackageManager = class _PackageManager {
+  static #cache = {};
+  #cwd;
+  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
   constructor(workspace) {
-    __privateAdd(this, _cwd, void 0);
-    __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(path3) {
-    let location = path3;
-    if (__privateGet(this, _cwd)) {
-      const require2 = mod.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
-      location = require2.resolve(path3);
+  getLocation(path) {
+    let location = path;
+    if (this.#cwd) {
+      const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
+      location = require2.resolve(path);
     }
     return location;
   }
-  async import(path3) {
+  async import(path) {
     try {
-      let location = this.getLocation(path3);
+      let location = this.getLocation(path);
       if (os.platform() == "win32") {
         location = pathToFileURL(location).href;
       }
@@ -1841,7 +1703,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;
@@ -1850,7 +1712,7 @@ var _PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: __privateGet(this, _cwd)
+      cwd: this.#cwd
     });
     if (!pkgPath) {
       return void 0;
@@ -1858,11 +1720,11 @@ var _PackageManager = class _PackageManager {
     return __require(pkgPath);
   }
   static setVersion(dependency, version) {
-    __privateGet(_PackageManager, _cache2)[dependency] = version;
+    _PackageManager.#cache[dependency] = version;
   }
   async getVersion(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
-      return __privateGet(_PackageManager, _cache2)[dependency];
+    if (_PackageManager.#cache[dependency]) {
+      return _PackageManager.#cache[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
@@ -1871,8 +1733,8 @@ var _PackageManager = class _PackageManager {
     return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
   }
   getVersionSync(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
-      return __privateGet(_PackageManager, _cache2)[dependency];
+    if (_PackageManager.#cache[dependency]) {
+      return _PackageManager.#cache[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
@@ -1903,19 +1765,10 @@ var _PackageManager = class _PackageManager {
     return satisfies(semVer, version);
   }
 };
-_cache2 = new WeakMap();
-_cwd = new WeakMap();
-_SLASHES = new WeakMap();
-__privateAdd(_PackageManager, _cache2, {});
-var PackageManager = _PackageManager;
-
-// src/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
 
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, PackageManager, ParallelPluginError, PluginError, PluginManager, PromiseManager, SchemaGenerator, SummaryError, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName };
+export { FileManager, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getPathMode, getRelativePath, getUniqueName, hooks, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map