@kubb/core 1.15.0-canary.20231023T140655 → 1.15.0-canary.20231024T104207

package/dist/index.cjs

@@ -4,17 +4,17 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var pc3 = require('picocolors');
 var crypto = require('crypto');
+var path4 = require('path');
 var fs2 = require('fs-extra');
 var changeCase = require('change-case');
 var naturalOrderby = require('natural-orderby');
 var perf_hooks = require('perf_hooks');
+var events = require('events');
 var seedrandom = require('seedrandom');
-var path2 = require('path');
 var jsRuntime = require('js-runtime');
 var dirTree = require('directory-tree');
 var parser = require('@kubb/parser');
 var isEqual = require('lodash.isequal');
-var events = require('events');
 var mod = require('module');
 var os = require('os');
 var url = require('url');
@@ -26,9 +26,9 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pc3__default = /*#__PURE__*/_interopDefault(pc3);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
 var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
 var mod__default = /*#__PURE__*/_interopDefault(mod);
@@ -71,8 +71,8 @@ function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
     }
   };
 }
-async function clean(path3) {
-  return fs2.remove(path3);
+async function clean(path5) {
+  return fs2.remove(path5);
 }
 var FunctionParams = class {
   type;
@@ -114,20 +114,9 @@ var FunctionParams = class {
   }
 };
 
-// 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";
+  return !!result && typeof result?.then === "function";
 }
 function isPromiseFulfilledResult(result) {
   return result.status === "fulfilled";
@@ -146,7 +135,7 @@ function createJSDocBlockText({ comments }) {
  * ${filteredComments.join("\n * ")}
  */`;
 }
-function createLogger(spinner) {
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -172,6 +161,8 @@ function createLogger(spinner) {
     }
   };
   const logger = {
+    name,
+    logLevel,
     log,
     error,
     warn,
@@ -192,8 +183,29 @@ function nameSorter(a, b) {
   }
   return 0;
 }
+var EventEmitter = class {
+  constructor() {
+    this.#emitter.setMaxListeners(100);
+  }
+  #emitter = new events.EventEmitter();
+  emit(eventName, ...eventArg) {
+    this.#emitter.emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    this.#emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.#emitter.off(eventName, handler);
+  }
+  removeAll() {
+    this.#emitter.removeAllListeners();
+  }
+};
+
+// src/utils/Queue.ts
 var Queue = class {
   #queue = [];
+  eventEmitter = new EventEmitter();
   #workerCount = 0;
   #maxParallel;
   #debug = false;
@@ -202,8 +214,8 @@ var Queue = class {
     this.#debug = debug;
   }
   run(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve, reject) => {
-      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+    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");
@@ -213,8 +225,8 @@ var Queue = class {
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve, reject) => {
-      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+    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);
       });
@@ -235,17 +247,21 @@ var Queue = class {
     this.#workerCount++;
     let entry;
     while (entry = this.#queue.shift()) {
-      const { reject, resolve, job, name, description } = entry;
+      const { reject, resolve: resolve2, job, name, description } = entry;
       if (this.#debug) {
         perf_hooks.performance.mark(name + "_start");
       }
       job().then((result) => {
-        resolve(result);
+        this.eventEmitter.emit("jobDone", result);
+        resolve2(result);
         if (this.#debug) {
           perf_hooks.performance.mark(name + "_stop");
           perf_hooks.performance.measure(description, name + "_start", name + "_stop");
         }
-      }).catch((err) => reject(err));
+      }).catch((err) => {
+        this.eventEmitter.emit("jobFailed", err);
+        reject(err);
+      });
     }
     this.#workerCount--;
   }
@@ -276,37 +292,31 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
-function slash(path3, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path3);
+function slash(path5, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path5);
   if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+    return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
   }
-  return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
 }
 function getRelativePath(rootDir, filePath, platform = "linux") {
   if (!rootDir || !filePath) {
     throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
   }
-  const relativePath = path2__default.default.relative(rootDir, filePath);
-  const path3 = slash(relativePath, platform);
-  if (path3.startsWith("../")) {
-    return path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)));
-  }
-  return `./${path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)))}`;
-}
-function getPathMode(path3) {
-  if (!path3) {
-    return "directory";
+  const relativePath = path4.relative(rootDir, filePath);
+  const slashedPath = slash(relativePath, platform);
+  if (slashedPath.startsWith("../")) {
+    return slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)));
   }
-  return path2__default.default.extname(path3) ? "file" : "directory";
+  return `./${slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)))}`;
 }
 var reader = jsRuntime.switcher(
   {
-    node: async (path3) => {
-      return fs2__default.default.readFile(path3, { encoding: "utf8" });
+    node: async (path5) => {
+      return fs2__default.default.readFile(path5, { encoding: "utf8" });
     },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
+    bun: async (path5) => {
+      const file = Bun.file(path5);
       return file.text();
     }
   },
@@ -314,8 +324,8 @@ var reader = jsRuntime.switcher(
 );
 var syncReader = jsRuntime.switcher(
   {
-    node: (path3) => {
-      return fs2__default.default.readFileSync(path3, { encoding: "utf8" });
+    node: (path5) => {
+      return fs2__default.default.readFileSync(path5, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -323,11 +333,11 @@ var syncReader = jsRuntime.switcher(
   },
   "node"
 );
-async function read(path3) {
-  return reader(path3);
+async function read(path5) {
+  return reader(path5);
 }
-function readSync(path3) {
-  return syncReader(path3);
+function readSync(path5) {
+  return syncReader(path5);
 }
 
 // src/utils/renderTemplate.ts
@@ -393,9 +403,9 @@ var throttle = (fn, delay) => {
 
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     setTimeout(() => {
-      resolve(true);
+      resolve2(true);
     }, ms);
   });
 }
@@ -430,6 +440,11 @@ function jsStringEscape(input) {
   });
 }
 
+// src/utils/transformers/indent.ts
+function createIndent(size) {
+  return Array.from({ length: size + 1 }).join(" ");
+}
+
 // src/utils/transformers/transformReservedWord.ts
 var reservedWords = [
   "abstract",
@@ -522,6 +537,15 @@ function transformReservedWord(word) {
   }
   return word;
 }
+
+// src/utils/transformers/index.ts
+var transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord
+};
 var TreeNode = class _TreeNode {
   data;
   parent;
@@ -586,16 +610,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path3, options = {}) {
+  static build(path5, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree__default.default(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree__default.default(path5, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
       const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) });
         if (item.children?.length) {
           item.children?.forEach((child) => {
             recurse(subNode, child);
@@ -612,10 +636,30 @@ var TreeNode = class _TreeNode {
 
 // src/utils/uniqueIdFactory.ts
 var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
+
+// src/utils/uniqueName.ts
+function getUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    originalName += used;
+  }
+  data[originalName] = 1;
+  return originalName;
+}
+function setUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    return originalName;
+  }
+  data[originalName] = 1;
+  return originalName;
+}
 var URLPath = class {
   path;
-  constructor(path3) {
-    this.path = path3;
+  constructor(path5) {
+    this.path = path5;
     return this;
   }
   /**
@@ -713,39 +757,67 @@ var Warning = class extends Error {
     this.name = "Warning";
   }
 };
-async function saveCreateDirectory(path3) {
-  const passedPath = path2__default.default.dirname(path2__default.default.resolve(path3));
+async function saveCreateDirectory(path5) {
+  const passedPath = path4.dirname(path4.resolve(path5));
   await fs2__default.default.mkdir(passedPath, { recursive: true });
 }
 var writer = jsRuntime.switcher(
   {
-    node: async (path3, data) => {
+    node: async (path5, data) => {
       try {
-        await fs2__default.default.stat(path3);
-        const oldContent = await fs2__default.default.readFile(path3, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
+        await fs2__default.default.stat(path4.resolve(path5));
+        const oldContent = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+        if (oldContent?.toString() === data?.toString()) {
           return;
         }
       } catch (_err) {
       }
-      await saveCreateDirectory(path3);
-      return fs2__default.default.writeFile(path2__default.default.resolve(path3), data, { encoding: "utf-8" });
+      await saveCreateDirectory(path5);
+      await fs2__default.default.writeFile(path4.resolve(path5), data, { encoding: "utf-8" });
+      const savedData = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+      if (savedData?.toString() !== data?.toString()) {
+        throw new Error(`Sanity check failed for ${path5}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+      }
+      return savedData;
     },
