@kubb/core 1.15.0-canary.20231025T103357 → 1.15.0-canary.20231025T223729

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 { camelCase, camelCaseTransformMerge } from 'change-case';
-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 { 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 dirTree from 'directory-tree';
 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,110 +27,15 @@ 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(path) {
-  return remove(path);
+async function clean(path3) {
+  return 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 = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
-    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
-      if (!name) {
-        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        return acc;
-      }
-      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
-      if (type) {
-        if (required) {
-          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        } else {
-          acc.push(`${parameterName}?: ${type}`);
-        }
-      } else {
-        acc.push(`${parameterName}`);
-      }
-      return acc;
-    }, []).join(", ");
-  }
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
 };
-
-// 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) {
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -156,6 +61,8 @@ function createLogger(spinner) {
     }
   };
   const logger = {
+    name,
+    logLevel,
     log,
     error,
     warn,
@@ -165,75 +72,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.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) {
@@ -260,46 +98,22 @@ 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 (path) => {
-      return fs2.readFile(path, { encoding: "utf8" });
+    node: async (path3) => {
+      return fs2.readFile(path3, { encoding: "utf8" });
     },
-    bun: async (path) => {
-      const file = Bun.file(path);
+    bun: async (path3) => {
+      const file = Bun.file(path3);
       return file.text();
     }
   },
   "node"
 );
-var syncReader = switcher(
+switcher(
   {
-    node: (path) => {
-      return fs2.readFileSync(path, { encoding: "utf8" });
+    node: (path3) => {
+      return fs2.readFileSync(path3, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -307,79 +121,116 @@ var syncReader = switcher(
   },
   "node"
 );
-async function read(path) {
-  return reader(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;
-    }
-    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(path3) {
+  return reader(path3);
 }
-
-// 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 {
+  path;
+  constructor(path3) {
+    this.path = path3;
+    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(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
+      return void 0;
+    }
+    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("}", "");
+  }
 };
 
+// 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);
   });
 }
@@ -389,6 +240,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("`", "\\`") : "";
@@ -414,6 +276,39 @@ 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",
@@ -506,6 +401,80 @@ 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;
@@ -570,16 +539,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path, options = {}) {
+  static build(path3, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree(path3, { 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);
@@ -594,227 +563,271 @@ var TreeNode = class _TreeNode {
   }
 };
 
-// src/utils/uniqueIdFactory.ts
-var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
-var URLPath = class {
-  path;
-  constructor(path) {
-    this.path = path;
+// src/BarrelManager.ts
+var BarrelManager = class {
+  #options = {};
+  constructor(options = {}) {
+    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 } = 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 = path.resolve(currentTree.data.path, "index.ts");
+        const exports = currentTree.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+          if (importPath.includes("index") && indexPath.includes("index")) {
+            return void 0;
+          }
+          return {
+            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+            isTypeOnly
+          };
+        }).filter(Boolean);
+        files2.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports: output ? exports?.filter((item) => {
+            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+          }) : exports
+        });
+      } else {
+        currentTree.children?.forEach((child) => {
+          const indexPath = path.resolve(currentTree.data.path, "index.ts");
+          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+          const exports = [
+            {
+              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+              isTypeOnly
+            }
+          ];
+          files2.push({
+            path: indexPath,
+            baseName: "index.ts",
+            source: "",
+            exports: output ? exports?.filter((item) => {
+              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+            }) : exports
+          });
+        });
+      }
+      currentTree.children.forEach((childItem) => {
+        fileReducer(files2, childItem);
+      });
+      return files2;
+    };
+    const files = fileReducer([], tree).reverse();
+    const filteredFiles = filter ? files.filter(filter) : files;
+    return map ? filteredFiles.map(map) : filteredFiles;
   }
