@kubb/core 1.15.0-canary.20231026T131818 → 1.15.0-canary.20231026T165002

package/dist/index.js

@@ -1,18 +1,18 @@
 import mod, { createRequire } from 'module';
 import pc3 from 'picocolors';
+export { default as pc } from 'picocolors';
+import crypto from 'crypto';
 import fs2, { remove } from 'fs-extra';
-import seedrandom from 'seedrandom';
-import { switcher } from 'js-runtime';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
-import crypto2 from 'crypto';
-import path, { resolve, dirname, extname } from 'path';
-import { print } from '@kubb/parser';
-import * as factory from '@kubb/parser/factory';
-import isEqual from 'lodash.isequal';
 import { orderBy } from 'natural-orderby';
+import { performance } from 'perf_hooks';
+import seedrandom from 'seedrandom';
+import pathParser from 'path';
+import { switcher } from 'js-runtime';
 import dirTree from 'directory-tree';
+import { createImportDeclaration, print, createExportDeclaration } from '@kubb/parser';
+import isEqual from 'lodash.isequal';
 import { EventEmitter as EventEmitter$1 } from 'events';
-import { performance } from 'perf_hooks';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
@@ -27,15 +27,110 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-async function clean(path3) {
-  return remove(path3);
+
+// 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];
+    }
+  };
 }
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
+async function clean(path) {
+  return remove(path);
+}
+var FunctionParams = class {
+  type;
+  items = [];
+  constructor(type) {
+    this.type = type;
+    return this;
+  }
+  add(item) {
+    if (!item) {
+      return this;
+    }
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => this.items.push(it));
+      return this;
+    }
+    this.items.push(item);
+    return this;
+  }
+  toString() {
+    const sortedData = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
+    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
+      if (!name) {
+        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        return acc;
+      }
+      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
+      if (type) {
+        if (required) {
+          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        } else {
+          acc.push(`${parameterName}?: ${type}`);
+        }
+      } else {
+        acc.push(`${parameterName}`);
+      }
+      return acc;
+    }, []).join(", ");
+  }
 };
-function createLogger({ logLevel, name, spinner }) {
+
+// 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 "";
+  }
+  return `/**
+ * ${filteredComments.join("\n * ")}
+ */`;
+}
+function createLogger(spinner) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -61,8 +156,6 @@ function createLogger({ logLevel, name, spinner }) {
     }
   };
   const logger = {
-    name,
-    logLevel,
     log,
     error,
     warn,
@@ -72,6 +165,75 @@ function createLogger({ logLevel, name, spinner }) {
   };
   return logger;
 }
