@kubb/core 1.1.13 → 1.2.1

package/dist/index.js

@@ -3,8 +3,14 @@ import crypto from 'node:crypto';
 import fs from 'fs-extra';
 import pathParser2 from 'node:path';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
+import { performance } from 'node:perf_hooks';
 import { rimraf } from 'rimraf';
 import dirTree from 'directory-tree';
+import mod from 'node:module';
+import { pathToFileURL } from 'node:url';
+import pc2 from 'picocolors';
+export { default as pc } from 'picocolors';
+import seedrandom from 'seedrandom';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
@@ -13,6 +19,12 @@ createRequire(import.meta.url);
 function isPromise(result) {
   return typeof result?.then === "function";
 }
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
 async function safeWriteFileToPath(path, data) {
   const passedPath = pathParser2.dirname(pathParser2.resolve(path));
   await fs.mkdir(passedPath, { recursive: true });
@@ -155,18 +167,18 @@ async function timeout(ms) {
     }, ms);
   });
 }
-
-// src/utils/Queue.ts
 var Queue = class {
   queue = [];
   workerCount = 0;
   maxParallel;
-  constructor(maxParallel) {
+  debug = false;
+  constructor(maxParallel, debug = false) {
     this.maxParallel = maxParallel;
+    this.debug = debug;
   }
-  run(task) {
+  run(task, options = { name: crypto.randomUUID(), description: "" }) {
     return new Promise((resolve, reject) => {
-      const item = { reject, resolve, task };
+      const item = { reject, resolve, task, name: options.name, description: options.description || options.name };
       this.queue.push(item);
       this.work();
     });
@@ -178,8 +190,17 @@ var Queue = class {
     this.workerCount++;
     let entry;
     while (entry = this.queue.shift()) {
-      const { reject, resolve, task } = entry;
-      task().then((result) => resolve(result)).catch((err) => reject(err));
+      const { reject, resolve, task, name, description } = entry;
+      if (this.debug) {
+        performance.mark(name + "_start");
+      }
+      task().then((result) => {
+        resolve(result);
+        if (this.debug) {
+          performance.mark(name + "_stop");
+          performance.measure(description, name + "_start", name + "_stop");
+        }
+      }).catch((err) => reject(err));
     }
     this.workerCount--;
   }
@@ -402,6 +423,31 @@ function getStackTrace(belowFn) {
 
 // src/utils/uniqueId.ts
 var uniqueId = ((counter) => (str = "") => `${str}${++counter}`)(0);
+var SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+function normalizeDirectory(directory) {
+  if (!SLASHES.has(directory[directory.length - 1])) {
+    return `${directory}/`;
+  }
+  return directory;
+}
+function getLocation(path, cwd) {
+  let location = path;
+  if (cwd) {
+    const require2 = mod.createRequire(normalizeDirectory(cwd));
+    location = require2.resolve(path);
+  }
+  return location;
+}
+async function importModule(path, cwd) {
+  try {
+    const location = getLocation(path, cwd);
+    const module = await import(pathToFileURL(location).href);
+    return module?.default ?? module;
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
 
 // src/utils/throttle.ts
 var throttle = (fn, delay) => {
@@ -430,108 +476,85 @@ var throttle = (fn, delay) => {
   ];
 };
 
-// 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;
-    }
-  }
-  getCache(id) {
-    return this.cache.get(id);
-  }
-  getCacheByPath(path) {
-    let cache;
-    this.cache.forEach((item) => {
-      if (item.file.path === path) {
-        cache = item;
-      }
-    });
-    return cache;
-  }
-  get files() {
-    const files = [];
-    this.cache.forEach((item) => {
-      files.push(item.file);
-    });
-    return files;
+// 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 || [];
   }
-  get cachedFiles() {
-    const files = [];
-    this.cache.forEach((item) => {
-      files.push(item);
-    });
-    return files;
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  async add(file) {
-    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
-    this.cache.set(cacheItem.id, cacheItem);
-    if (this.queue) {
-      await this.queue.run(async () => {
-        await this.task?.(cacheItem.id, file);
-      });
+};
+function createLogger(spinner) {
+  const log = (message) => {
+    if (message && spinner) {
+      spinner.text = message;
     }
-    return file;
-  }
-  addOrAppend(file) {
-    if (!file.path.endsWith(file.fileName)) ;
-    const previousCache = this.getCacheByPath(file.path);
-    if (previousCache) {
-      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
-      if (sourceAlreadyExists) {
-        return Promise.resolve(file);
-      }
-      this.cache.delete(previousCache.id);
-      return this.add({
-        ...file,
-        source: `${previousCache.file.source}
-${file.source}`,
-        imports: [...previousCache.file.imports || [], ...file.imports || []],
-        exports: [...previousCache.file.exports || [], ...file.exports || []]
-      });
+  };
+  const error = (message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
     }
-    return this.add(file);
-  }
-  setStatus(id, status) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+  };
+  const warn = (message) => {
+    if (message && spinner) {
+      spinner.warn(pc2.yellow(message));
+    }
+  };
+  const info = (message) => {
+    if (message && spinner) {
+      spinner.info(message);
     }
-    cacheItem.status = status;
-    this.cache.set(id, cacheItem);
+  };
+  const logger = {
+    log,
+    error,
+    warn,
+    info,
+    spinner
+  };
+  return logger;
+}
+function canLogHierarchy(input, compareTo) {
+  if (input === "stacktrace") {
+    return canLogHierarchy("info", compareTo);
   }
-  get(id) {
-    const cacheItem = this.getCache(id);
-    return cacheItem?.file;
+  return input === compareTo;
+}
+var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
+function randomColour(text, colours = defaultColours) {
+  if (!text) {
+    return "white";
   }
-  remove(id) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
-    }
-    this.setStatus(id, "removed");
+  const random = seedrandom(text);
+  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
+  return colour;
+}
+function randomPicoColour(text, colors = defaultColours) {
+  const colours = pc2.createColors(true);
+  if (!text) {
+    return colours.white(text);
   }
-  async write(...params) {
-    if (this.queue) {
-      return this.queue.run(async () => {
-        return write(...params);
-      });
-    }
-    return write(...params);
+  const colour = randomColour(text, colors);
+  const isDark = colour.includes("dark");
+  const key = colour.replace("dark", "").toLowerCase();
+  const formatter = colours[key];
+  if (isDark) {
+    return pc2.bold(formatter(text));
   }
-  async read(...params) {
-    if (this.queue) {
-      return this.queue.run(async () => {
-        return read(...params);
-      });
-    }
-    return read(...params);
+  if (typeof formatter !== "function") {
+    throw new Error("Formatter for picoColor is not of type function/Formatter");
   }
-};
+  return formatter(text);
+}
 function writeIndexes(root, options = {}) {
   const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
   if (!tree) {
@@ -587,9 +610,10 @@ function combineFiles(files) {
       acc[prevIndex] = {
         ...curr,
         source: prev.source && curr.source ? `${prev.source}
-${curr.source}` : "'",
+${curr.source}` : "",
         imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
+        exports: [...prev.exports || [], ...curr.exports || []],
+        env: { ...prev.env || {}, ...curr.env || {} }
       };
     } else {
       acc.push(curr);
@@ -597,9 +621,10 @@ ${curr.source}` : "'",
     return acc;
   }, []);
 }
+var extensions = [".js", ".ts"];
 function getFileSource(file) {
   let { source } = file;
-  if (!file.fileName.endsWith(".ts")) {
+  if (!extensions.some((extension) => file.fileName.endsWith(extension))) {
     return file.source;
   }
   const imports = [];
@@ -646,6 +671,7 @@ function getFileSource(file) {
     return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
   }, []);
   const exportSource = print(exportNodes);
+  source = getEnvSource(source, file.env);
   if (importSource) {
     source = `${importSource}
 ${source}`;
@@ -656,6 +682,133 @@ ${source}`;
   }
   return source;
 }
+function searchAndReplace(options) {
+  const { text, replaceBy, prefix = "", key } = options;
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, "g")
+  ];
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy);
+  }, text);
+}
+function getEnvSource(source, env) {
+  if (!env) {
+    return source;
+  }
+  const keys = Object.keys(env);
+  if (!keys.length) {
+    return source;
+  }
+  return keys.reduce((prev, key) => {
+    const environmentValue = env[key];
+    const replaceBy = environmentValue ? `'${environmentValue.replaceAll('"', "")?.replaceAll("'", "")}'` : "undefined";
+    if (key.toUpperCase() !== key) {
+      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).*
+`, "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;
+    }
+  }
+  get extensions() {
+    return extensions;
+  }
+  get files() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
+  }
+  async add(file) {
+    const resolvedFile = { id: crypto.randomUUID(), ...file };
+    this.cache.set(resolvedFile.path, [resolvedFile]);
+    if (this.queue) {
+      await this.queue.run(async () => {
+        await this.task?.(resolvedFile);
+      });
+    }
+    return resolvedFile;
+  }
+  addOrAppend(file) {
+    const previousCaches = this.cache.get(file.path);
+    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+    if (previousCache) {
+      const sourceAlreadyExists = file.source && previousCache.source.includes(file.source);
+      if (sourceAlreadyExists) {
+        return Promise.resolve(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);
+  }
+  append(path, file) {
+    const previousFiles = this.cache.get(path) || [];
+    this.cache.set(path, [...previousFiles, file]);
+  }
+  getCacheByUUID(UUID) {
+    let cache;
+    this.cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
+  }
+  get(path) {
+    return this.cache.get(path);
+  }
+  remove(path) {
+    const cacheItem = this.get(path);
+    if (!cacheItem) {
+      return;
+    }
+    this.cache.delete(path);
+  }
+  async write(...params) {
+    if (this.queue) {
+      return this.queue.run(async () => {
+        return write(...params);
+      });
+    }
+    return write(...params);
+  }
+  async read(...params) {
+    if (this.queue) {
+      return this.queue.run(async () => {
+        return read(...params);
+      });
+    }
+    return read(...params);
+  }
+};
 function createPlugin(factory) {
   return (options) => {
     const plugin = factory(options);
@@ -670,67 +823,69 @@ function createPlugin(factory) {
     return plugin;
   };
 }
-var name = "core";
+var pluginName = "core";
 var definePlugin = createPlugin((options) => {
-  const { fileManager, resolvePath, resolveName, load } = options;
-  const api = {
-    get config() {
-      return options.config;
-    },
-    fileManager,
-    async addFile(...files) {
-      const trace = getStackTrace();
-      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
-        if (a.name.length < b.name.length) {
-          return 1;
-        }
-        if (a.name.length > b.name.length) {
-          return -1;
-        }
-        return 0;
-      });
-      const pluginName = plugins?.[0]?.name;
-      return Promise.all(
-        files.map((file) => {
-          const fileWithMeta = {
-            ...file,
-            meta: {
-              ...file.meta || {},
-              pluginName
-            }
-          };
-          if (file.override) {
-            return fileManager.add(fileWithMeta);
-          }
-          return fileManager.addOrAppend(fileWithMeta);
-        })
-      );
-    },
-    resolvePath,
-    resolveName: (params) => {
-      const name2 = resolveName(params);
-      return transformReservedWord(name2);
-    },
-    load,
-    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
-  };
+  const { fileManager, resolvePath, resolveName, load, logger } = options;
   return {
-    name,
+    name: pluginName,
     options,
-    api,
+    api() {
+      return {
+        get config() {
+          return options.config;
+        },
+        logger,
+        fileManager,
+        async addFile(...files) {
+          const trace = getStackTrace();
+          const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
+            if (a.name.length < b.name.length) {
+              return 1;
+            }
+            if (a.name.length > b.name.length) {
+              return -1;
+            }
+            return 0;
+          });
+          const pluginName2 = plugins?.[0]?.name;
+          return Promise.all(
+            files.map((file) => {
+              const fileWithMeta = {
+                ...file,
+                meta: {
+                  ...file.meta || {},
+                  pluginName: pluginName2
+                }
+              };
+              if (file.override) {
+                return fileManager.add(fileWithMeta);
+              }
+              return fileManager.addOrAppend(fileWithMeta);
+            })
+          );
+        },
+        resolvePath,
+        resolveName: (params) => {
+          const name = resolveName(params);
+          return transformReservedWord(name);
+        },
+        load,
+        cache: createPluginCache(/* @__PURE__ */ Object.create(null))
+      };
+    },
     resolvePath(fileName) {
       const root = pathParser2.resolve(this.config.root, this.config.output.path);
       return pathParser2.resolve(root, fileName);
     },
-    resolveName(name2) {
-      return name2;
+    resolveName(name) {
+      return name;
     }
   };
 });
 
 // src/managers/pluginManager/ParallelPluginError.ts
 var ParallelPluginError = class extends Error {
-  errors;
+  errors = [];
   pluginManager;
   constructor(message, options) {
     super(message, { cause: options.cause });
@@ -738,14 +893,27 @@ var ParallelPluginError = class extends Error {
     this.errors = options.errors;
     this.pluginManager = options.pluginManager;
   }
+  findError(searchError) {
+    return this.errors.find((error) => {
+      if (error.cause) {
+        if (error.cause.name == searchError.name) {
+          return true;
+        }
+        return !!this.findError(error.cause);
+      }
+      return error.name === searchError.name;
+    })?.cause;
+  }
 };
 
 // src/managers/pluginManager/PluginError.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;
   }
 };
@@ -762,30 +930,46 @@ var hookNames = {
   buildEnd: 1
 };
 var hooks = Object.keys(hookNames);
+var convertKubbUserPluginToKubbPlugin = (plugin, context) => {
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      api
+    };
+  }
+  return null;
+};
 var PluginManager = class {
   plugins;
   fileManager;
   onExecute;
   core;
   queue;
-  executer;
   executed = [];
+  logger;
   constructor(config, options) {
     this.onExecute = options.onExecute?.bind(this);
-    this.queue = new Queue(10);
+    this.logger = options.logger;
+    this.queue = new Queue(100, options.debug);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
-    this.core = definePlugin({
+    const core = definePlugin({
       config,
+      logger: this.logger,
       fileManager: this.fileManager,
       load: this.load,
       resolvePath: this.resolvePath,
-      resolveName: this.resolveName,
-      getExecuter: this.getExecuter.bind(this)
+      resolveName: this.resolveName
     });
-    this.plugins = [this.core, ...config.plugins || []];
-  }
-  getExecuter() {
-    return this.executer;
+    const convertedCore = convertKubbUserPluginToKubbPlugin(core, core.api.call(null));
+    this.core = convertedCore;
+    this.plugins = [this.core, ...config.plugins || []].reduce((prev, plugin) => {
+      const convertedApi = convertKubbUserPluginToKubbPlugin(plugin, convertedCore?.api);
+      if (convertedApi) {
+        return [...prev, convertedApi];
+      }
+      return [...prev, plugin];
+    }, []);
   }
   resolvePath = (params) => {
     if (params.pluginName) {
@@ -824,11 +1008,11 @@ var PluginManager = class {
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginName,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName);
+    const plugin = this.getPlugin(hookName, pluginName2);
     return this.execute({
       strategy: "hookFirst",
       hookName,
@@ -837,11 +1021,11 @@ var PluginManager = class {
     });
   }
   hookForPluginSync({
-    pluginName,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName);
+    const plugin = this.getPlugin(hookName, pluginName2);
     return this.executeSync({
       strategy: "hookFirst",
       hookName,
@@ -926,7 +1110,12 @@ var PluginManager = class {
       }
     }
     const results = await Promise.allSettled(parallelPromises);
-    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    const errors = results.map((result) => {
+      if (isPromiseRejectedResult(result) && result.reason instanceof PluginError) {
+        return result.reason;
+      }
+      return void 0;
+    }).filter(Boolean);
     if (errors.length) {
       throw new ParallelPluginError("Error", { errors, pluginManager: this });
     }
@@ -977,15 +1166,15 @@ var PluginManager = class {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
     return plugins;
   }
-  getPlugin(hookName, pluginName) {
+  getPlugin(hookName, pluginName2) {
     const plugins = [...this.plugins];
-    const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName]);
+    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
     if (!pluginByPluginName) {
       return this.core;
     }
     return pluginByPluginName;
   }
-  addExecuter(executer) {
+  addExecutedToCallStack(executer) {
     this.onExecute?.call(this, executer, this);
     if (executer) {
       this.executed.push(executer);
@@ -1005,38 +1194,35 @@ var PluginManager = class {
     plugin
   }) {
     const hook = plugin[hookName];
+    let output;
     if (!hook) {
       return null;
     }
-    return Promise.resolve().then(() => {
-      this.executer = {
-        strategy,
-        hookName,
-        plugin
-      };
+    const task = Promise.resolve().then(() => {
       if (typeof hook === "function") {
-        const hookResult = hook.apply(this.core.api, parameters);
-        if (isPromise(hookResult)) {
-          return Promise.resolve(hookResult).then((result) => {
-            this.addExecuter({
-              strategy,
-              hookName,
-              plugin
-            });
-            return result;
-          });
+        const possiblePromiseResult = hook.apply(this.core.api, parameters);
+        if (isPromise(possiblePromiseResult)) {
+          return Promise.resolve(possiblePromiseResult);
         }
-        return hookResult;
+        return possiblePromiseResult;
       }
-      this.addExecuter({
+      return hook;
+    }).then((result) => {
+      output = result;
+      return result;
+    }).catch((e) => {
+      this.catcher(e, plugin, hookName);
+      return null;
+    }).finally(() => {
+      this.addExecutedToCallStack({
+        input: parameters,
+        output,
         strategy,
         hookName,
         plugin
       });
-      return hook;
-    }).catch((e) => {
-      this.catcher(e, plugin, hookName);
     });
+    return this.queue.run(() => task);
   }
   /**
    * Run a sync plugin hook and return the result.
@@ -1052,33 +1238,29 @@ var PluginManager = class {
     plugin
   }) {
     const hook = plugin[hookName];
+    let output;
     if (!hook) {
       return null;
     }
     try {
-      this.executer = {
-        strategy,
-        hookName,
-        plugin
-      };
       if (typeof hook === "function") {
         const fn = hook.apply(this.core.api, parameters);
-        this.addExecuter({
-          strategy,
-          hookName,
-          plugin
-        });
+        output = fn;
         return fn;
       }
-      this.addExecuter({
-        strategy,
-        hookName,
-        plugin
-      });
+      output = hook;
       return hook;
     } catch (e) {
       this.catcher(e, plugin, hookName);
       return null;
+    } finally {
+      this.addExecutedToCallStack({
+        input: parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
     }
   }
   catcher(e, plugin, hookName) {
@@ -1100,23 +1282,20 @@ function validatePlugins(plugins, dependedPluginNames) {
   } else {
     pluginNames = dependedPluginNames;
   }
-  pluginNames.forEach((pluginName) => {
-    const exists = plugins.some((plugin) => plugin.name === pluginName);
+  pluginNames.forEach((pluginName2) => {
+    const exists = plugins.some((plugin) => plugin.name === pluginName2);
     if (!exists) {
-      throw new ValidationPluginError(`This plugin depends on the ${pluginName} plugin.`);
+      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
     }
   });
   return true;
 }
 
-// src/managers/pluginManager/SummaryError.ts
-var SummaryError = class extends Error {
-  summary;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  stacktrace: "stacktrace"
 };
 
 // src/build.ts
@@ -1124,7 +1303,7 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logger } = options;
+  const { config, debug, logger = createLogger() } = options;
   try {
     if (!isURL(config.input.path)) {
       await read(config.input.path);
@@ -1135,7 +1314,7 @@ async function build(options) {
   if (config.output.clean) {
     await clean(config.output.path);
   }
-  const queueTask = async (id, file) => {
+  const queueTask = async (file) => {
     const { path } = file;
     let code = getFileSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
@@ -1166,12 +1345,27 @@ async function build(options) {
     if (!executer) {
       return;
     }
-    const { hookName, plugin } = executer;
-    if (config.logLevel === "info" && logger) {
-      logger.log(null, { logLevel: config.logLevel, params: { hookName, pluginName: plugin.name } });
+    const { hookName, plugin, output, input } = executer;
+    const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
+    if (config.logLevel === LogLevel.info && logger?.spinner && input) {
+      if (debug) {
+        logger.info(messsage);
+      } else {
+        logger.spinner.suffixText = messsage;
+      }
+    }
+    if (config.logLevel === LogLevel.stacktrace && logger?.spinner && input) {
+      logger.info(messsage);
+      const logs = [
+        input && `${pc2.bgWhite(`Input`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(input, void 0, 2),
+        output && `${pc2.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output
+      ].filter(Boolean);
+      console.log(logs.join("\n"));
     }
   };
-  const pluginManager = new PluginManager(config, { task: queueTask, onExecute });
+  const pluginManager = new PluginManager(config, { debug, logger, task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1212,6 +1406,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };
+export { FileManager, Generator, LogLevel, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, isURL, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map