npm - @kubb/core - Versions diffs - 1.15.0-canary.20231027T200912 → 2.0.0-canary.20231027T203719 - Mend

@kubb/core 1.15.0-canary.20231027T200912 → 2.0.0-canary.20231027T203719

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/index.cjs CHANGED Viewed

@@ -3,18 +3,19 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 var pc3 = require('picocolors');
-var crypto = require('crypto');
 var fs2 = require('fs-extra');
-var changeCase = require('change-case');
-var naturalOrderby = require('natural-orderby');
-var perf_hooks = require('perf_hooks');
 var seedrandom = require('seedrandom');
-var path2 = require('path');
+var path4 = require('path');
 var jsRuntime = require('js-runtime');
-var dirTree = require('directory-tree');
+var changeCase = require('change-case');
+var crypto2 = require('crypto');
 var parser = require('@kubb/parser');
+var factory = require('@kubb/parser/factory');
 var isEqual = require('lodash.isequal');
+var naturalOrderby = require('natural-orderby');
+var dirTree = require('directory-tree');
 var events = require('events');
+var perf_hooks = require('perf_hooks');
 var mod = require('module');
 var os = require('os');
 var url = require('url');
@@ -24,18 +25,39 @@ var semver = require('semver');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
 var pc3__default = /*#__PURE__*/_interopDefault(pc3);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
 var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 var mod__default = /*#__PURE__*/_interopDefault(mod);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var process__default = /*#__PURE__*/_interopDefault(process);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -43,110 +65,49 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-// 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(path3) {
-  return fs2.remove(path3);
-}
-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 = naturalOrderby.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 : changeCase.camelCase(name, { delimiter: "", transform: changeCase.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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
 };
-// 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;
-}
-// 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 "";
+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);
   }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+async function clean(path5) {
+  return fs2.remove(path5);
 }