+
+// src/utils/nameSorter.ts
+function nameSorter(a, b) {
+  if (a.name < b.name) {
+    return -1;
+  }
+  if (a.name > b.name) {
+    return 1;
+  }
+  return 0;
+}
+var Queue = class {
+  #queue = [];
+  #workerCount = 0;
+  #maxParallel;
+  #debug = false;
+  constructor(maxParallel, debug = false) {
+    this.#maxParallel = maxParallel;
+    this.#debug = debug;
+  }
+  run(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
+    return new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        reject("Aborted");
+      });
+      this.#queue.push(item);
+      this.#work();
+    });
+  }
+  runSync(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
+    new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+      });
+      this.#queue.push(item);
+      this.#work();
+    });
+  }
+  get hasJobs() {
+    return this.#workerCount > 0 || this.#queue.length > 0;
+  }
+  get count() {
+    return this.#workerCount;
+  }
+  #work() {
+    if (this.#workerCount >= this.#maxParallel) {
+      return;
+    }
+    this.#workerCount++;
+    let entry;
+    while (entry = this.#queue.shift()) {
+      const { reject, resolve, job, name, description } = entry;
+      if (this.#debug) {
+        performance.mark(name + "_start");
+      }
+      job().then((result) => {
+        resolve(result);
+        if (this.#debug) {
+          performance.mark(name + "_stop");
+          performance.measure(description, name + "_start", name + "_stop");
+        }
+      }).catch((err) => reject(err));
+    }
+    this.#workerCount--;
+  }
+};
 var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
 function randomColour(text, colours = defaultColours) {
   if (!text) {
@@ -98,22 +260,46 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
+function slash(path, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  }
+  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+  }
+  const relativePath = pathParser.relative(rootDir, filePath);
+  const path = slash(relativePath, platform);
+  if (path.startsWith("../")) {
+    return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)));
+  }
+  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`;
+}
+function getPathMode(path) {
+  if (!path) {
+    return "directory";
+  }
+  return pathParser.extname(path) ? "file" : "directory";
+}
 var reader = switcher(
   {
-    node: async (path3) => {
-      return fs2.readFile(path3, { encoding: "utf8" });
+    node: async (path) => {
+      return fs2.readFile(path, { encoding: "utf8" });
     },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
+    bun: async (path) => {
+      const file = Bun.file(path);
       return file.text();
     }
   },
   "node"
 );
-switcher(
+var syncReader = switcher(
   {
-    node: (path3) => {
-      return fs2.readFileSync(path3, { encoding: "utf8" });
+    node: (path) => {
+      return fs2.readFileSync(path, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -121,116 +307,79 @@ switcher(
   },
   "node"
 );
-async function read(path3) {
-  return reader(path3);
+async function read(path) {
+  return reader(path);
 }
-var URLPath = class {
-  path;
-  constructor(path3) {
-    this.path = path3;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
-        return true;
-      }
-    } catch (error) {
-      return false;
-    }
-    return false;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
-  }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
-    };
-    if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
-      }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-    }
-    return object;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
+function readSync(path) {
+  return syncReader(path);
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  const matches = template.match(/{{(.*?)}}/g);
+  return matches?.reduce((prev, curr) => {
+    const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
+    if (index === void 0) {
+      return prev;
     }
-    return `\`${newPath}\``;
-  }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
+    const value = data[index];
+    if (value === void 0) {
+      return prev;
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+    return prev.replace(curr, () => {
+      if (typeof value === "boolean") {
+        return `${value.toString()}` || "false";
+      }
+      return value || "";
+    }).trim();
+  }, template) || "";
+}
+
+// src/utils/SummaryError.ts
+var SummaryError = class extends Error {
+  summary;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "SummaryError";
+    this.summary = options.summary || [];
   }
 };
 
-// src/config.ts
-function defineConfig(options) {
-  return options;
-}
-function isInputPath(result) {
-  return !!result && "path" in result;
-}
+// src/utils/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout2;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled) {
+        return void 0;
+      }
+      if (wait) {
+        return void 0;
+      }
+      const val = fn(...args);
+      wait = true;
+      timeout2 = setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout2);
+    }
+  ];
+};
 
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     setTimeout(() => {
-      resolve2(true);
+      resolve(true);
     }, ms);
   });
 }
@@ -240,17 +389,6 @@ function combineCodes(codes) {
   return codes.join("\n");
 }
 
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
-  }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
-}
-
 // src/utils/transformers/escape.ts
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
@@ -276,39 +414,6 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/indent.ts
-function createIndent(size) {
-  return Array.from({ length: size + 1 }).join(" ");
-}
-
-// src/utils/transformers/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-
-// src/utils/transformers/searchAndReplace.ts
-function searchAndReplace(options) {
-  const { text, replaceBy, prefix = "", key } = options;
-  const searchValues = options.searchValues?.(prefix, key) || [
-    `${prefix}["${key}"]`,
-    `${prefix}['${key}']`,
-    `${prefix}[\`${key}\`]`,
-    `${prefix}"${key}"`,
-    `${prefix}'${key}'`,
-    `${prefix}\`${key}\``,
-    new RegExp(`${prefix}${key}`, "g")
-  ];
-  return searchValues.reduce((prev, searchValue) => {
-    return prev.toString().replaceAll(searchValue, replaceBy);
-  }, text);
-}
-
 // src/utils/transformers/transformReservedWord.ts
 var reservedWords = [
   "abstract",
@@ -401,80 +506,6 @@ function transformReservedWord(word) {
   }
   return word;
 }
