@kubb/core 1.2.0 → 1.2.2

package/dist/index.js

@@ -3,12 +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 pc from 'picocolors';
+import pc3 from 'picocolors';
 export { default as pc } from 'picocolors';
+import seedrandom from 'seedrandom';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
@@ -42,7 +44,7 @@ async function write(data, path) {
 }
 
 // src/utils/cache.ts
-function createPluginCache(Store) {
+function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
   return {
     set(id, value) {
       Store[id] = [0, value];
@@ -165,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();
     });
@@ -188,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--;
   }
@@ -483,26 +494,26 @@ var Warning = class extends Error {
   }
 };
 function createLogger(spinner) {
-  const [log] = throttle((message) => {
+  const log = (message) => {
     if (message && spinner) {
       spinner.text = message;
     }
-  }, 100);
-  const [error] = throttle((message) => {
+  };
+  const error = (message) => {
     if (message) {
       throw new Error(message || "Something went wrong");
     }
-  }, 100);
-  const [warn] = throttle((message) => {
+  };
+  const warn = (message) => {
     if (message && spinner) {
-      spinner.warn(pc.yellow(message));
+      spinner.warn(pc3.yellow(message));
     }
-  }, 100);
-  const [info] = throttle((message) => {
+  };
+  const info = (message) => {
     if (message && spinner) {
-      spinner.text = message;
+      spinner.info(message);
     }
-  }, 100);
+  };
   const logger = {
     log,
     error,
@@ -512,6 +523,38 @@ function createLogger(spinner) {
   };
   return logger;
 }
+function canLogHierarchy(input, compareTo) {
+  if (input === "stacktrace") {
+    return canLogHierarchy("info", compareTo);
+  }
+  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";
+  }
+  const random = seedrandom(text);
+  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
+  return colour;
+}
+function randomPicoColour(text, colors = defaultColours) {
+  const colours = pc3.createColors(true);
+  if (!text) {
+    return colours.white(text);
+  }
+  const colour = randomColour(text, colors);
+  const isDark = colour.includes("dark");
+  const key = colour.replace("dark", "").toLowerCase();
+  const formatter = colours[key];
+  if (isDark) {
+    return pc3.bold(formatter(text));
+  }
+  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) {
@@ -567,7 +610,7 @@ 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 || []],
         env: { ...prev.env || {}, ...curr.env || {} }
@@ -688,82 +731,66 @@ var FileManager = class {
       this.queue = options.queue;
     }
   }
-  getCache(id) {
-    return this.cache.get(id);
-  }
   get extensions() {
     return extensions;
   }