-    bun: async (path3, data) => {
+    bun: async (path5, data) => {
       try {
-        await saveCreateDirectory(path3);
-        await Bun.write(path2__default.default.resolve(path3), data);
+        await saveCreateDirectory(path5);
+        await Bun.write(path4.resolve(path5), data);
+        const file = Bun.file(path4.resolve(path5));
+        const savedData = await file.text();
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path5}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+        }
+        return savedData;
       } catch (e) {
-        console.log(e, path2__default.default.resolve(path3));
+        console.log(e, path4.resolve(path5));
       }
     }
   },
   "node"
 );
-async function write(data, path3) {
-  return writer(path3, data);
+async function write(data, path5) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  return writer(path5, data.trim());
 }
-function getIndexes(root, extName, options = {}) {
+function getIndexes(root, extName, { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = {}) {
   const extMapper = {
     ".ts": {
       extensions: /\.ts/,
@@ -756,7 +828,7 @@ function getIndexes(root, extName, options = {}) {
       exclude: []
     }
   };
-  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
+  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
   if (!tree) {
     return null;
   }
@@ -765,32 +837,42 @@ function getIndexes(root, extName, options = {}) {
       return [];
     }
     if (currentTree.children?.length > 1) {
-      const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
-      const exports = currentTree.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
+      const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.children.filter(Boolean).map((file) => {
         const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-        if (importPath.includes("index") && path3.includes("index")) {
+        if (importPath.includes("index") && indexPath.includes("index")) {
           return void 0;
         }
-        return { path: importPath };
+        return {
+          path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+          isTypeOnly
+        };
       }).filter(Boolean);
       files2.push({
-        path: path3,
+        path: indexPath,
         baseName: "index.ts",
         source: "",
-        exports
+        exports: output ? exports?.filter((item) => {
+          return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+        }) : exports
       });
     } else {
       currentTree.children?.forEach((child) => {
-        const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
+        const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
         const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        const exports = [
+          {
+            path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+            isTypeOnly
+          }
+        ];
         files2.push({
-          path: path3,
+          path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: [{ path: importPath }]
+          exports: output ? exports?.filter((item) => {
+            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+          }) : exports
         });
       });
     }
@@ -799,8 +881,9 @@ function getIndexes(root, extName, options = {}) {
     });
     return files2;
   };
-  const files = fileReducer([], tree);
-  return files;
+  const files = fileReducer([], tree).reverse();
+  const filteredFiles = filter ? files.filter(filter) : files;
+  return map ? filteredFiles.map(map) : filteredFiles;
 }
 function combineFiles(files) {
   return files.filter(Boolean).reduce((acc, curr) => {
@@ -828,9 +911,13 @@ function isExtensionAllowed(baseName) {
   return extensions.some((extension) => baseName.endsWith(extension));
 }
 function combineExports(exports) {
-  return exports.reduce((prev, curr) => {
+  const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathAndIsTypeOnly) {
+      return prev;
+    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -852,12 +939,16 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
+  return naturalOrderby.orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  return imports.reduce((prev, curr) => {
+  const combinedImports = naturalOrderby.orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
     const hasImportInSource = (importName) => {
-      const checker = (name2) => name2 && !!source.includes(`${name2}`);
+      if (!source) {
+        return true;
+      }
+      const checker = (name2) => name2 && !!source.includes(name2);
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
@@ -865,6 +956,10 @@ function combineImports(imports, exports, source) {
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
     const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathNameAndIsTypeOnly) {
+      return prev;
+    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -886,28 +981,17 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
+  return naturalOrderby.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 imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
   const importNodes = imports.map((item) => parser.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-  const importSource = parser.print(importNodes);
   const exportNodes = exports.map((item) => parser.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
-  const exportSource = parser.print(exportNodes);
-  source = getEnvSource(file.source, file.env);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
+  return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
 }
 function searchAndReplace(options) {
   const { text, replaceBy, prefix = "", key } = options;
@@ -951,11 +1035,17 @@ function getEnvSource(source, env) {
 var FileManager = class {
   #cache = /* @__PURE__ */ new Map();
   #task;
+  #isWriting = false;
+  /**
+   * Timeout between writes
+   */
+  #timeout = 0;
   #queue;
   constructor(options) {
     if (options) {
       this.#task = options.task;
       this.#queue = options.queue;
+      this.#timeout = options.timeout || 0;
     }
     return this;
   }
@@ -970,23 +1060,19 @@ var FileManager = class {
     return files;
   }
   get isExecuting() {
-    return this.#queue?.hasJobs ?? false;
+    return this.#queue?.hasJobs ?? this.#isWriting ?? false;
   }
   async add(file) {
     const controller = new AbortController();
     const resolvedFile = { id: crypto__default.default.randomUUID(), ...file };
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
     if (this.#queue) {
-      try {
-        await this.#queue.run(
-          async () => {
-            return this.#task?.(resolvedFile);
-          },
-          { controller }
-        );
-      } catch {
-        return resolvedFile;
-      }
+      await this.#queue.run(
+        async () => {
+          return this.#task?.(resolvedFile);
+        },
+        { controller }
+      );
     }
     return resolvedFile;
   }
@@ -1006,24 +1092,20 @@ ${file.source}` : "",
     }
     return this.add(file);
   }
-  async addIndexes(root, extName = ".ts", options = {}) {
-    const files = await getIndexes(root, extName, options);
+  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
+    const files = getIndexes(root, extName, options);
     if (!files) {
       return void 0;
     }
-    return Promise.all(
+    return await Promise.all(
       files.map((file) => {
-        if (file.override) {
-          return this.add(file);
-        }
-        return this.addOrAppend(file);
+        return this.addOrAppend({
+          ...file,
+          meta: meta ? meta : file.meta
+        });
       })
     );
   }
-  #append(path3, file) {
-    const previousFiles = this.#cache.get(path3) || [];
-    this.#cache.set(path3, [...previousFiles, file]);
-  }
   getCacheByUUID(UUID) {
     let cache;
     this.#cache.forEach((files) => {
@@ -1031,32 +1113,63 @@ ${file.source}` : "",
     });
     return cache;
   }
-  get(path3) {
-    return this.#cache.get(path3);
+  get(path5) {
+    return this.#cache.get(path5);
   }
-  remove(path3) {
-    const cacheItem = this.get(path3);
+  remove(path5) {
+    const cacheItem = this.get(path5);
     if (!cacheItem) {
       return;
     }
-    this.#cache.delete(path3);
+    this.#cache.delete(path5);
   }
   async write(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return write(...params);
-      });
+    if (!this.#isWriting) {
+      this.#isWriting = true;
+      const text = await write(...params);
+      this.#isWriting = false;
+      return text;
     }
-    return write(...params);
+    await timeout(this.#timeout);
+    return this.write(...params);
   }
   async read(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return read(...params);
-      });
-    }
     return read(...params);
   }
+  // statics
+  static getSource(file) {
+    return createFileSource(file);
+  }
+  static combineFiles(files) {
+    return combineFiles(files);
+  }
+  static getMode(path5) {
+    if (!path5) {
+      return "directory";
+    }
+    return path4.extname(path5) ? "file" : "directory";
+  }
+};
+
+// src/managers/pluginManager/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([])
+  );
+}
+var executeStrategies = {
+  hookSeq
 };
 
 // src/managers/pluginManager/ParallelPluginError.ts
@@ -1098,16 +1211,7 @@ var PluginError = class extends Error {
 };
 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;
-      };
-    }
-    return plugin;
+    return factory(options);
   };
 }
 var pluginName = "core";
@@ -1116,6 +1220,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1124,6 +1230,9 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
+        get plugin() {
+          return options.plugin;
+        },
         logger,
         fileManager,
         pluginManager,
@@ -1143,37 +1252,35 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path2__default.default.resolve(this.config.root, this.config.output.path);
-      return path2__default.default.resolve(root, baseName);
+      const root = path4__default.default.resolve(this.config.root, this.config.output.path);
+      return path4__default.default.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #emitter = new events.EventEmitter();
-  emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
-  }
-  on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
-  }
-  off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
-  }
-  removeAll() {
-    this.#emitter.removeAllListeners();
-  }
+
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
 };
 
 // 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)];