-
-// src/utils/transformers/index.ts
-var transformers = {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  nameSorter,
-  searchAndReplace,
-  JSDoc: {
-    createJSDocBlockText
-  }
-};
-async function saveCreateDirectory(path3) {
-  const passedPath = dirname(resolve(path3));
-  await fs2.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path3, data) => {
-      try {
-        await fs2.stat(resolve(path3));
-        const oldContent = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-        if (oldContent?.toString() === data?.toString()) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path3);
-      await fs2.writeFile(resolve(path3), data, { encoding: "utf-8" });
-      const savedData = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path3}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-      }
-      return savedData;
-    },
-    bun: async (path3, data) => {
-      try {
-        await saveCreateDirectory(path3);
-        await Bun.write(resolve(path3), data);
-        const file = Bun.file(resolve(path3));
-        const savedData = await file.text();
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path3}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-        }
-        return savedData;
-      } catch (e) {
-        console.log(e, resolve(path3));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path3) {
-  if (data.trim() === "") {
-    return void 0;
-  }
-  return writer(path3, data.trim());
-}
 var TreeNode = class _TreeNode {
   data;
   parent;
@@ -539,16 +570,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path3, options = {}) {
+  static build(path, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
       const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) });
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
         if (item.children?.length) {
           item.children?.forEach((child) => {
             recurse(subNode, child);
@@ -563,271 +594,227 @@ var TreeNode = class _TreeNode {
   }
 };
 
-// src/BarrelManager.ts
-var BarrelManager = class {
-  #options = {};
-  constructor(options = {}) {
-    this.#options = options;
+// src/utils/uniqueIdFactory.ts
+var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
+var URLPath = class {
+  path;
+  constructor(path) {
+    this.path = path;
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = this.#options;
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
-      }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
-    if (!tree) {
-      return null;
-    }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
-        return [];
-      }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && indexPath.includes("index")) {
-            return void 0;
-          }
-          return {
-            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
-            isTypeOnly
-          };
-        }).filter(Boolean);
-        files2.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
-        });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
-        });
+  /**
+   * 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;
       }
-      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;
+    } catch (error) {
+      return false;
+    }
+    return false;
   }
-};
-
-// src/FileManager.ts
-var FileManager = class _FileManager {
-  #cache = /* @__PURE__ */ new Map();
-  #task;
-  #isWriting = false;
   /**
-   * Timeout between writes
+   * 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}`
    */
-  #timeout = 0;
-  #queue;
-  constructor(options) {
-    if (options) {
-      this.#task = options.task;
-      this.#queue = options.queue;
-      this.#timeout = options.timeout || 0;
-    }
-    return this;
-  }
-  get files() {
-    const files = [];
-    this.#cache.forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
+  get template() {
+    return this.toTemplateString();
   }
-  get isExecuting() {
-    return this.#queue?.hasJobs ?? this.#isWriting ?? false;
+  get object() {
+    return this.toObject();
   }
-  #validate(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}`);
-    }
+  get params() {
+    return this.getParams();
   }
-  async add(...files) {
-    const promises = files.map((file) => {
-      this.#validate(file);
-      if (file.override) {
-        return this.#add(file);
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type !== "template") {
+        throw new Error("Type should be `template` when using stringiyf");
       }
-      return this.#addOrAppend(file);
-    });
-    const resolvedFiles = await Promise.all(promises);
-    if (files.length > 1) {
-      return resolvedFiles;
-    }
-    return resolvedFiles[0];
-  }
-  async #add(file) {
-    const controller = new AbortController();
-    const resolvedFile = { id: crypto2.randomUUID(), ...file };
-    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-    if (this.#queue) {
-      await this.#queue.run(
-        async () => {
-          return this.#task?.(resolvedFile);
-        },
-        { controller }
-      );
+      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
     }
-    return resolvedFile;
+    return object;
   }
-  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 || {} }
-      });
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
     }
-    return this.#add(file);
+    return `\`${newPath}\``;
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
-    if (!files) {
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
       return void 0;
     }
-    return await Promise.all(
-      files.map((file) => {
-        return this.#addOrAppend({
-          ...file,
-          meta: meta ? meta : file.meta
-        });
-      })
-    );
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
+      params[pathParam] = pathParam;
+    }, this.path);
+    return params;
   }
-  getCacheByUUID(UUID) {
-    let cache;
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
-    });
-    return cache;
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
   }
