@kubb/core 1.1.13 → 1.2.1

package/dist/index.cjs

@@ -6,8 +6,13 @@ var crypto = require('crypto');
 var fs = require('fs-extra');
 var pathParser2 = require('path');
 var changeCase = require('change-case');
+var perf_hooks = require('perf_hooks');
 var rimraf = require('rimraf');
 var dirTree = require('directory-tree');
+var mod = require('module');
+var url = require('url');
+var pc2 = require('picocolors');
+var seedrandom = require('seedrandom');
 var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -16,6 +21,9 @@ var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var pathParser2__default = /*#__PURE__*/_interopDefault(pathParser2);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
+var mod__default = /*#__PURE__*/_interopDefault(mod);
+var pc2__default = /*#__PURE__*/_interopDefault(pc2);
+var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
 
 // src/managers/fileManager/FileManager.ts
 
@@ -23,6 +31,12 @@ var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 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__default.default.dirname(pathParser2__default.default.resolve(path));
   await fs__default.default.mkdir(passedPath, { recursive: true });
@@ -165,18 +179,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__default.default.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();
     });
@@ -188,8 +202,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) {
+        perf_hooks.performance.mark(name + "_start");
+      }
+      task().then((result) => {
+        resolve(result);
+        if (this.debug) {
+          perf_hooks.performance.mark(name + "_stop");
+          perf_hooks.performance.measure(description, name + "_start", name + "_stop");
+        }
+      }).catch((err) => reject(err));
     }
     this.workerCount--;
   }
@@ -412,6 +435,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__default.default.createRequire(normalizeDirectory(cwd));
+    location = require2.resolve(path);
+  }
+  return location;
+}
+async function importModule(path, cwd) {
+  try {
+    const location = getLocation(path, cwd);
+    const module = await import(url.pathToFileURL(location).href);
+    return module?.default ?? module;
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
 
 // src/utils/throttle.ts
 var throttle = (fn, delay) => {
@@ -440,108 +488,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__default.default.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__default.default.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__default.default(text);
+  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
+  return colour;
+}
+function randomPicoColour(text, colors = defaultColours) {
+  const colours = pc2__default.default.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__default.default.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) {
@@ -597,9 +622,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);
@@ -607,9 +633,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 = [];
@@ -656,6 +683,7 @@ function getFileSource(file) {
     return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
   }, []);
   const exportSource = tsCodegen.print(exportNodes);
+  source = getEnvSource(source, file.env);
   if (importSource) {
     source = `${importSource}
 ${source}`;
@@ -666,6 +694,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__default.default.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);
@@ -680,67 +835,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__default.default.resolve(this.config.root, this.config.output.path);
       return pathParser2__default.default.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 });
@@ -748,14 +905,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;
   }
 };
@@ -772,30 +942,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) {
@@ -834,11 +1020,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,
@@ -847,11 +1033,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,
@@ -936,7 +1122,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 });
     }
@@ -987,15 +1178,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);
@@ -1015,38 +1206,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.
@@ -1062,33 +1250,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) {
@@ -1110,23 +1294,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
@@ -1134,7 +1315,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);
@@ -1145,7 +1326,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({
@@ -1176,12 +1357,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__default.default.bgWhite(`Input`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(input, void 0, 2),
+        output && `${pc2__default.default.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",
@@ -1222,8 +1418,13 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
+Object.defineProperty(exports, 'pc', {
+  enumerable: true,
+  get: function () { return pc2__default.default; }
+});
 exports.FileManager = FileManager;
 exports.Generator = Generator;
+exports.LogLevel = LogLevel;
 exports.ParallelPluginError = ParallelPluginError;
 exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
@@ -1232,26 +1433,39 @@ exports.SchemaGenerator = SchemaGenerator;
 exports.SummaryError = SummaryError;
 exports.TreeNode = TreeNode;
 exports.ValidationPluginError = ValidationPluginError;
+exports.Warning = Warning;
 exports.build = build;
+exports.canLogHierarchy = canLogHierarchy;
 exports.clean = clean;
 exports.combineFiles = combineFiles;
 exports.createJSDocBlockText = createJSDocBlockText;
+exports.createLogger = createLogger;
 exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
+exports.defaultColours = defaultColours;
 exports.defineConfig = defineConfig;
+exports.extensions = extensions;
 exports.getEncodedText = getEncodedText;
 exports.getFileSource = getFileSource;
+exports.getLocation = getLocation;
 exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
 exports.getStackTrace = getStackTrace;
 exports.getUniqueName = getUniqueName;
 exports.hooks = hooks;
+exports.importModule = importModule;
 exports.isPromise = isPromise;
+exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
+exports.isPromiseRejectedResult = isPromiseRejectedResult;
 exports.isURL = isURL;
-exports.name = name;
+exports.name = pluginName;
 exports.nameSorter = nameSorter;
+exports.normalizeDirectory = normalizeDirectory;
 exports.objectToParameters = objectToParameters;
+exports.pluginName = pluginName;
+exports.randomColour = randomColour;
+exports.randomPicoColour = randomPicoColour;
 exports.read = read;
 exports.renderTemplate = renderTemplate;
 exports.throttle = throttle;