+function pluginParser(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 {
@@ -1208,10 +1315,12 @@ var PluginManager = class {
   executed = [];
   logger;
   #core;
+  usedPluginNames = {};
   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 });
+    const plugins = config.plugins || [];
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1219,23 +1328,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 = pluginParser(core, this, core.api.call(null));
+    this.plugins = [this.#core, ...plugins].map((plugin) => {
+      return pluginParser(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",
@@ -1243,13 +1358,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",
@@ -1264,30 +1386,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
@@ -1403,37 +1530,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 executeStrategies.hookSeq(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);
     }
   }
@@ -1503,7 +1651,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;
       }
@@ -1530,8 +1678,6 @@ var PluginManager = class {
     throw pluginError;
   }
 };
-function noReturn() {
-}
 
 // src/managers/pluginManager/validate.ts
 var ValidationPluginError = class extends Error {
@@ -1552,25 +1698,26 @@ function getDependedPlugins(plugins, dependedPluginNames) {
   });
 }
 
-// src/types.ts
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
-};
+// src/config.ts
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logLevel, logger = createLogger() } = options;
+  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
   try {
-    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
+    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
-    if ("path" in config.input) {
+    if (isInputPath(config)) {
       throw new Error(
         "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
         {
@@ -1583,11 +1730,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path: path3 } = file;
-    let code = createFileSource(file);
+    const { path: path5 } = file;
+    let code = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path3]
+      parameters: [path5]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1598,28 +1745,53 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path3],
+        parameters: [code, path5],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
-        await pluginManager.hookParallel({
+        if (file.meta?.pluginKey) {
+          return pluginManager.hookForPlugin({
+            pluginKey: file.meta?.pluginKey,
+            hookName: "writeFile",
+            parameters: [transformedCode, path5]
+          });
+        }
+        return pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [transformedCode, path5]
         });
       }
     }
   };