-  get(path3) {
-    return this.#cache.get(path3);
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  remove(path3) {
-    const cacheItem = this.get(path3);
-    if (!cacheItem) {
-      return;
+};
+async function saveCreateDirectory(path) {
+  const passedPath = pathParser.dirname(pathParser.resolve(path));
+  await fs2.mkdir(passedPath, { recursive: true });
+}
+var writer = switcher(
+  {
+    node: async (path, data) => {
+      try {
+        await fs2.stat(path);
+        const oldContent = await fs2.readFile(path, { encoding: "utf-8" });
+        if (oldContent?.toString() === data) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path);
+      return fs2.writeFile(pathParser.resolve(path), data, { encoding: "utf-8" });
+    },
+    bun: async (path, data) => {
+      try {
+        await saveCreateDirectory(path);
+        await Bun.write(pathParser.resolve(path), data);
+      } catch (e) {
+        console.log(e, pathParser.resolve(path));
+      }
     }
-    this.#cache.delete(path3);
-  }
-  async write(...params) {
-    if (!this.#isWriting) {
-      this.#isWriting = true;
-      const text = await write(...params);
-      this.#isWriting = false;
-      return text;
+  },
+  "node"
+);
+async function write(data, path) {
+  return writer(path, data);
+}
+function getIndexes(root, extName, options = {}) {
+  const extMapper = {
+    ".ts": {
+      extensions: /\.ts/,
+      exclude: [/schemas/, /json/]
+    },
+    ".json": {
+      extensions: /\.json/,
+      exclude: []
     }
-    await timeout(this.#timeout);
-    return this.write(...params);
-  }
-  async read(...params) {
-    return read(...params);
+  };
+  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
+  if (!tree) {
+    return null;
   }
-  // statics
-  static getSource(file) {
-    if (!_FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source;
+  const fileReducer = (files2, currentTree) => {
+    if (!currentTree.children) {
+      return [];
     }
-    const exports = file.exports ? combineExports(file.exports) : [];
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-    const exportNodes = exports.map(
-      (item) => factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    );
-    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
-  }
-  static combineFiles(files) {
-    return files.filter(Boolean).reduce((acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
+    if (currentTree.children?.length > 1) {
+      const path = pathParser.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        baseName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      currentTree.children?.forEach((child) => {
+        const path = pathParser.resolve(currentTree.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          baseName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    currentTree.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
       const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
-        return acc;
-      }
       if (prev) {
         acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
+          ...curr,
+          source: prev.source && curr.source ? `${prev.source}
+${curr.source}` : "",
+          imports: [...prev.imports || [], ...curr.imports || []],
+          exports: [...prev.exports || [], ...curr.exports || []],
+          env: { ...prev.env || {}, ...curr.env || {} }
         };
       }
-      return acc;
-    }, []);
-  }
-  static getMode(path3) {
-    if (!path3) {
-      return "directory";
+    } else {
+      acc.push(curr);
     }
-    return extname(path3) ? "file" : "directory";
-  }
-  static get extensions() {
-    return [".js", ".ts", ".tsx"];
-  }
-  static isExtensionAllowed(baseName) {
-    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
-  }
-};
+    return acc;
+  }, []);
+}
+var extensions = [".js", ".ts", ".tsx"];
+function isExtensionAllowed(baseName) {
+  return extensions.some((extension) => baseName.endsWith(extension));
+}
 function combineExports(exports) {
-  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
+  return exports.reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathAndIsTypeOnly) {
-      return prev;
-    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -849,16 +836,12 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
-  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
+  return imports.reduce((prev, curr) => {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
     const hasImportInSource = (importName) => {
-      if (!source) {
-        return true;
-      }
-      const checker = (name2) => name2 && !!source.includes(name2);
+      const checker = (name2) => name2 && !!source.includes(`${name2}`);
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
@@ -866,10 +849,6 @@ function combineImports(imports, exports, source) {
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
     const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathNameAndIsTypeOnly) {
-      return prev;
-    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -891,7 +870,43 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
-  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
+}
+function createFileSource(file) {
+  let { source } = file;
+  if (!isExtensionAllowed(file.baseName)) {
+    return file.source;
+  }
+  const exports = file.exports ? combineExports(file.exports) : [];
+  const imports = file.imports ? combineImports(file.imports, exports, source) : [];
+  const importNodes = imports.map((item) => createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+  const importSource = print(importNodes);
+  const exportNodes = exports.map((item) => createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
+  const exportSource = print(exportNodes);
+  source = getEnvSource(file.source, file.env);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
+function searchAndReplace(options) {
+  const { text, replaceBy, prefix = "", key } = options;
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, "g")
+  ];
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy);
+  }, text);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -908,117 +923,127 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #emitter = new EventEmitter$1();
-  emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
+
+// 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;
   }
-  on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
+  get extensions() {
+    return extensions;
   }
-  off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
+  get files() {
+    const files = [];
+    this.#cache.forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
   }
-  removeAll() {
-    this.#emitter.removeAllListeners();
+  get isExecuting() {
+    return this.#queue?.hasJobs ?? false;
   }
-};
-var Queue = class {
-  #queue = [];
-  eventEmitter = new EventEmitter();
-  #workerCount = 0;
-  #maxParallel;
-  #debug = false;
-  constructor(maxParallel, debug = false) {
-    this.#maxParallel = maxParallel;
-    this.#debug = debug;
+  async add(file) {
+    const controller = new AbortController();
+    const resolvedFile = { id: crypto.randomUUID(), ...file };
+    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+    if (this.#queue) {
+      try {
+        await this.#queue.run(
+          async () => {
+            return this.#task?.(resolvedFile);
+          },
+          { controller }
+        );
+      } catch {
+        return resolvedFile;
+      }
+    }
+    return resolvedFile;
   }
-  run(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
-        reject("Aborted");
+  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 || {} }
       });
-      this.#queue.push(item);
-      this.#work();
-    });
+    }
+    return this.add(file);
   }
-  runSync(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
-      });
-      this.#queue.push(item);
-      this.#work();
-    });
+  async addIndexes(root, extName = ".ts", options = {}) {
+    const files = await getIndexes(root, extName, options);
+    if (!files) {
+      return void 0;
+    }
+    return Promise.all(
+      files.map((file) => {
+        if (file.override) {
+          return this.add(file);
+        }
+        return this.addOrAppend(file);
+      })
+    );
   }
