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

package/dist/index.js

@@ -2,17 +2,17 @@ import mod, { createRequire } from 'module';
 import pc3 from 'picocolors';
 export { default as pc } from 'picocolors';
 import crypto from 'crypto';
+import path, { resolve, relative, basename, extname, dirname } from 'path';
 import fs2, { remove } from 'fs-extra';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { orderBy } from 'natural-orderby';
 import { performance } from 'perf_hooks';
+import { EventEmitter as EventEmitter$1 } from 'events';
 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 { createImportDeclaration, createExportDeclaration, print } from '@kubb/parser';
 import isEqual from 'lodash.isequal';
-import { EventEmitter as EventEmitter$1 } from 'events';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
@@ -55,8 +55,8 @@ function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
     }
   };
 }
-async function clean(path) {
-  return remove(path);
+async function clean(path3) {
+  return remove(path3);
 }
 var FunctionParams = class {
   type;
@@ -98,20 +98,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";
@@ -130,7 +119,7 @@ function createJSDocBlockText({ comments }) {
  * ${filteredComments.join("\n * ")}
  */`;
 }
-function createLogger(spinner) {
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -156,6 +145,8 @@ function createLogger(spinner) {
     }
   };
   const logger = {
+    name,
+    logLevel,
     log,
     error,
     warn,
@@ -176,8 +167,29 @@ function nameSorter(a, b) {
   }
   return 0;
 }
+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);
+  }
+  removeAll() {
+    this.#emitter.removeAllListeners();
+  }
+};
+
+// src/utils/Queue.ts
 var Queue = class {
   #queue = [];
+  eventEmitter = new EventEmitter();
   #workerCount = 0;
   #maxParallel;
   #debug = false;
@@ -186,8 +198,8 @@ var Queue = class {
     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 };
+    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");
@@ -197,8 +209,8 @@ var Queue = class {
     });
   }
   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 };
+    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);
       });
@@ -219,17 +231,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) {
         performance.mark(name + "_start");
       }
       job().then((result) => {
-        resolve(result);
+        this.eventEmitter.emit("jobDone", result);
+        resolve2(result);
         if (this.#debug) {
           performance.mark(name + "_stop");
           performance.measure(description, name + "_start", name + "_stop");
         }
-      }).catch((err) => reject(err));
+      }).catch((err) => {
+        this.eventEmitter.emit("jobFailed", err);
+        reject(err);
+      });
     }
     this.#workerCount--;
   }
@@ -260,37 +276,31 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
-function slash(path, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path);
+function slash(path3, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path3);
   if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+    return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
   }
-  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
 }
 function getRelativePath(rootDir, filePath, platform = "linux") {
   if (!rootDir || !filePath) {
     throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
   }
-  const relativePath = 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";
+  const relativePath = relative(rootDir, filePath);
+  const slashedPath = slash(relativePath, platform);
+  if (slashedPath.startsWith("../")) {
+    return slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)));
   }
-  return pathParser.extname(path) ? "file" : "directory";
+  return `./${slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))}`;
 }
 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();
     }
   },
@@ -298,8 +308,8 @@ var reader = switcher(
 );
 var syncReader = 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,11 +317,11 @@ var syncReader = switcher(
   },
   "node"
 );
-async function read(path) {
-  return reader(path);
+async function read(path3) {
+  return reader(path3);
 }
-function readSync(path) {
-  return syncReader(path);
+function readSync(path3) {
+  return syncReader(path3);
 }
 
 // src/utils/renderTemplate.ts
@@ -377,9 +387,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);
   });
 }
@@ -414,6 +424,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",
@@ -506,6 +521,15 @@ function transformReservedWord(word) {
   }
   return word;
 }
+
+// src/utils/transformers/index.ts
+var transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord
+};
 var TreeNode = class _TreeNode {
   data;
   parent;
@@ -570,16 +594,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);
@@ -596,10 +620,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(path) {
-    this.path = path;
+  constructor(path3) {
+    this.path = path3;
     return this;
   }
   /**
@@ -697,39 +741,67 @@ var Warning = class extends Error {
     this.name = "Warning";
   }
 };
-async function saveCreateDirectory(path) {
-  const passedPath = pathParser.dirname(pathParser.resolve(path));
+async function saveCreateDirectory(path3) {
+  const passedPath = dirname(resolve(path3));
   await fs2.mkdir(passedPath, { recursive: true });
 }
 var writer = switcher(
   {
-    node: async (path, data) => {
+    node: async (path3, data) => {
       try {
-        await fs2.stat(path);
-        const oldContent = await fs2.readFile(path, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
+        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(path);
-      return fs2.writeFile(pathParser.resolve(path), data, { encoding: "utf-8" });
+      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 (path, data) => {
+    bun: async (path3, data) => {
       try {
-        await saveCreateDirectory(path);
-        await Bun.write(pathParser.resolve(path), data);
+        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, pathParser.resolve(path));
+        console.log(e, resolve(path3));
       }
     }
   },
   "node"
 );
-async function write(data, path) {
-  return writer(path, data);
+async function write(data, path3) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  return writer(path3, data.trim());
 }
-function getIndexes(root, extName, options = {}) {
+function getIndexes(root, extName, { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = {}) {
   const extMapper = {
     ".ts": {
       extensions: /\.ts/,
@@ -740,7 +812,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;
   }
@@ -749,32 +821,42 @@ function getIndexes(root, extName, options = {}) {
       return [];
     }
     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 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") && path.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,
+        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 path = pathParser.resolve(currentTree.data.path, "index.ts");
+        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,
+          path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: [{ path: importPath }]
+          exports: output ? exports?.filter((item) => {
+            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+          }) : exports
         });
       });
     }
@@ -783,8 +865,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) => {
@@ -812,9 +895,13 @@ function isExtensionAllowed(baseName) {
   return 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 +923,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 +940,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,28 +965,17 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
+  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
 }
 function createFileSource(file) {
-  let { source } = file;
   if (!isExtensionAllowed(file.baseName)) {
     return file.source;
   }
   const exports = file.exports ? combineExports(file.exports) : [];
-  const imports = file.imports ? combineImports(file.imports, exports, source) : [];
+  const imports = file.imports ? combineImports(file.imports, exports, file.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;
+  return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
 }
 function searchAndReplace(options) {
   const { text, replaceBy, prefix = "", key } = options;
@@ -935,11 +1019,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;
   }
@@ -954,23 +1044,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.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;
   }
@@ -990,24 +1076,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(path, file) {
-    const previousFiles = this.#cache.get(path) || [];
-    this.#cache.set(path, [...previousFiles, file]);
-  }
   getCacheByUUID(UUID) {
     let cache;
     this.#cache.forEach((files) => {
@@ -1015,32 +1097,63 @@ ${file.source}` : "",
     });
     return cache;
   }