-function createLogger(spinner) {
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
+};
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -172,6 +133,8 @@ function createLogger(spinner) {
     }
   };
   const logger = {
+    name,
+    logLevel,
     log,
     error,
     warn,
@@ -181,75 +144,6 @@ function createLogger(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__default.default.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__default.default.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) {
-        perf_hooks.performance.mark(name + "_start");
-      }
-      job().then((result) => {
-        resolve(result);
-        if (this.#debug) {
-          perf_hooks.performance.mark(name + "_stop");
-          perf_hooks.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) {
@@ -276,46 +170,22 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
-function slash(path3, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path3);
-  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-  }
-  return path3.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 = path2__default.default.relative(rootDir, filePath);
-  const path3 = slash(relativePath, platform);
-  if (path3.startsWith("../")) {
-    return path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)));
-  }
-  return `./${path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)))}`;
-}
-function getPathMode(path3) {
-  if (!path3) {
-    return "directory";
-  }
-  return path2__default.default.extname(path3) ? "file" : "directory";
-}
 var reader = jsRuntime.switcher(
   {
-    node: async (path3) => {
-      return fs2__default.default.readFile(path3, { encoding: "utf8" });
+    node: async (path5) => {
+      return fs2__default.default.readFile(path5, { encoding: "utf8" });
     },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
+    bun: async (path5) => {
+      const file = Bun.file(path5);
       return file.text();
     }
   },
   "node"
 );
-var syncReader = jsRuntime.switcher(
+jsRuntime.switcher(
   {
-    node: (path3) => {
-      return fs2__default.default.readFileSync(path3, { encoding: "utf8" });
+    node: (path5) => {
+      return fs2__default.default.readFileSync(path5, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -323,79 +193,115 @@ var syncReader = jsRuntime.switcher(
   },
   "node"
 );
-async function read(path3) {
-  return reader(path3);
-}
-function readSync(path3) {
-  return syncReader(path3);
-}
-// 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;
-    }
-    const value = data[index];
-    if (value === void 0) {
-      return prev;
-    }
-    return prev.replace(curr, () => {
-      if (typeof value === "boolean") {
-        return `${value.toString()}` || "false";
-      }
-      return value || "";
-    }).trim();
-  }, template) || "";
+async function read(path5) {
+  return reader(path5);
 }
-// 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 || [];
+var URLPath = class {
+  constructor(path5) {
+    this.path = path5;
+    return this;
   }
-};
-// src/utils/throttle.ts
-var throttle = (fn, delay) => {
-  let wait = false;
-  let timeout2;
-  let cancelled = false;
-  return [
-    (...args) => {
-      if (cancelled) {
-        return void 0;
+  /**
+   * 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;
       }
-      if (wait) {
-        return void 0;
+    } 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");
       }
-      const val = fn(...args);
-      wait = true;
-      timeout2 = setTimeout(() => {
-        wait = false;
-      }, delay);
-      return val;
-    },
-    () => {
-      cancelled = true;
-      clearTimeout(timeout2);
+      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(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.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;
+    }
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.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("}", "");
+  }
 };
+// src/config.ts
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     setTimeout(() => {
-      resolve(true);
+      resolve2(true);
     }, ms);
   });
 }
@@ -405,6 +311,17 @@ 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("`", "\\`") : "";
@@ -430,7 +347,40 @@ function jsStringEscape(input) {
   });
 }
-// src/utils/transformers/transformReservedWord.ts
+// 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",
   "arguments",
@@ -522,11 +472,83 @@ function transformReservedWord(word) {
   }
   return word;
 }
+// src/utils/transformers/index.ts
+var transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  JSDoc: {
+    createJSDocBlockText
+  }
+};
+async function saveCreateDirectory(path5) {
+  const passedPath = path4.dirname(path4.resolve(path5));
+  await fs2__default.default.mkdir(passedPath, { recursive: true });
+}
+var writer = jsRuntime.switcher(
+  {
+    node: async (path5, data) => {
+      try {
+        await fs2__default.default.stat(path4.resolve(path5));
+        const oldContent = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+        if (oldContent?.toString() === data?.toString()) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path5);
+      await fs2__default.default.writeFile(path4.resolve(path5), data, { encoding: "utf-8" });
+      const savedData = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+      if (savedData?.toString() !== data?.toString()) {
+        throw new Error(`Sanity check failed for ${path5}
+Data[${data.length}]:
+${data}
+Saved[${savedData.length}]:
+${savedData}
+`);
+      }
+      return savedData;
+    },
+    bun: async (path5, data) => {
+      try {
+        await saveCreateDirectory(path5);
+        await Bun.write(path4.resolve(path5), data);
+        const file = Bun.file(path4.resolve(path5));
+        const savedData = await file.text();
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path5}
+Data[${data.length}]:
+${data}
+Saved[${savedData.length}]:
+${savedData}
+`);
+        }
+        return savedData;
+      } catch (e) {
+        console.log(e, path4.resolve(path5));
+      }
+    }
+  },
+  "node"
+);
+async function write(data, path5) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  return writer(path5, data.trim());
+}
 var TreeNode = class _TreeNode {
-  data;
-  parent;
-  children = [];
   constructor(data, parent) {
+    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -586,16 +608,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path3, options = {}) {
+  static build(path5, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree__default.default(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree__default.default(path5, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
       const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) });
         if (item.children?.length) {
           item.children?.forEach((child) => {
             recurse(subNode, child);
@@ -610,227 +632,287 @@ var TreeNode = class _TreeNode {
   }
 };
-// src/utils/uniqueIdFactory.ts
-var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
-var URLPath = class {
-  path;
-  constructor(path3) {
-    this.path = path3;
+// src/BarrelManager.ts
+var _options;
+var BarrelManager = class {
+  constructor(options = {}) {
+    __privateAdd(this, _options, {});
+    __privateSet(this, _options, options);
     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;
+  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: []
       }
-    } catch (error) {
-      return false;
+    };
+    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
+    if (!tree) {
+      return null;
     }
-    return false;
+    const fileReducer = (files2, currentTree) => {
+      if (!currentTree.children) {
+        return [];
+      }
+      if (currentTree.children?.length > 1) {
+        const indexPath = path4__default.default.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 = path4__default.default.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;
   }
-  /**
-   * 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();
+};
+_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;
   }
-  get object() {
-    return this.toObject();
+  get files() {
+    const files = [];
+    __privateGet(this, _cache).forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
   }
-  get params() {
-    return this.getParams();
+  get isExecuting() {
+    return __privateGet(this, _queue)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
   }
-  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");
+  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);
       }
-      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(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
+      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
+    });
+    const resolvedFiles = await Promise.all(promises);
+    if (files.length > 1) {
+      return resolvedFiles;
     }
-    return `\`${newPath}\``;
+    return resolvedFiles[0];
   }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
+  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
+    const barrelManager = new BarrelManager(options);
+    const files = barrelManager.getIndexes(root, extName);
+    if (!files) {
       return void 0;
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
+    return await Promise.all(
+      files.map((file) => {
+        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+          ...file,
+          meta: meta ? meta : file.meta
+        });
+      })
+    );
   }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+  getCacheByUUID(UUID) {
+    let cache;
+    __privateGet(this, _cache).forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
   }
-};
-// src/utils/Warning.ts
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
+  get(path5) {
+    return __privateGet(this, _cache).get(path5);
   }
-};
-async function saveCreateDirectory(path3) {
-  const passedPath = path2__default.default.dirname(path2__default.default.resolve(path3));
-  await fs2__default.default.mkdir(passedPath, { recursive: true });
-}
-var writer = jsRuntime.switcher(
-  {
-    node: async (path3, data) => {
-      try {
-        await fs2__default.default.stat(path3);
-        const oldContent = await fs2__default.default.readFile(path3, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path3);
-      return fs2__default.default.writeFile(path2__default.default.resolve(path3), data, { encoding: "utf-8" });
-    },
-    bun: async (path3, data) => {
-      try {
-        await saveCreateDirectory(path3);
-        await Bun.write(path2__default.default.resolve(path3), data);
-      } catch (e) {
-        console.log(e, path2__default.default.resolve(path3));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path3) {
-  return writer(path3, data);
-}
-function getIndexes(root, extName, options = {}) {
-  const extMapper = {
-    ".ts": {
-      extensions: /\.ts/,
-      exclude: [/schemas/, /json/]
-    },
-    ".json": {
-      extensions: /\.json/,
-      exclude: []
+  remove(path5) {
+    const cacheItem = this.get(path5);
+    if (!cacheItem) {
+      return;
     }
-  };
-  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
-  if (!tree) {
-    return null;
+    __privateGet(this, _cache).delete(path5);
   }
-  const fileReducer = (files2, currentTree) => {
-    if (!currentTree.children) {
-      return [];
+  async write(...params) {
+    if (!__privateGet(this, _isWriting)) {
+      __privateSet(this, _isWriting, true);
+      const text = await write(...params);
+      __privateSet(this, _isWriting, false);
+      return text;
     }
-    if (currentTree.children?.length > 1) {
-      const path3 = path2__default.default.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") && path3.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path: path3,
-        baseName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      currentTree.children?.forEach((child) => {
-        const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path: path3,
-          baseName: "index.ts",
-          source: "",
-          exports: [{ path: importPath }]
-        });
-      });
+    await timeout(__privateGet(this, _timeout));
+    return this.write(...params);
+  }
+  async read(...params) {
+    return read(...params);
+  }
+  // statics
+  static getSource(file) {
+    if (!_FileManager.isExtensionAllowed(file.baseName)) {
+      return file.source;
     }
-    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 exports = file.exports ? combineExports(file.exports) : [];
+    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
+    const importNodes = imports.map((item) => factory__namespace.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+    const exportNodes = exports.map(
+      (item) => factory__namespace.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+    );
+    return [parser.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];
+      }
       const prev = acc[prevIndex];
+      if (prev && file.override) {
+        acc[prevIndex] = {
+          imports: [],
+          exports: [],
+          ...file
+        };
+        return acc;
+      }
       if (prev) {
         acc[prevIndex] = {
-          ...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 || {} }
+          ...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 || {} }
         };
       }
-    } else {
-      acc.push(curr);
+      return acc;
+    }, []);
+  }
+  static getMode(path5) {
+    if (!path5) {
+      return "directory";
     }
-    return acc;
-  }, []);
-}
-var extensions = [".js", ".ts", ".tsx"];
-function isExtensionAllowed(baseName) {
-  return extensions.some((extension) => baseName.endsWith(extension));
-}
+    return path4.extname(path5) ? "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__default.default.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;
 function combineExports(exports) {
-  return exports.reduce((prev, curr) => {
+  const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).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__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathAndIsTypeOnly) {
+      return prev;
+    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -852,12 +934,16 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
+  return naturalOrderby.orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  return imports.reduce((prev, curr) => {
+  const combinedImports = naturalOrderby.orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
     const hasImportInSource = (importName) => {
-      const checker = (name2) => name2 && !!source.includes(`${name2}`);
+      if (!source) {
+        return true;
+      }
+      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)) {
@@ -865,6 +951,10 @@ 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__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathNameAndIsTypeOnly) {
+      return prev;
+    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -886,43 +976,7 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
-}
-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) => parser.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-  const importSource = parser.print(importNodes);
-  const exportNodes = exports.map((item) => parser.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
-  const exportSource = parser.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);
+  return naturalOrderby.orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -939,132 +993,128 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      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).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
-// 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;
+var _emitter;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _emitter, new events.EventEmitter());
+    __privateGet(this, _emitter).setMaxListeners(100);
   }
-  get extensions() {
-    return extensions;
+  emit(eventName, ...eventArg) {
+    __privateGet(this, _emitter).emit(eventName, ...eventArg);
   }
-  get files() {
-    const files = [];
-    this.#cache.forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
+  on(eventName, handler) {
+    __privateGet(this, _emitter).on(eventName, handler);
   }
-  get isExecuting() {
-    return this.#queue?.hasJobs ?? false;
+  off(eventName, handler) {
+    __privateGet(this, _emitter).off(eventName, handler);
   }
-  async add(file) {
-    const controller = new AbortController();
-    const resolvedFile = { id: crypto__default.default.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;
+  removeAll() {
+    __privateGet(this, _emitter).removeAllListeners();
   }
-  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 || {} }
+};
+_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__default.default.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");
       });
-    }
-    return this.add(file);
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
+    });
   }
-  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);
-      })
-    );
+  runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.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));
+      });
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
+    });
   }
-  #append(path3, file) {
-    const previousFiles = this.#cache.get(path3) || [];
-    this.#cache.set(path3, [...previousFiles, file]);
+  get hasJobs() {
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
   }
-  getCacheByUUID(UUID) {
-    let cache;
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
-    });
-    return cache;
+  get count() {
+    return __privateGet(this, _workerCount);
   }
-  get(path3) {
-    return this.#cache.get(path3);
+};
+_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;
   }
-  remove(path3) {
-    const cacheItem = this.get(path3);
-    if (!cacheItem) {
-      return;
-    }
-    this.#cache.delete(path3);
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue2).shift()) {
+    const { reject, resolve: resolve2, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      perf_hooks.performance.mark(name + "_start");
+    }
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve2(result);
+      if (__privateGet(this, _debug)) {
+        perf_hooks.performance.mark(name + "_stop");
+        perf_hooks.performance.measure(description, name + "_start", name + "_stop");
+      }
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
-  async write(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return write(...params);
-      });
-    }
-    return write(...params);
+  __privateWrapper(this, _workerCount)._--;
+};
+// src/utils/uniqueName.ts
+function setUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    return originalName;
   }
-  async read(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return read(...params);
-      });
-    }
-    return read(...params);
+  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;
   }
 };
-// 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;
@@ -1084,30 +1134,54 @@ var ParallelPluginError = class extends Error {
     })?.cause;
   }
 };
-// src/managers/pluginManager/PluginError.ts
-var PluginError = class extends Error {
-  pluginManager;
-  cause;
+var SummaryError = class extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
+    this.name = "SummaryError";
+    this.summary = options.summary || [];
   }
 };
-function createPlugin(factory) {
-  return (options) => {
-    const plugin = factory(options);
-    if (Array.isArray(plugin)) {
-      throw new Error("Not implemented");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
+  }
+};
+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];
     }
-    return plugin;
+  };
+}
+// src/plugin.ts
+function createPlugin(factory2) {
+  return (options) => {
+    return factory2(options);
   };
 }
 var pluginName = "core";
@@ -1116,6 +1190,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1124,18 +1200,18 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
+        get plugin() {
+          return options.plugin;
+        },
         logger,
         fileManager,
         pluginManager,
         async addFile(...files) {
-          return Promise.all(
-            files.map((file) => {
-              if (file.override) {
-                return fileManager.add(file);
-              }
-              return fileManager.addOrAppend(file);
-            })
-          );
+          const resolvedFiles = await fileManager.add(...files);
+          if (!Array.isArray(resolvedFiles)) {
+            return [resolvedFiles];
+          }
+          return resolvedFiles;
         },
         resolvePath,
         resolveName,
@@ -1143,75 +1219,133 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path2__default.default.resolve(this.config.root, this.config.output.path);
-      return path2__default.default.resolve(root, baseName);
+      const root = path4__default.default.resolve(this.config.root, this.config.output.path);
+      return path4__default.default.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #emitter = new events.EventEmitter();
-  emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
-  }
-  on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
-  }
-  off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
+// 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;
   }
-  removeAll() {
-    this.#emitter.removeAllListeners();
+  run(strategy, promises) {
+    if (strategy === "seq") {
+      return hookSeq(promises);
+    }
+    throw new Error(`${strategy} not implemented`);
   }
 };
-// 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
-  };
+_options2 = new WeakMap();
+function isPromise(result) {
+  return !!result && typeof result?.then === "function";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
 }
-// 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);
+// 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;
 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, options.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
+    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 || [];
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1219,44 +1353,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this),
-      plugin: void 0
+      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);
     });
-    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);
   }
@@ -1264,30 +1368,35 @@ var PluginManager = class {
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginName: pluginName2,
+    pluginKey,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName2);
-    return this.#execute({
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
+    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);
   }
   hookForPluginSync({
-    pluginName: pluginName2,
+    pluginKey,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName2);
-    return this.#executeSync({
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
+    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);
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1298,7 +1407,7 @@ var PluginManager = class {
     skipped
   }) {
     let promise = Promise.resolve(null);
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
@@ -1306,7 +1415,7 @@ var PluginManager = class {
         if (parseResult?.result != null) {
           return parseResult;
         }
-        const value = await this.#execute({
+        const value = await __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1331,12 +1440,12 @@ var PluginManager = class {
     skipped
   }) {
     let parseResult = null;
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
       parseResult = {
-        result: this.#executeSync({
+        result: __privateMethod(this, _executeSync, executeSync_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1358,8 +1467,8 @@ var PluginManager = class {
     parameters
   }) {
     const parallelPromises = [];
-    for (const plugin of this.#getSortedPlugins()) {
-      const promise = this.#execute({ strategy: "hookParallel", hookName, parameters, plugin });
+    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 });
       if (promise) {
         parallelPromises.push(promise);
       }
@@ -1386,16 +1495,16 @@ var PluginManager = class {
   }) {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       promise = promise.then((arg0) => {
-        const value = this.#execute({
+        const value = __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
           plugin
         });
         return value;
-      }).then((result) => reduce.call(this.#core.api, argument0, result, plugin));
+      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
     }
     return promise;
   }
@@ -1403,160 +1512,192 @@ var PluginManager = class {
    * Chains plugins
    */
   hookSeq({ hookName, parameters }) {
-    let promise = Promise.resolve();
-    for (const plugin of this.#getSortedPlugins()) {
-      promise = promise.then(() => {
-        this.#execute({
-          strategy: "hookSeq",
-          hookName,
-          parameters,
-          plugin
-        });
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => __privateMethod(this, _execute, execute_fn).call(this, {
+        strategy: "hookSeq",
+        hookName,
+        parameters,
+        plugin
       });
-    }
-    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;
+    });
+    return __privateGet(this, _promiseManager).run("seq", promises);
   }
-  getPlugin(hookName, pluginName2) {
+  getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
-    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
-    if (!pluginByPluginName) {
-      return this.#core;
+    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] : [];
     }
     return pluginByPluginName;
   }
-  #addExecutedToCallStack(executer) {
-    if (executer) {
-      this.eventEmitter.emit("execute", executer);
-      this.executed.push(executer);
-    }
-  }
-  /**
-   * Run an async plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual pluginObject to run.
-   */
-  // Implementation signature
-  #execute({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
+  static getDependedPlugins(plugins, dependedPluginNames) {
+    let pluginNames = [];
+    if (typeof dependedPluginNames === "string") {
+      pluginNames = [dependedPluginNames];
+    } else {
+      pluginNames = dependedPluginNames;
     }
-    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 pluginNames.map((pluginName2) => {
+      const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
+      if (!plugin) {
+        throw new ValidationPluginError(`This plugin depends on the ${pluginName2} 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 plugin;
     });
-    return task;
   }
-  /**
-   * Run a sync plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The acutal plugin
-   * @param replaceContext When passed, the plugin context can be overridden.
-   */
-  #executeSync({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
-    }
-    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
-    try {
-      if (typeof hook === "function") {
-        const fn = hook.apply(this.#core.api, parameters);
-        output = fn;
-        return fn;
+  // 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`);
       }
-      output = hook;
-      return hook;
-    } catch (e) {
-      this.#catcher(e, plugin, hookName);
-      return null;
-    } finally {
-      this.#addExecutedToCallStack({
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin
-      });
     }
+    return plugins.filter((item) => item[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;
-  }
+  return plugins;
 };
-function noReturn() {
-}
-// src/managers/pluginManager/validate.ts
-var ValidationPluginError = class extends Error {
+_addExecutedToCallStack = new WeakSet();
+addExecutedToCallStack_fn = function(executer) {
+  if (executer) {
+    this.eventEmitter.emit("executed", executer);
+    this.executed.push(executer);
+  }
 };
-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;
+_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);
+      }
+      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
+    });
   });