+};
+
+// src/FileManager.ts
+var FileManager = class _FileManager {
+  #cache = /* @__PURE__ */ new Map();
+  #task;
+  #isWriting = 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}`
+   * Timeout between writes
    */
-  get template() {
-    return this.toTemplateString();
+  #timeout = 0;
+  #queue;
+  constructor(options) {
+    if (options) {
+      this.#task = options.task;
+      this.#queue = options.queue;
+      this.#timeout = options.timeout || 0;
+    }
+    return this;
   }
-  get object() {
-    return this.toObject();
+  get files() {
+    const files = [];
+    this.#cache.forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
   }
-  get params() {
-    return this.getParams();
+  get isExecuting() {
+    return this.#queue?.hasJobs ?? 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");
+  #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}`);
+    }
+  }
+  async add(...files) {
+    const promises = files.map((file) => {
+      this.#validate(file);
+      if (file.override) {
+        return this.#add(file);
       }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      return this.#addOrAppend(file);
+    });
+    const resolvedFiles = await Promise.all(promises);
+    if (files.length > 1) {
+      return resolvedFiles;
     }
-    return object;
+    return resolvedFiles[0];
   }
-  /**
-   * 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);
+  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 `\`${newPath}\``;
+    return resolvedFile;
   }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
+  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 || {} }
+      });
+    }
+    return this.#add(file);
+  }
+  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(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
+    return await Promise.all(
+      files.map((file) => {
+        return this.#addOrAppend({
+          ...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;
+    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(path3) {
+    return this.#cache.get(path3);
   }
-};
-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));
-      }
-    }
-  },
-  "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: []
+  remove(path3) {
+    const cacheItem = this.get(path3);
+    if (!cacheItem) {
+      return;
     }
-  };
-  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
-  if (!tree) {
-    return null;
+    this.#cache.delete(path3);
   }
-  const fileReducer = (files2, currentTree) => {
-    if (!currentTree.children) {
-      return [];
+  async write(...params) {
+    if (!this.#isWriting) {
+      this.#isWriting = true;
+      const text = await write(...params);
+      this.#isWriting = false;
+      return text;
     }
-    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 }]
-        });
-      });
+    await timeout(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.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];
+      }
       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(path3) {
+    if (!path3) {
+      return "directory";
     }
-    return acc;
-  }, []);
-}
-var extensions = [".js", ".ts", ".tsx"];
-function isExtensionAllowed(baseName) {
-  return extensions.some((extension) => baseName.endsWith(extension));
-}
+    return extname(path3) ? "file" : "directory";
+  }
+  static get extensions() {
+    return [".js", ".ts", ".tsx"];
+  }
+  static isExtensionAllowed(baseName) {
+    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
+  }
+};
 function combineExports(exports) {
-  return exports.reduce((prev, curr) => {
+  const combinedExports = 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(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
     );
@@ -836,12 +849,16 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
+  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  return imports.reduce((prev, curr) => {
+  const combinedImports = 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)) {
@@ -849,6 +866,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(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;
     }
@@ -870,43 +891,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) => 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);
+  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -923,127 +908,117 @@ 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;
-  }
-  get extensions() {
-    return extensions;
+var EventEmitter = class {
+  constructor() {
+    this.#emitter.setMaxListeners(100);
   }
-  get files() {
-    const files = [];
-    this.#cache.forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
+  #emitter = new EventEmitter$1();
+  emit(eventName, ...eventArg) {
+    this.#emitter.emit(eventName, ...eventArg);
   }
-  get isExecuting() {
-    return this.#queue?.hasJobs ?? false;
+  on(eventName, handler) {
+    this.#emitter.on(eventName, handler);
   }
-  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;
+  off(eventName, handler) {
+    this.#emitter.off(eventName, handler);
   }
-  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 || {} }
-      });
-    }
-    return this.add(file);
+  removeAll() {
+    this.#emitter.removeAllListeners();
   }
-  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);
-      })
-    );
+};
+var Queue = class {
+  #queue = [];
+  eventEmitter = new EventEmitter();
+  #workerCount = 0;
+  #maxParallel;
+  #debug = false;
+  constructor(maxParallel, debug = false) {
+    this.#maxParallel = maxParallel;
+    this.#debug = debug;
   }
-  #append(path, file) {
-    const previousFiles = this.#cache.get(path) || [];
-    this.#cache.set(path, [...previousFiles, file]);
+  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");
+      });
+      this.#queue.push(item);
+      this.#work();
+    });
   }
-  getCacheByUUID(UUID) {
-    let cache;
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
+  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();
     });
-    return cache;
   }
-  get(path) {
-    return this.#cache.get(path);
+  get hasJobs() {
+    return this.#workerCount > 0 || this.#queue.length > 0;
   }
-  remove(path) {
-    const cacheItem = this.get(path);
-    if (!cacheItem) {
-      return;
-    }
-    this.#cache.delete(path);
+  get count() {
+    return this.#workerCount;
   }
-  async write(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return write(...params);
-      });
+  #work() {
+    if (this.#workerCount >= this.#maxParallel) {
+      return;
     }
-    return write(...params);
-  }
-  async read(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return read(...params);
+    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);
       });
     }
-    return read(...params);
+    this.#workerCount--;
   }
 };
 
-// src/managers/pluginManager/ParallelPluginError.ts
+// src/utils/uniqueName.ts
+function setUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    return originalName;
+  }
+  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;
+  }
+};
 var ParallelPluginError = class extends Error {
   errors = [];
   pluginManager;
@@ -1068,30 +1043,55 @@ var ParallelPluginError = class extends Error {
     })?.cause;
   }
 };
-
-// src/managers/pluginManager/PluginError.ts
-var PluginError = class extends Error {
-  pluginManager;
-  cause;
+var SummaryError = class extends Error {
+  summary;
   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";
@@ -1100,6 +1100,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1108,18 +1110,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,
@@ -1127,63 +1129,58 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = pathParser.resolve(this.config.root, this.config.output.path);
-      return pathParser.resolve(root, baseName);
+      const root = path.resolve(this.config.root, this.config.output.path);
+      return path.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #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);
+
+// 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;
   }
-  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
-  };
+function isPromise(result) {
+  return !!result && typeof result?.then === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+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 PluginManager = class {
   plugins;
   fileManager;
@@ -1192,10 +1189,14 @@ var PluginManager = class {
   executed = [];
   logger;
   #core;
+  #usedPluginNames = {};
+  #promiseManager;
   constructor(config, options) {
     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 });
+    this.#promiseManager = new PromiseManager();
+    const plugins = config.plugins || [];
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1203,23 +1204,29 @@ 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: 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);
     });
-    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,
+    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",
@@ -1227,13 +1234,20 @@ var PluginManager = class {
     }).result;
   };
   resolveName = (params) => {
-    if (params.pluginName) {
-      const name2 = this.hookForPluginSync({
-        pluginName: params.pluginName,
+    if (params.pluginKey) {
+      const names = this.hookForPluginSync({
+        pluginKey: params.pluginKey,
         hookName: "resolveName",
         parameters: [params.name, params.type]
       });
-      return transformReservedWord(name2 || params.name);
+      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",
@@ -1248,30 +1262,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 this.#execute({
+        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 this.#executeSync({
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
+      });
+    }).filter(Boolean);
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1387,37 +1406,58 @@ 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 = this.#getSortedPlugins().map((plugin) => {
+      return () => this.#execute({
+        strategy: "hookSeq",
+        hookName,
+        parameters,
+        plugin
       });
-    }
-    return promise.then(noReturn);
+    });
+    return this.#promiseManager.run("seq", promises);
   }
   #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;
   }
-  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.eventEmitter.emit("executed", executer);
       this.executed.push(executer);
     }
   }
@@ -1487,7 +1527,7 @@ var PluginManager = class {
     this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
     try {
       if (typeof hook === "function") {
-        const fn = hook.apply(this.#core.api, parameters);
+        const fn = hook.apply({ ...this.#core.api, plugin }, parameters);
         output = fn;
         return fn;
       }
@@ -1513,34 +1553,50 @@ var PluginManager = class {
     this.eventEmitter.emit("error", pluginError);
     throw pluginError;
   }
-};
-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"
+  #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"];
+  }
 };
 
 // src/build.ts
@@ -1548,13 +1604,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.dim(config.input.path),
         {
@@ -1567,11 +1623,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path } = file;
-    let code = createFileSource(file);
+    const { path: path3 } = file;
+    let code = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path]
+      parameters: [path3]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1582,28 +1638,53 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path],
+        parameters: [code, path3],
         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, path3]
+          });
+        }
+        return pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path]
+          parameters: [transformedCode, path3]
         });
       }
     }
   };
-  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.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, path3] = parameters;
+        logger.spinner.suffixText = pc3.dim(path3);
+      } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logLevel === LogLevel.debug) {
+    if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1623,15 +1704,14 @@ 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 Generator = class {
   #options = {};
   #context = {};
@@ -1654,10 +1734,6 @@ var Generator = class {
     this.#options = { ...this.#options, ...options };
   }
 };
-
-// src/generators/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
 var PackageManager = class _PackageManager {
   static #cache = {};
   #cwd;
@@ -1680,17 +1756,17 @@ var PackageManager = class _PackageManager {
     }
     return directory;
   }
-  getLocation(path) {
-    let location = path;
+  getLocation(path3) {
+    let location = path3;
     if (this.#cwd) {
       const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path);
+      location = require2.resolve(path3);
     }
     return location;
   }
-  async import(path) {
+  async import(path3) {
     try {
-      let location = this.getLocation(path);
+      let location = this.getLocation(path3);
       if (os.platform() == "win32") {
         location = pathToFileURL(location).href;
       }
@@ -1766,9 +1842,13 @@ var PackageManager = class _PackageManager {
   }
 };
 
+// src/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
+
 // src/index.ts
 var src_default = build;
 
-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 };
+export { FileManager, Generator, PackageManager, ParallelPluginError, PluginError, PluginManager, PromiseManager, SchemaGenerator, SummaryError, ValidationPluginError, Warning, build, createPlugin, src_default as default, defineConfig, isInputPath, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, pluginName };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map