-  get hasJobs() {
-    return this.#workerCount > 0 || this.#queue.length > 0;
+  #append(path, file) {
+    const previousFiles = this.#cache.get(path) || [];
+    this.#cache.set(path, [...previousFiles, file]);
   }
-  get count() {
-    return this.#workerCount;
+  getCacheByUUID(UUID) {
+    let cache;
+    this.#cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
   }
-  #work() {
-    if (this.#workerCount >= this.#maxParallel) {
+  get(path) {
+    return this.#cache.get(path);
+  }
+  remove(path) {
+    const cacheItem = this.get(path);
+    if (!cacheItem) {
       return;
     }
-    this.#workerCount++;
-    let entry;
-    while (entry = this.#queue.shift()) {
-      const { reject, resolve: resolve2, job, name, description } = entry;
-      if (this.#debug) {
-        performance.mark(name + "_start");
-      }
-      job().then((result) => {
-        this.eventEmitter.emit("jobDone", result);
-        resolve2(result);
-        if (this.#debug) {
-          performance.mark(name + "_stop");
-          performance.measure(description, name + "_start", name + "_stop");
-        }
-      }).catch((err) => {
-        this.eventEmitter.emit("jobFailed", err);
-        reject(err);
+    this.#cache.delete(path);
+  }
+  async write(...params) {
+    if (this.#queue) {
+      return this.#queue.run(async () => {
+        return write(...params);
       });
     }
-    this.#workerCount--;
-  }
-};
-
-// src/utils/uniqueName.ts
-function setUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    return originalName;
+    return write(...params);
   }
-  data[originalName] = 1;
-  return originalName;
-}
-
-// src/errors.ts
-var PluginError = class extends Error {
-  pluginManager;
-  cause;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
+  async read(...params) {
+    if (this.#queue) {
+      return this.#queue.run(async () => {
+        return read(...params);
+      });
+    }
+    return read(...params);
   }
 };
+
+// src/managers/pluginManager/ParallelPluginError.ts
 var ParallelPluginError = class extends Error {
   errors = [];
   pluginManager;
@@ -1043,55 +1068,30 @@ var ParallelPluginError = class extends Error {
     })?.cause;
   }
 };