-  get(path) {
-    return this.#cache.get(path);
+  get(path3) {
+    return this.#cache.get(path3);
   }
-  remove(path) {
-    const cacheItem = this.get(path);
+  remove(path3) {
+    const cacheItem = this.get(path3);
     if (!cacheItem) {
       return;
     }
-    this.#cache.delete(path);
+    this.#cache.delete(path3);
   }
   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(path3) {
+    if (!path3) {
+      return "directory";
+    }
+    return extname(path3) ? "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
@@ -1082,16 +1195,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";
@@ -1100,6 +1204,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1108,6 +1214,9 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
+        get plugin() {
+          return options.plugin;
+        },
         logger,
         fileManager,
         pluginManager,
@@ -1127,37 +1236,35 @@ 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);
-  }
-  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 {
@@ -1192,10 +1299,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,
@@ -1203,23 +1312,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",
@@ -1227,13 +1342,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 +1370,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 +1514,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);
     }
   }
@@ -1487,7 +1635,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;
       }
@@ -1514,8 +1662,6 @@ var PluginManager = class {
     throw pluginError;
   }
 };
-function noReturn() {
-}
 
 // src/managers/pluginManager/validate.ts
 var ValidationPluginError = class extends Error {
@@ -1536,25 +1682,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.dim(config.input.path),
         {
@@ -1567,11 +1714,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 +1729,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,12 +1795,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
@@ -1679,17 +1850,17 @@ var PackageManager = class {
     }
     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;
       }
@@ -1759,6 +1930,6 @@ var PackageManager = class {
 // 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, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defineConfig, executeStrategies, getDependedPlugins, getRelativePath, getUniqueName, hooks, isInputPath, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, setUniqueName, throttle, timeout, transformers, uniqueIdFactory, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map