-}
-// src/types.ts
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
+  return task;
+};
+_executeSync = new WeakSet();
+executeSync_fn = function({
+  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({ ...__privateGet(this, _core).api, plugin }, parameters);
+      output = fn;
+      return fn;
+    }
+    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})
+`;
+  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
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
 };
 // src/build.ts
@@ -1564,13 +1705,13 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logLevel, logger = createLogger() } = options;
+  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
   try {
-    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
+    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
-    if ("path" in config.input) {
+    if (isInputPath(config)) {
       throw new Error(
         "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
         {
@@ -1583,11 +1724,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path: path3 } = file;
-    let code = createFileSource(file);
+    const { path: path5 } = file;
+    let code = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path3]
+      parameters: [path5]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1598,28 +1739,53 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path3],
+        parameters: [code, path5],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
-        await pluginManager.hookParallel({
+        if (file.meta?.pluginKey) {
+          return pluginManager.hookForPlugin({
+            pluginKey: file.meta?.pluginKey,
+            hookName: "writeFile",
+            parameters: [transformedCode, path5]
+          });
+        }
+        return pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [transformedCode, path5]
         });
       }
     }
   };
-  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
+  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
   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__default.default.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 (logLevel === LogLevel.info) {
-      if (logger.spinner) {
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
+      if (hookName === "writeFile") {
+        const [_code, path5] = parameters;
+        logger.spinner.suffixText = pc3__default.default.dim(path5);
+      } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logLevel === LogLevel.debug) {
+    if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1639,93 +1805,95 @@ async function build(options) {
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  return { files: fileManager.files.map((file) => ({ ...file, source: createFileSource(file) })), pluginManager };
-}
-// src/config.ts
-function defineConfig(options) {
-  return options;
+  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 };
 }
-// src/generators/Generator.ts
+// src/Generator.ts
+var _options3, _context;
 var Generator = class {
-  #options = {};
-  #context = {};
   constructor(options, context) {
+    __privateAdd(this, _options3, {});
+    __privateAdd(this, _context, {});
     if (context) {
-      this.#context = context;
+      __privateSet(this, _context, context);
     }
     if (options) {
-      this.#options = options;
+      __privateSet(this, _options3, options);
     }
     return this;
   }
   get options() {
-    return this.#options;
+    return __privateGet(this, _options3);
   }
   get context() {
-    return this.#context;
+    return __privateGet(this, _context);
   }
   set options(options) {
-    this.#options = { ...this.#options, ...options };
+    __privateSet(this, _options3, { ...__privateGet(this, _options3), ...options });
   }
 };
-// src/generators/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
+_options3 = new WeakMap();
+_context = new WeakMap();
 // ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
 var Node = class {
-  value;
-  next;
   constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
     this.value = value;
   }
 };
+var _head, _tail, _size;
 var Queue2 = class {
-  #head;
-  #tail;
-  #size;
   constructor() {
+    __privateAdd(this, _head, void 0);
+    __privateAdd(this, _tail, void 0);
+    __privateAdd(this, _size, void 0);
     this.clear();
   }
   enqueue(value) {
     const node = new Node(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
     } else {
-      this.#head = node;
-      this.#tail = node;
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
     }
-    this.#size++;
+    __privateWrapper(this, _size)._++;
   }
   dequeue() {
-    const current = this.#head;
+    const current = __privateGet(this, _head);
     if (!current) {
       return;
     }
-    this.#head = this.#head.next;
-    this.#size--;
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
     return current.value;
   }
   clear() {
-    this.#head = void 0;
-    this.#tail = void 0;
-    this.#size = 0;
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
   }
   get size() {
-    return this.#size;
+    return __privateGet(this, _size);
   }
   *[Symbol.iterator]() {
-    let current = this.#head;
+    let current = __privateGet(this, _head);
     while (current) {
       yield current.value;
       current = current.next;
     }
   }
 };
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 function pLimit(concurrency) {
@@ -1740,18 +1908,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve, args) => {
+  const run = async (fn, resolve2, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve(result);
+    resolve2(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve, args));
+  const enqueue = (fn, resolve2, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve2, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1759,8 +1927,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve) => {
-    enqueue(fn, resolve, args);
+  const generator = (fn, ...args) => new Promise((resolve2) => {
+    enqueue(fn, resolve2, args);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -1835,7 +2003,7 @@ async function locatePath(paths, {
   const statFunction = allowSymlinks ? fs3.promises.stat : fs3.promises.lstat;
   return pLocate(paths, async (path_) => {
     try {
-      const stat = await statFunction(path2__default.default.resolve(cwd, path_));
+      const stat = await statFunction(path4__default.default.resolve(cwd, path_));
       return matchType(type, stat);
     } catch {
       return false;
@@ -1852,7 +2020,7 @@ function locatePathSync(paths, {
   const statFunction = allowSymlinks ? fs3__default.default.statSync : fs3__default.default.lstatSync;
   for (const path_ of paths) {
     try {
-      const stat = statFunction(path2__default.default.resolve(cwd, path_), {
+      const stat = statFunction(path4__default.default.resolve(cwd, path_), {
         throwIfNoEntry: false
       });
       if (!stat) {
@@ -1870,9 +2038,9 @@ function locatePathSync(paths, {
 var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
 async function findUpMultiple(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
-  const stopAt = path2__default.default.resolve(directory, options.stopAt || root);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
+  const stopAt = path4__default.default.resolve(directory, options.stopAt || root);
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
   const runMatcher = async (locateOptions) => {
@@ -1892,18 +2060,18 @@ async function findUpMultiple(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
 function findUpMultipleSync(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
   const stopAt = options.stopAt || root;
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
@@ -1924,12 +2092,12 @@ function findUpMultipleSync(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
@@ -1941,39 +2109,39 @@ function findUpSync(name, options = {}) {
   const matches = findUpMultipleSync(name, { ...options, limit: 1 });
   return matches[0];
 }
-var PackageManager = class _PackageManager {
-  static #cache = {};
-  #cwd;
-  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+var _cache2, _cwd, _SLASHES;
+var _PackageManager = class _PackageManager {
   constructor(workspace) {
+    __privateAdd(this, _cwd, void 0);
+    __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
-      this.#cwd = workspace;
+      __privateSet(this, _cwd, workspace);
     }
     return this;
   }
   set workspace(workspace) {
-    this.#cwd = workspace;
+    __privateSet(this, _cwd, workspace);
   }
   get workspace() {
-    return this.#cwd;
+    return __privateGet(this, _cwd);
   }
   normalizeDirectory(directory) {
-    if (!this.#SLASHES.has(directory[directory.length - 1])) {
+    if (!__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
       return `${directory}/`;
     }
     return directory;
   }
-  getLocation(path3) {
-    let location = path3;
-    if (this.#cwd) {
-      const require2 = mod__default.default.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path3);
+  getLocation(path5) {
+    let location = path5;
+    if (__privateGet(this, _cwd)) {
+      const require2 = mod__default.default.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
+      location = require2.resolve(path5);
     }
     return location;
   }
-  async import(path3) {
+  async import(path5) {
     try {
-      let location = this.getLocation(path3);
+      let location = this.getLocation(path5);
       if (os__default.default.platform() == "win32") {
         location = url.pathToFileURL(location).href;
       }
@@ -1986,7 +2154,7 @@ var PackageManager = class _PackageManager {
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -1995,7 +2163,7 @@ var PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -2003,11 +2171,11 @@ var PackageManager = class _PackageManager {
     return __require(pkgPath);
   }
   static setVersion(dependency, version) {
-    _PackageManager.#cache[dependency] = version;
+    __privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[dependency];
+    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+      return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
@@ -2016,8 +2184,8 @@ var PackageManager = class _PackageManager {
     return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
   }
   getVersionSync(dependency) {
-    if (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[dependency];
+    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+      return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
@@ -2048,68 +2216,38 @@ var PackageManager = class _PackageManager {
     return semver.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;
-Object.defineProperty(exports, 'pc', {
-  enumerable: true,
-  get: function () { return pc3__default.default; }
-});
 exports.FileManager = FileManager;
-exports.FunctionParams = FunctionParams;
 exports.Generator = Generator;
-exports.LogLevel = LogLevel;
 exports.PackageManager = PackageManager;
 exports.ParallelPluginError = ParallelPluginError;
 exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
-exports.Queue = Queue;
+exports.PromiseManager = PromiseManager;
 exports.SchemaGenerator = SchemaGenerator;
 exports.SummaryError = SummaryError;
-exports.TreeNode = TreeNode;
-exports.URLPath = URLPath;
 exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;
-exports.clean = clean;
-exports.combineCodes = combineCodes;
 exports.combineExports = combineExports;
-exports.combineFiles = combineFiles;
 exports.combineImports = combineImports;
-exports.createFileSource = createFileSource;
-exports.createJSDocBlockText = createJSDocBlockText;
-exports.createLogger = createLogger;
 exports.createPlugin = createPlugin;
-exports.createPluginCache = createPluginCache;
 exports.default = src_default;
-exports.defaultColours = defaultColours;
 exports.defineConfig = defineConfig;
-exports.escape = escape;
-exports.extensions = extensions;
-exports.getDependedPlugins = getDependedPlugins;
-exports.getIndexes = getIndexes;
-exports.getPathMode = getPathMode;
-exports.getRelativePath = getRelativePath;
-exports.getUniqueName = getUniqueName;
-exports.hooks = hooks;
-exports.isExtensionAllowed = isExtensionAllowed;
-exports.isPromise = isPromise;
-exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
-exports.isPromiseRejectedResult = isPromiseRejectedResult;
-exports.jsStringEscape = jsStringEscape;
+exports.isInputPath = isInputPath;
 exports.name = pluginName;
-exports.nameSorter = nameSorter;
 exports.pluginName = pluginName;
-exports.randomColour = randomColour;
-exports.randomPicoColour = randomPicoColour;
-exports.read = read;
-exports.readSync = readSync;
-exports.renderTemplate = renderTemplate;
-exports.throttle = throttle;
-exports.timeout = timeout;
-exports.transformReservedWord = transformReservedWord;
-exports.uniqueIdFactory = uniqueIdFactory;
-exports.write = write;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map