-var SummaryError = class extends Error {
-  summary;
+
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  cause;
   constructor(message, options) {
     super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
-};
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
+    this.name = "PluginError";
+    this.cause = options.cause;
+    this.pluginManager = options.pluginManager;
   }
 };
-var ValidationPluginError = class extends Error {
-};
-
-// src/utils/cache.ts
-function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
-  return {
-    set(id, value) {
-      Store[id] = [0, value];
-    },
-    get(id) {
-      const item = Store[id];
-      if (!item) {
-        return null;
-      }
-      item[0] = 0;
-      return item[1];
-    },
-    has(id) {
-      const item = Store[id];
-      if (!item) {
-        return false;
-      }
-      item[0] = 0;
-      return true;
-    },
-    delete(id) {
-      return delete Store[id];
-    }
-  };
-}
-
-// src/plugin.ts
-function createPlugin(factory2) {
+function createPlugin(factory) {
   return (options) => {
-    return factory2(options);
+    const plugin = factory(options);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
+    }
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
+    }
+    return plugin;
   };
 }
 var pluginName = "core";
@@ -1100,8 +1100,6 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
-    key: ["controller", "core"],
-    kind: "controller",
     api() {
       return {
         get config() {
@@ -1110,18 +1108,18 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
-        get plugin() {
-          return options.plugin;
-        },
         logger,
         fileManager,
         pluginManager,
         async addFile(...files) {
-          const resolvedFiles = await fileManager.add(...files);
-          if (!Array.isArray(resolvedFiles)) {
-            return [resolvedFiles];
-          }
-          return resolvedFiles;
+          return Promise.all(
+            files.map((file) => {
+              if (file.override) {
+                return fileManager.add(file);
+              }
+              return fileManager.addOrAppend(file);
+            })
+          );
         },
         resolvePath,
         resolveName,
@@ -1129,55 +1127,63 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      return path.resolve(root, baseName);
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      return pathParser.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-
-// src/utils/executeStrategies.ts
-function hookSeq(promises) {
-  return promises.reduce(
-    (promise, func) => {
-      if (!func || typeof func !== "function") {
-        throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-      }
-      return promise.then((result) => {
-        const calledFunc = func();
-        if (calledFunc) {
-          return calledFunc.then(Array.prototype.concat.bind(result));
-        }
-      });
-    },
-    Promise.resolve([])
-  );
-}
-
-// src/PromiseManager.ts
-var PromiseManager = class {
-  #options = {};
-  constructor(options = {}) {
-    this.#options = options;
-    return this;
+var EventEmitter = class {
+  constructor() {
+    this.#emitter.setMaxListeners(100);
   }
-  run(strategy, promises) {
-    if (strategy === "seq") {
-      return hookSeq(promises);
-    }
-    throw new Error(`${strategy} not implemented`);
+  #emitter = new EventEmitter$1();
+  emit(eventName, ...eventArg) {
+    this.#emitter.emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    this.#emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.#emitter.off(eventName, handler);
+  }
+  removeAll() {
+    this.#emitter.removeAllListeners();
   }
 };
-function isPromise(result) {
-  return !!result && typeof result?.then === "function";
-}
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
+
+// src/managers/pluginManager/pluginParser.ts
+var usedPluginNames = {};
+function pluginParser(plugin, context) {
+  const key = [plugin.kind, plugin.name, getUniqueName(plugin.name, usedPluginNames).split(plugin.name).at(1)];
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      key,
+      api
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
 }
 
-// src/PluginManager.ts
+// src/managers/pluginManager/PluginManager.ts
+var hookNames = {
+  validate: 1,
+  buildStart: 1,
+  resolvePath: 1,
+  resolveName: 1,
+  load: 1,
+  transform: 1,
+  writeFile: 1,
+  buildEnd: 1
+};
+var hooks = Object.keys(hookNames);
 var PluginManager = class {
   plugins;
   fileManager;
@@ -1186,14 +1192,10 @@ var PluginManager = class {
   executed = [];
   logger;
   #core;
-  #usedPluginNames = {};
-  #promiseManager;
   constructor(config, options) {
     this.logger = options.logger;
-    this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
-    this.#promiseManager = new PromiseManager();
-    const plugins = config.plugins || [];
+    this.queue = new Queue(100, options.debug);
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1201,29 +1203,23 @@ var PluginManager = class {
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this)
-    });
-    this.#core = this.#parse(core, this, core.api.call(null));
-    this.plugins = [this.#core, ...plugins].map((plugin) => {
-      return this.#parse(plugin, this, this.#core.api);
+      getPlugins: this.#getSortedPlugins.bind(this),
+      plugin: void 0
     });
+    this.#core = pluginParser(core, core.api.call(null));
+    this.plugins = [this.#core, ...config.plugins || []].reduce((prev, plugin) => {
+      const convertedApi = pluginParser(plugin, this.#core?.api);
+      return [...prev, convertedApi];
+    }, []);
     return this;
   }
   resolvePath = (params) => {
-    if (params.pluginKey) {
-      const paths = this.hookForPluginSync({
-        pluginKey: params.pluginKey,
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
         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",
@@ -1231,20 +1227,13 @@ Paths: ${JSON.stringify(paths, void 0, 2)}`
     }).result;
   };
   resolveName = (params) => {
-    if (params.pluginKey) {
-      const names = this.hookForPluginSync({
-        pluginKey: params.pluginKey,
+    if (params.pluginName) {
+      const name2 = this.hookForPluginSync({
+        pluginName: params.pluginName,
         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);
+      return transformReservedWord(name2 || params.name);
     }
     const name = this.hookFirstSync({
       hookName: "resolveName",
@@ -1259,35 +1248,30 @@ Names: ${JSON.stringify(names, void 0, 2)}`
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginKey,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    const promises = plugins.map((plugin) => {
-      return this.#execute({
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
-    return Promise.all(promises);
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.#execute({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
   }
   hookForPluginSync({
-    pluginKey,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    return plugins.map((plugin) => {
-      return this.#executeSync({
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.#executeSync({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1403,58 +1387,37 @@ Names: ${JSON.stringify(names, void 0, 2)}`
    * Chains plugins
    */
   hookSeq({ hookName, parameters }) {
-    const promises = this.#getSortedPlugins().map((plugin) => {
-      return () => this.#execute({
-        strategy: "hookSeq",
-        hookName,
-        parameters,
-        plugin
+    let promise = Promise.resolve();
+    for (const plugin of this.#getSortedPlugins()) {
+      promise = promise.then(() => {
+        this.#execute({
+          strategy: "hookSeq",
+          hookName,
+          parameters,
+          plugin
+        });
       });
-    });
-    return this.#promiseManager.run("seq", promises);
+    }
+    return promise.then(noReturn);
   }
   #getSortedPlugins(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`);
-        }
-      }
       return plugins.filter((item) => item[hookName]);
     }
     return plugins;
   }
-  getPluginsByKey(hookName, pluginKey) {
+  getPlugin(hookName, pluginName2) {
     const plugins = [...this.plugins];
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
-    const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [kind, name, identifier] = item.key;
-      const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const kindCheck = kind === searchKind;
-      const nameCheck = name === searchPluginName;
-      if (searchIdentifier) {
-        return identifierCheck && kindCheck && nameCheck;
-      }
-      return kindCheck && nameCheck;
-    });
-    if (!pluginByPluginName?.length) {
-      const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === "info") {
-        if (corePlugin) {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
-        } else {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`);
-        }
-      }
-      return corePlugin ? [corePlugin] : [];
+    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
+    if (!pluginByPluginName) {
+      return this.#core;
     }
     return pluginByPluginName;
   }
   #addExecutedToCallStack(executer) {
     if (executer) {
-      this.eventEmitter.emit("executed", executer);
+      this.eventEmitter.emit("execute", executer);
       this.executed.push(executer);
     }
   }
@@ -1524,7 +1487,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
     try {
       if (typeof hook === "function") {
-        const fn = hook.apply({ ...this.#core.api, plugin }, parameters);
+        const fn = hook.apply(this.#core.api, parameters);
         output = fn;
         return fn;
       }
@@ -1550,50 +1513,34 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     this.eventEmitter.emit("error", pluginError);
     throw pluginError;
   }
-  #parse(plugin, pluginManager, context) {
-    const usedPluginNames = 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
-    };
-  }
-  static 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;
-    });
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  static get hooks() {
-    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
-  }
+};
+function noReturn() {
+}
+
+// src/managers/pluginManager/validate.ts
+var ValidationPluginError = class extends Error {
+};
+function getDependedPlugins(plugins, dependedPluginNames) {
+  let pluginNames = [];
+  if (typeof dependedPluginNames === "string") {
+    pluginNames = [dependedPluginNames];
+  } else {
+    pluginNames = dependedPluginNames;
+  }
+  return pluginNames.map((pluginName2) => {
+    const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
+    if (!plugin) {
+      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
+    }
+    return plugin;
+  });
+}
+
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
 };
 
 // src/build.ts
@@ -1601,13 +1548,13 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
+  const { config, logLevel, logger = createLogger() } = options;
   try {
-    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
+    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
-    if (isInputPath(config)) {
+    if ("path" in config.input) {
       throw new Error(
         "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3.dim(config.input.path),
         {
@@ -1620,11 +1567,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path: path3 } = file;
-    let code = FileManager.getSource(file);
+    const { path } = file;
+    let code = createFileSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path3]
+      parameters: [path]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1635,53 +1582,28 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path3],
+        parameters: [code, path],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
-        if (file.meta?.pluginKey) {
-          return pluginManager.hookForPlugin({
-            pluginKey: file.meta?.pluginKey,
-            hookName: "writeFile",
-            parameters: [transformedCode, path3]
-          });
-        }
-        return pluginManager.hookFirst({
+        await pluginManager.hookParallel({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [transformedCode, path]
         });
       }
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
+  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
   const { plugins, fileManager } = pluginManager;
   pluginManager.on("execute", (executer) => {
-    const { hookName, parameters, plugin } = executer;
-    if (hookName === "writeFile" && logger.spinner) {
-      const [code] = parameters;
-      if (logger.logLevel === LogLevel.info) {
-        logger.spinner.start(`\u{1F4BE} Writing`);
-      }
-      if (logger.logLevel === "debug") {
-        logger.info(`PluginKey ${pc3.dim(JSON.stringify(plugin.key))} 
-with source
-
-${code}`);
-      }
-    }
-  });
-  pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
     const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (logger.logLevel === LogLevel.info && logger.spinner) {
-      if (hookName === "writeFile") {
-        const [_code, path3] = parameters;
-        logger.spinner.suffixText = pc3.dim(path3);
-      } else {
+    if (logLevel === LogLevel.info) {
+      if (logger.spinner) {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logger.logLevel === LogLevel.debug) {
+    if (logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1701,14 +1623,15 @@ ${code}`);
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (!fileManager.isExecuting && logger.spinner) {
-    logger.spinner.suffixText = "";
-    logger.spinner.succeed(`\u{1F4BE} Writing completed`);
-  }
-  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
+  return { files: fileManager.files.map((file) => ({ ...file, source: createFileSource(file) })), pluginManager };
+}
+
+// src/config.ts
+function defineConfig(options) {
+  return options;
 }
 
-// src/Generator.ts
+// src/generators/Generator.ts
 var Generator = class {
   #options = {};
   #context = {};
@@ -1731,6 +1654,10 @@ var Generator = class {
     this.#options = { ...this.#options, ...options };
   }
 };
+
+// src/generators/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
 var PackageManager = class _PackageManager {
   static #cache = {};
   #cwd;
@@ -1753,17 +1680,17 @@ var PackageManager = class _PackageManager {
     }
     return directory;
   }
-  getLocation(path3) {
-    let location = path3;
+  getLocation(path) {
+    let location = path;
     if (this.#cwd) {
       const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path3);
+      location = require2.resolve(path);
     }
     return location;
   }
-  async import(path3) {
+  async import(path) {
     try {
-      let location = this.getLocation(path3);
+      let location = this.getLocation(path);
       if (os.platform() == "win32") {
         location = pathToFileURL(location).href;
       }
@@ -1839,13 +1766,9 @@ var PackageManager = class _PackageManager {
   }
 };
 
-// src/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
-
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, PackageManager, ParallelPluginError, PluginError, PluginManager, PromiseManager, SchemaGenerator, SummaryError, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName };
+export { FileManager, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getPathMode, getRelativePath, getUniqueName, hooks, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map