-  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;
-  }
-  get cachedFiles() {
-    const files = [];
-    this.cache.forEach((item) => {
-      files.push(item);
+      files.push(...item.flat(1));
     });
     return files;
   }
   async add(file) {
-    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
-    this.cache.set(cacheItem.id, cacheItem);
+    const resolvedFile = { id: crypto.randomUUID(), ...file };
+    this.cache.set(resolvedFile.path, [resolvedFile]);
     if (this.queue) {
       await this.queue.run(async () => {
-        await this.task?.(cacheItem.id, file);
+        await this.task?.(resolvedFile);
       });
     }
-    return file;
+    return resolvedFile;
   }
   addOrAppend(file) {
-    if (!file.path.endsWith(file.fileName)) ;
-    const previousCache = this.getCacheByPath(file.path);
+    const previousCaches = this.cache.get(file.path);
+    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
     if (previousCache) {
-      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
+      const sourceAlreadyExists = file.source && previousCache.source.includes(file.source);
       if (sourceAlreadyExists) {
-        return Promise.resolve(file);
+        return Promise.resolve(previousCache);
       }
-      this.cache.delete(previousCache.id);
+      this.cache.delete(previousCache.path);
       return this.add({
         ...file,
-        source: `${previousCache.file.source}
-${file.source}`,
-        imports: [...previousCache.file.imports || [], ...file.imports || []],
-        exports: [...previousCache.file.exports || [], ...file.exports || []]
+        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);
   }
-  setStatus(id, status) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
-    }
-    cacheItem.status = status;
-    this.cache.set(id, cacheItem);
+  append(path, file) {
+    const previousFiles = this.cache.get(path) || [];
+    this.cache.set(path, [...previousFiles, file]);
   }
-  get(id) {
-    const cacheItem = this.getCache(id);
-    return cacheItem?.file;
+  getCacheByUUID(UUID) {
+    let cache;
+    this.cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
   }
-  remove(id) {
-    const cacheItem = this.getCache(id);
+  get(path) {
+    return this.cache.get(path);
+  }
+  remove(path) {
+    const cacheItem = this.get(path);
     if (!cacheItem) {
       return;
     }
-    this.setStatus(id, "removed");
+    this.cache.delete(path);
   }
   async write(...params) {
     if (this.queue) {
@@ -799,52 +826,53 @@ function createPlugin(factory) {
 var pluginName = "core";
 var definePlugin = createPlugin((options) => {
   const { fileManager, resolvePath, resolveName, load, logger } = 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 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,
-    logger,
-    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
-  };
   return {
     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()
+      };
+    },
     resolvePath(fileName) {
       const root = pathParser2.resolve(this.config.root, this.config.output.path);
       return pathParser2.resolve(root, fileName);
@@ -902,33 +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.logger = options.logger;
-    this.queue = new Queue(10);
+    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) {
@@ -949,7 +990,7 @@ var PluginManager = class {
         pluginName: params.pluginName,
         hookName: "resolveName",
         parameters: [params.name]
-      });
+      }) || params.name;
     }
     return this.hookFirstSync({
       hookName: "resolveName",
@@ -1133,7 +1174,7 @@ var PluginManager = class {
     }
     return pluginByPluginName;
   }
-  addExecuter(executer) {
+  addExecutedToCallStack(executer) {
     this.onExecute?.call(this, executer, this);
     if (executer) {
       this.executed.push(executer);
@@ -1153,39 +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({
-        strategy,
-        hookName,
-        plugin
-      });
       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 this.queue.run(() => task);
   }
   /**
    * Run a sync plugin hook and return the result.
@@ -1201,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) {
@@ -1258,23 +1291,35 @@ function validatePlugins(plugins, dependedPluginNames) {
   return true;
 }
 
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  stacktrace: "stacktrace"
+};
+
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logger = createLogger() } = options;
+  const { config, debug, logger = createLogger() } = options;
   try {
     if (!isURL(config.input.path)) {
       await read(config.input.path);
     }
   } catch (e) {
-    throw new Error("Cannot read file/URL defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
+    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),
+      {
+        cause: e
+      }
+    );
   }
   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({
@@ -1305,13 +1350,27 @@ async function build(options) {
     if (!executer) {
       return;
     }
-    const { hookName, plugin } = executer;
-    if (config.logLevel === "info") {
-      const messsage = `\u{1FA82} Executing ${hookName || "unknown"}(${pc.yellow(plugin.name || "unknown")})`;
-      logger.log(messsage);
+    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 && `${pc3.bgWhite(`Input`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(input, void 0, 2),
+        output && `${pc3.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output
+      ].filter(Boolean);
+      console.log(logs.join("\n"));
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask, onExecute });
+  const pluginManager = new PluginManager(config, { debug, logger, task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1326,7 +1385,9 @@ async function build(options) {
 }
 
 // src/config.ts
-var defineConfig = (options) => options;
+function defineConfig(options) {
+  return options;
+}
 
 // src/generators/Generator.ts
 var Generator = class {
@@ -1352,6 +1413,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, ValidationPluginError, Warning, build, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defineConfig, extensions, getEncodedText, getFileSource, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, isURL, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, 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