@kubb/core 1.2.0 → 1.2.1

package/dist/index.cjs

@@ -6,11 +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 pc = require('picocolors');
+var pc2 = require('picocolors');
+var seedrandom = require('seedrandom');
 var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -20,7 +22,8 @@ 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 pc__default = /*#__PURE__*/_interopDefault(pc);
+var pc2__default = /*#__PURE__*/_interopDefault(pc2);
+var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
 
 // src/managers/fileManager/FileManager.ts
 
@@ -176,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();
     });
@@ -199,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--;
   }
@@ -494,26 +506,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__default.default.yellow(message));
+      spinner.warn(pc2__default.default.yellow(message));
     }
-  }, 100);
-  const [info] = throttle((message) => {
+  };
+  const info = (message) => {
     if (message && spinner) {
-      spinner.text = message;
+      spinner.info(message);
     }
-  }, 100);
+  };
   const logger = {
     log,
     error,
@@ -523,6 +535,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__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);
+  }
+  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));
+  }
+  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) {
@@ -578,7 +622,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 || {} }
@@ -699,82 +743,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__default.default.randomUUID(), file, status: "new" };
-    this.cache.set(cacheItem.id, cacheItem);
+    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?.(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]);
+  }
+  getCacheByUUID(UUID) {
+    let cache;
+    this.cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
   }
-  get(id) {
-    const cacheItem = this.getCache(id);
-    return cacheItem?.file;
+  get(path) {
+    return this.cache.get(path);
   }
-  remove(id) {
-    const cacheItem = this.getCache(id);
+  remove(path) {
+    const cacheItem = this.get(path);
     if (!cacheItem) {
       return;
     }
-    this.setStatus(id, "removed");
+    this.cache.delete(path);
   }
   async write(...params) {
     if (this.queue) {
@@ -810,52 +838,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(/* @__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);
@@ -913,33 +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.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) {
@@ -1144,7 +1186,7 @@ var PluginManager = class {
     }
     return pluginByPluginName;
   }
-  addExecuter(executer) {
+  addExecutedToCallStack(executer) {
     this.onExecute?.call(this, executer, this);
     if (executer) {
       this.executed.push(executer);
@@ -1164,39 +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({
-        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.
@@ -1212,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) {
@@ -1269,12 +1303,19 @@ 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);
@@ -1285,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({
@@ -1316,13 +1357,27 @@ async function build(options) {
     if (!executer) {
       return;
     }
-    const { hookName, plugin } = executer;
-    if (config.logLevel === "info") {
-      const messsage = `\u{1FA82} Executing ${hookName || "unknown"}(${pc__default.default.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 && `${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, { logger, task: queueTask, onExecute });
+  const pluginManager = new PluginManager(config, { debug, logger, task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1365,10 +1420,11 @@ var src_default = build;
 
 Object.defineProperty(exports, 'pc', {
   enumerable: true,
-  get: function () { return pc__default.default; }
+  get: function () { return pc2__default.default; }
 });
 exports.FileManager = FileManager;
 exports.Generator = Generator;
+exports.LogLevel = LogLevel;
 exports.ParallelPluginError = ParallelPluginError;
 exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
@@ -1379,6 +1435,7 @@ exports.TreeNode = TreeNode;
 exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;
+exports.canLogHierarchy = canLogHierarchy;
 exports.clean = clean;
 exports.combineFiles = combineFiles;
 exports.createJSDocBlockText = createJSDocBlockText;
@@ -1386,6 +1443,7 @@ 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;
@@ -1406,6 +1464,8 @@ 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;