-  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
+  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
   const { plugins, fileManager } = pluginManager;
   pluginManager.on("execute", (executer) => {
+    const { hookName, parameters, plugin } = executer;
+    if (hookName === "writeFile" && logger.spinner) {
+      const [code] = parameters;
+      if (logger.logLevel === LogLevel.info) {
+        logger.spinner.start(`\u{1F4BE} Writing`);
+      }
+      if (logger.logLevel === "debug") {
+        logger.info(`PluginKey ${pc3__default.default.dim(JSON.stringify(plugin.key))} 
+with source
+
+${code}`);
+      }
+    }
+  });
+  pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
     const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (logLevel === LogLevel.info) {
-      if (logger.spinner) {
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
+      if (hookName === "writeFile") {
+        const [_code, path5] = parameters;
+        logger.spinner.suffixText = pc3__default.default.dim(path5);
+      } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logLevel === LogLevel.debug) {
+    if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1639,12 +1811,11 @@ 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
@@ -1740,18 +1911,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve, args) => {
+  const run = async (fn, resolve2, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve(result);
+    resolve2(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve, args));
+  const enqueue = (fn, resolve2, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve2, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1759,8 +1930,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve) => {
-    enqueue(fn, resolve, args);
+  const generator = (fn, ...args) => new Promise((resolve2) => {
+    enqueue(fn, resolve2, args);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -1835,7 +2006,7 @@ async function locatePath(paths, {
   const statFunction = allowSymlinks ? fs3.promises.stat : fs3.promises.lstat;
   return pLocate(paths, async (path_) => {
     try {
-      const stat = await statFunction(path2__default.default.resolve(cwd, path_));
+      const stat = await statFunction(path4__default.default.resolve(cwd, path_));
       return matchType(type, stat);
     } catch {
       return false;
@@ -1852,7 +2023,7 @@ function locatePathSync(paths, {
   const statFunction = allowSymlinks ? fs3__default.default.statSync : fs3__default.default.lstatSync;
   for (const path_ of paths) {
     try {
-      const stat = statFunction(path2__default.default.resolve(cwd, path_), {
+      const stat = statFunction(path4__default.default.resolve(cwd, path_), {
         throwIfNoEntry: false
       });
       if (!stat) {
@@ -1870,9 +2041,9 @@ function locatePathSync(paths, {
 var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
 async function findUpMultiple(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
-  const stopAt = path2__default.default.resolve(directory, options.stopAt || root);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
+  const stopAt = path4__default.default.resolve(directory, options.stopAt || root);
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
   const runMatcher = async (locateOptions) => {
@@ -1892,18 +2063,18 @@ async function findUpMultiple(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
 function findUpMultipleSync(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
   const stopAt = options.stopAt || root;
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
@@ -1924,12 +2095,12 @@ function findUpMultipleSync(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
@@ -1962,17 +2133,17 @@ var PackageManager = class {
     }
     return directory;
   }
-  getLocation(path3) {
-    let location = path3;
+  getLocation(path5) {
+    let location = path5;
     if (this.#cwd) {
       const require2 = mod__default.default.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path3);
+      location = require2.resolve(path5);
     }
     return location;
   }
-  async import(path3) {
+  async import(path5) {
     try {
-      let location = this.getLocation(path3);
+      let location = this.getLocation(path5);
       if (os__default.default.platform() == "win32") {
         location = url.pathToFileURL(location).href;
       }
@@ -2063,31 +2234,21 @@ exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;
 exports.clean = clean;
-exports.combineCodes = combineCodes;
-exports.combineExports = combineExports;
-exports.combineFiles = combineFiles;
-exports.combineImports = combineImports;
-exports.createFileSource = createFileSource;
 exports.createJSDocBlockText = createJSDocBlockText;
 exports.createLogger = createLogger;
 exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
-exports.defaultColours = defaultColours;
 exports.defineConfig = defineConfig;
-exports.escape = escape;
-exports.extensions = extensions;
+exports.executeStrategies = executeStrategies;
 exports.getDependedPlugins = getDependedPlugins;
-exports.getIndexes = getIndexes;
-exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
 exports.getUniqueName = getUniqueName;
 exports.hooks = hooks;
-exports.isExtensionAllowed = isExtensionAllowed;
+exports.isInputPath = isInputPath;
 exports.isPromise = isPromise;
 exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
 exports.isPromiseRejectedResult = isPromiseRejectedResult;
-exports.jsStringEscape = jsStringEscape;
 exports.name = pluginName;
 exports.nameSorter = nameSorter;
 exports.pluginName = pluginName;
@@ -2096,9 +2257,10 @@ exports.randomPicoColour = randomPicoColour;
 exports.read = read;
 exports.readSync = readSync;
 exports.renderTemplate = renderTemplate;
+exports.setUniqueName = setUniqueName;
 exports.throttle = throttle;
 exports.timeout = timeout;
-exports.transformReservedWord = transformReservedWord;
+exports.transformers = transformers;
 exports.uniqueIdFactory = uniqueIdFactory;
 exports.write = write;
 //# sourceMappingURL=out.js.map