@kubb/core 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -7,19 +7,37 @@ var pathParser2 = require('path');
 var fs = require('fs');
 var rimraf = require('rimraf');
 var dirTree = require('directory-tree');
-var uuid = require('uuid');
-var uniq = require('lodash.uniq');
+var crypto = require('crypto');
 var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pathParser2__default = /*#__PURE__*/_interopDefault(pathParser2);
-var rimraf__default = /*#__PURE__*/_interopDefault(rimraf);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
-var uniq__default = /*#__PURE__*/_interopDefault(uniq);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
 module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('out.js', document.baseURI).href)));
 
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.pluginManager = options.pluginManager;
+  }
+};
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors;
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.errors = options.errors;
+    this.pluginManager = options.pluginManager;
+  }
+};
+
 // src/utils/isPromise.ts
 function isPromise(result) {
   return typeof result?.then === "function";
@@ -215,15 +233,7 @@ function renderTemplate(template, data = void 0) {
   });
 }
 async function clean(path) {
-  return new Promise((resolve, reject) => {
-    rimraf__default.default(path, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(true);
-      }
-    });
-  });
+  return rimraf.rimraf(path);
 }
 var TreeNode = class {
   data;
@@ -392,12 +402,28 @@ var reservedWords = [
   "valueOf"
 ];
 function transformReservedWord(word) {
-  if (reservedWords.includes(word)) {
+  if (word && reservedWords.includes(word)) {
     return `_${word}`;
   }
   return word;
 }
 
+// src/utils/getStackTrace.ts
+function getStackTrace(belowFn) {
+  const oldLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = Infinity;
+  const dummyObject = {};
+  const v8Handler = Error.prepareStackTrace;
+  Error.prepareStackTrace = function prepareStackTrace(dummyObject2, v8StackTrace2) {
+    return v8StackTrace2;
+  };
+  Error.captureStackTrace(dummyObject, belowFn || getStackTrace);
+  const v8StackTrace = dummyObject.stack;
+  Error.prepareStackTrace = v8Handler;
+  Error.stackTraceLimit = oldLimit;
+  return v8StackTrace;
+}
+
 // src/plugin.ts
 function createPlugin(factory) {
   return (options) => {
@@ -422,7 +448,30 @@ var definePlugin = createPlugin((options) => {
     },
     fileManager,
     async addFile(...files) {
-      return Promise.all(files.map((file) => file.override ? fileManager.add(file) : fileManager.addOrAppend(file)));
+      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) => {
@@ -475,7 +524,7 @@ var FileManager = class {
     return files;
   }
   async add(file) {
-    const cacheItem = { id: uuid.v4(), file, status: "new" };
+    const cacheItem = { id: crypto__default.default.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
     if (this.queue) {
       await this.queue.run(async () => {
@@ -529,133 +578,6 @@ ${file.source}`,
     return read(...params);
   }
 };
-function writeIndexes(root, options) {
-  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
-  if (!tree) {
-    return void 0;
-  }
-  const fileReducer = (files2, item) => {
-    if (!item.children) {
-      return [];
-    }
-    if (item.children?.length > 1) {
-      const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
-      const exports = item.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
-        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-        if (importPath.includes("index") && path.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path,
-        fileName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      item.children?.forEach((child) => {
-        const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path,
-          fileName: "index.ts",
-          source: "",
-          exports: [{ path: importPath }]
-        });
-      });
-    }
-    item.children.forEach((childItem) => {
-      fileReducer(files2, childItem);
-    });
-    return files2;
-  };
-  const files = fileReducer([], tree);
-  return files;
-}
-function combineFiles(files) {
-  return files.filter(Boolean).reduce((acc, curr) => {
-    if (!curr) {
-      return acc;
-    }
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex];
-      acc[prevIndex] = {
-        ...curr,
-        source: `${prev.source}
-${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
-      };
-    } else {
-      acc.push(curr);
-    }
-    return acc;
-  }, []);
-}
-function getFileSource(file) {
-  let { source } = file;
-  if (!file.fileName.endsWith(".ts")) {
-    return file.source;
-  }
-  const imports = [];
-  const exports = [];
-  file.imports?.forEach((curr) => {
-    const exists = imports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      imports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? uniq__default.default(curr.name) : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
-      imports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = uniq__default.default([...exists.name, ...curr.name]);
-      }
-    }
-  });
-  file.exports?.forEach((curr) => {
-    const exists = exports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      exports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? uniq__default.default(curr.name) : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
-      exports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = uniq__default.default([...exists.name, ...curr.name]);
-      }
-    }
-  });
-  const importNodes = imports.reduce((prev, curr) => {
-    return [...prev, tsCodegen.createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
-  }, []);
-  const importSource = tsCodegen.print(importNodes);
-  const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
-  }, []);
-  const exportSource = tsCodegen.print(exportNodes);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -672,13 +594,13 @@ var hooks = Object.keys(hookNames);
 var PluginManager = class {
   plugins;
   fileManager;
-  logger;
-  config;
+  onExecute;
   core;
   queue;
+  executer;
+  executed = [];
   constructor(config, options) {
-    this.logger = options.logger;
-    this.config = config;
+    this.onExecute = options.onExecute;
     this.queue = new Queue(10);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     this.core = definePlugin({
@@ -686,10 +608,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       load: this.load,
       resolvePath: this.resolvePath,
-      resolveName: this.resolveName
+      resolveName: this.resolveName,
+      getExecuter: this.getExecuter.bind(this)
     });
     this.plugins = [this.core, ...config.plugins || []];
   }
+  getExecuter() {
+    return this.executer;
+  }
   resolvePath = (params) => {
     if (params.pluginName) {
       return this.hookForPluginSync({
@@ -732,7 +658,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.run({
+    return this.execute({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -745,7 +671,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.runSync({
+    return this.executeSync({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -768,7 +694,7 @@ var PluginManager = class {
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.run({
+        return this.execute({
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -791,7 +717,7 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = this.runSync({
+      result = this.executeSync({
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -813,18 +739,25 @@ var PluginManager = class {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.run({
+        await this.execute({
           strategy: "hookParallel",
           hookName,
           parameters,
           plugin
         });
       } else {
-        const promise = this.run({ strategy: "hookParallel", hookName, parameters, plugin });
-        parallelPromises.push(promise);
+        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+        if (promise) {
+          parallelPromises.push(promise);
+        }
       }
     }
-    return Promise.all(parallelPromises);
+    const results = await Promise.allSettled(parallelPromises);
+    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (errors.length) {
+      throw new ParallelPluginError("Error", { errors, pluginManager: this });
+    }
+    return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   // chains, reduces returned value, handling the reduced value as the first hook argument
   hookReduceArg0({
@@ -835,14 +768,15 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(
-        (argument02) => this.run({
+      promise = promise.then((argument02) => {
+        const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
           parameters: [argument02, ...rest],
           plugin
-        }).then((result) => reduce.call(this.core.api, argument02, result, plugin))
-      );
+        });
+        return value;
+      }).then((result) => reduce.call(this.core.api, argument0, result, plugin));
     }
     return promise;
   }
@@ -851,7 +785,7 @@ var PluginManager = class {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        () => this.run({
+        () => this.execute({
           strategy: "hookSeq",
           hookName,
           parameters,
@@ -869,13 +803,16 @@ var PluginManager = class {
     const plugins = [...this.plugins];
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName]);
     if (!pluginByPluginName) {
-      if (this.config.logLevel === "warn" && this.logger?.spinner) {
-        this.logger.spinner.info(`Plugin hook with ${hookName} not found for plugin ${pluginName}`);
-      }
       return this.core;
     }
     return pluginByPluginName;
   }
+  addExecuter(executer) {
+    this.onExecute?.call(this, executer);
+    if (executer) {
+      this.executed.push(executer);
+    }
+  }
   /**
    * Run an async plugin hook and return the result.
    * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
@@ -883,36 +820,42 @@ var PluginManager = class {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  run({
+  execute({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     return Promise.resolve().then(() => {
-      if (typeof hook !== "function") {
-        return hook;
-      }
-      if (this.config.logLevel === "info" && this.logger?.spinner) {
-        this.logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`;
-      }
-      const hookResult = hook.apply(this.core.api, parameters);
-      if (!hookResult?.then) {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      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;
+          });
         }
         return hookResult;
       }
-      return Promise.resolve(hookResult).then((result) => {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
-        }
-        return result;
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
       });
+      return hook;
     }).catch((e) => {
       this.catcher(e, plugin, hookName);
     });
@@ -924,18 +867,37 @@ var PluginManager = class {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  runSync({
+  executeSync({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     try {
-      if (typeof hook !== "function") {
-        return hook;
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      if (typeof hook === "function") {
+        const fn = hook.apply(this.core.api, parameters);
+        this.addExecuter({
+          strategy,
+          hookName,
+          plugin
+        });
+        return fn;
       }
-      return hook.apply(this.core.api, parameters);
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
+      });
+      return hook;
     } catch (e) {
       this.catcher(e, plugin, hookName);
       return null;
@@ -944,7 +906,7 @@ var PluginManager = class {
   catcher(e, plugin, hookName) {
     const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
 `;
-    throw new Error(text, { cause: e });
+    throw new PluginError(text, { cause: e, pluginManager: this });
   }
 };
 function noReturn() {
@@ -968,6 +930,133 @@ function validatePlugins(plugins, dependedPluginNames) {
   });
   return true;
 }
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
+  }
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
+    }
+    if (item.children?.length > 1) {
+      const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+      const exports = item.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        fileName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          fileName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    item.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    if (!curr) {
+      return acc;
+    }
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: `${prev.source}
+${curr.source}`,
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const exists = imports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
+      exports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  const importSource = tsCodegen.print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = tsCodegen.print(exportNodes);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
@@ -976,8 +1065,13 @@ async function transformReducer(_previousCode, result, _plugin) {
   }
   return result;
 }
-async function buildImplementation(options) {
+async function build(options) {
   const { config, logger } = options;
+  try {
+    await read(config.input.path);
+  } catch (e) {
+    throw new Error("Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
+  }
   if (config.output.clean) {
     await clean(config.output.path);
   }
@@ -1005,7 +1099,17 @@ async function buildImplementation(options) {
       }
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask });
+  const onExecute = (executer) => {
+    if (!executer) {
+      return;
+    }
+    const { strategy, hookName, plugin } = executer;
+    if (config.logLevel === "info" && logger?.spinner) {
+      logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
+`;
+    }
+  };
+  const pluginManager = new PluginManager(config, { task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1016,19 +1120,7 @@ async function buildImplementation(options) {
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) };
-}
-function build(options) {
-  return new Promise(async (resolve, reject) => {
-    try {
-      const output = await buildImplementation(options);
-      setTimeout(() => {
-        resolve(output);
-      }, 500);
-    } catch (e) {
-      reject(e);
-    }
-  });
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager };
 }
 
 // src/config.ts
@@ -1060,6 +1152,8 @@ var src_default = build;
 
 exports.FileManager = FileManager;
 exports.Generator = Generator;
+exports.ParallelPluginError = ParallelPluginError;
+exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
 exports.Queue = Queue;
 exports.SchemaGenerator = SchemaGenerator;
@@ -1077,6 +1171,7 @@ exports.getEncodedText = getEncodedText;
 exports.getFileSource = getFileSource;
 exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
+exports.getStackTrace = getStackTrace;
 exports.getUniqueName = getUniqueName;
 exports.hooks = hooks;
 exports.isPromise = isPromise;
@@ -1091,5 +1186,3 @@ exports.transformReservedWord = transformReservedWord;
 exports.validatePlugins = validatePlugins;
 exports.write = write;
 exports.writeIndexes = writeIndexes;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map