@kubb/core 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/index.js

@@ -2,9 +2,9 @@ import { createRequire } from 'module';
 import pathParser2 from 'path';
 import { promises } from 'fs';
 import rimraf from 'rimraf';
-import uniq from 'lodash.uniq';
 import { v4 } from 'uuid';
 import dirTree from 'directory-tree';
+import uniq from 'lodash.uniq';
 
 createRequire(import.meta.url);
 
@@ -139,7 +139,7 @@ function nameSorter(a, b) {
 function createJSDocBlockText({ comments }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
-    return void 0;
+    return "";
   }
   const text = filteredComments.reduce((acc, comment) => {
     return `${acc}
@@ -197,6 +197,22 @@ var Queue = class {
   }
 };
 
+// src/utils/getEncodedText.ts
+function getEncodedText(text) {
+  return text ? text.replaceAll("`", "\\`") : "";
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  return template.replace(/{{(.*?)}}/g, (match) => {
+    const value = data[match.split(/{{|}}/).filter(Boolean)[0].trim()];
+    return value || "";
+  });
+}
+
 // src/plugin.ts
 function createPlugin(factory) {
   return (options) => {
@@ -214,7 +230,7 @@ function createPlugin(factory) {
 }
 var name = "core";
 var definePlugin = createPlugin((options) => {
-  const { fileManager, resolveId, load } = options;
+  const { fileManager, resolvePath, resolveName, load } = options;
   const api = {
     get config() {
       return options.config;
@@ -223,7 +239,8 @@ var definePlugin = createPlugin((options) => {
     async addFile(file) {
       return fileManager.addOrAppend(file);
     },
-    resolveId,
+    resolvePath,
+    resolveName,
     load,
     cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
@@ -231,11 +248,14 @@ var definePlugin = createPlugin((options) => {
     name,
     options,
     api,
-    resolveId(fileName, directory) {
+    resolvePath(fileName, directory) {
       if (!directory) {
         return null;
       }
       return pathParser2.resolve(directory, fileName);
+    },
+    resolveName(name2) {
+      return name2;
     }
   };
 });
@@ -261,35 +281,6 @@ var FileManager = class {
     });
     return cache;
   }
-  getSource(file) {
-    if (!file.fileName.endsWith(".ts")) {
-      return file.source;
-    }
-    const imports = [];
-    file.imports?.forEach((curr) => {
-      const exists = imports.find((imp) => imp.path === curr.path);
-      if (!exists) {
-        imports.push(curr);
-        return;
-      }
-      if (exists && Array.isArray(curr.name)) {
-        exists.name = uniq([...exists.name, ...curr.name]);
-      }
-    });
-    const importSource = imports.reduce((prev, curr) => {
-      if (Array.isArray(curr.name)) {
-        return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}{ ${curr.name.join(", ")} } from "${curr.path}";`;
-      }
-      return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}${curr.name} from "${curr.path}";`;
-    }, "");
-    if (importSource) {
-      return `${importSource}
-${file.source}`;
-    }
-    return file.source;
-  }
   get files() {
     const files = [];
     this.cache.forEach((item) => {
@@ -320,26 +311,6 @@ ${file.source}`,
     }
     return this.add(file);
   }
-  combine(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 || []]
-        };
-      } else {
-        acc.push(curr);
-      }
-      return acc;
-    }, []);
-  }
   setStatus(id, status) {
     const cacheItem = this.getCache(id);
     if (!cacheItem) {
@@ -445,12 +416,69 @@ var TreeNode = class {
     return treeNode;
   }
 };
+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 || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  file.imports?.forEach((curr) => {
+    const exists = imports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? uniq(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([...exists.name, ...curr.name]);
+      }
+    }
+  });
+  const importSource = imports.reduce((prev, curr) => {
+    if (Array.isArray(curr.name)) {
+      return `${prev}
+import ${curr.isTypeOnly ? "type " : ""}{ ${curr.name.join(", ")} } from "${curr.path}";`;
+    }
+    return `${prev}
+import ${curr.isTypeOnly ? "type " : ""}${curr.name} from "${curr.path}";`;
+  }, "");
+  if (importSource) {
+    return `${importSource}
+${file.source}`;
+  }
+  return file.source;
+}
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
   validate: 1,
   buildStart: 1,
-  resolveId: 1,
+  resolvePath: 1,
+  resolveName: 1,
   load: 1,
   transform: 1,
   writeFile: 1,
@@ -473,95 +501,196 @@ var PluginManager = class {
       config,
       fileManager: this.fileManager,
       load: this.load,
-      resolveId: this.resolveId
+      resolvePath: this.resolvePath,
+      resolveName: this.resolveName
     });
     this.plugins = [this.core, ...config.plugins || []];
   }
-  resolveId = (params) => {
+  resolvePath = (params) => {
     if (params.pluginName) {
-      return this.hookForPlugin(params.pluginName, "resolveId", [params.fileName, params.directory, params.options]);
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolvePath",
+        parameters: [params.fileName, params.directory, params.options]
+      });
     }
-    return this.hookFirst("resolveId", [params.fileName, params.directory, params.options]);
+    return this.hookFirstSync({
+      hookName: "resolvePath",
+      parameters: [params.fileName, params.directory, params.options]
+    });
+  };
+  resolveName = (params) => {
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolveName",
+        parameters: [params.name]
+      });
+    }
+    return this.hookFirstSync({
+      hookName: "resolveName",
+      parameters: [params.name]
+    });
   };
   load = async (id) => {
-    return this.hookFirst("load", [id]);
+    return this.hookFirst({
+      hookName: "load",
+      parameters: [id]
+    });
   };
-  // run only hook for a specific plugin name
-  hookForPlugin(pluginName, hookName, parameters, skipped) {
+  /**
+   *
+   * Run only hook for a specific plugin name
+   */
+  hookForPlugin({
+    pluginName,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName);
+    return this.run({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+  }
+  hookForPluginSync({
+    pluginName,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName);
+    return this.runSync({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+  }
+  /**
+   *
+   * Chains, first non-null result stops and returns
+   */
+  hookFirst({
+    hookName,
+    parameters,
+    skipped
+  }) {
     let promise = Promise.resolve(null);
-    for (const plugin of this.getSortedPlugins(hookName, pluginName)) {
+    for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.run("hookFirst", hookName, parameters, plugin);
+        return this.run({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        });
       });
     }
     return promise;
   }
-  // chains, first non-null result stops and returns
-  hookFirst(hookName, parameters, skipped) {
-    let promise = Promise.resolve(null);
+  /**
+   *
+   * Chains, first non-null result stops and returns
+   */
+  hookFirstSync({
+    hookName,
+    parameters,
+    skipped
+  }) {
+    let result = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      promise = promise.then((result) => {
-        if (result != null)
-          return result;
-        return this.run("hookFirst", hookName, parameters, plugin);
+      result = this.runSync({
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
       });
+      if (result != null) {
+        break;
+      }
     }
-    return promise;
+    return result;
   }
   // parallel
-  async hookParallel(hookName, parameters) {
+  async hookParallel({
+    hookName,
+    parameters
+  }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.run("hookParallel", hookName, parameters, plugin);
+        await this.run({
+          strategy: "hookParallel",
+          hookName,
+          parameters,
+          plugin
+        });
       } else {
-        const promise = this.run("hookParallel", hookName, parameters, plugin);
+        const promise = this.run({ strategy: "hookParallel", hookName, parameters, plugin });
         parallelPromises.push(promise);
       }
     }
     return Promise.all(parallelPromises);
   }
   // chains, reduces returned value, handling the reduced value as the first hook argument
-  hookReduceArg0(hookName, [argument0, ...rest], reduce) {
+  hookReduceArg0({
+    hookName,
+    parameters,
+    reduce
+  }) {
+    const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        (argument02) => this.run("hookReduceArg0", hookName, [argument02, ...rest], plugin).then(
-          (result) => reduce.call(this.core.api, argument02, result, plugin)
-        )
+        (argument02) => this.run({
+          strategy: "hookReduceArg0",
+          hookName,
+          parameters: [argument02, ...rest],
+          plugin
+        }).then((result) => reduce.call(this.core.api, argument02, result, plugin))
       );
     }
     return promise;
   }
   // chains
-  hookSeq(hookName, parameters) {
+  hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(() => this.run("hookSeq", hookName, parameters, plugin));
+      promise = promise.then(
+        () => this.run({
+          strategy: "hookSeq",
+          hookName,
+          parameters,
+          plugin
+        })
+      );
     }
     return promise.then(noReturn);
   }
-  getSortedPlugins(hookName, pluginName) {
+  getSortedPlugins(_hookName) {
     const plugins = [...this.plugins];
-    if (pluginName) {
-      const pluginsByPluginName = plugins.filter((item) => item.name === pluginName && item[hookName]);
-      if (pluginsByPluginName.length === 0) {
-        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 plugins;
+  }
+  getPlugin(hookName, pluginName) {
+    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 pluginsByPluginName;
+      return this.core;
     }
-    return plugins;
+    return pluginByPluginName;
   }
   /**
    * Run an async plugin hook and return the result.
@@ -570,7 +699,12 @@ var PluginManager = class {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  run(strategy, hookName, parameters, plugin) {
+  run({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
     const hook = plugin[hookName];
     return Promise.resolve().then(() => {
       if (typeof hook !== "function") {
@@ -606,12 +740,21 @@ var PluginManager = class {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  runSync(hookName, parameters, plugin) {
+  runSync({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
     const hook = plugin[hookName];
     try {
+      if (typeof hook !== "function") {
+        return hook;
+      }
       return hook.apply(this.core.api, parameters);
-    } catch (error) {
-      return error;
+    } catch (e) {
+      this.catcher(e, plugin, hookName);
+      return null;
     }
   }
   catcher(e, plugin, hookName) {
@@ -649,43 +792,60 @@ async function transformReducer(_previousCode, result, _plugin) {
   }
   return result;
 }
-async function buildImplementation(options, done) {
+async function buildImplementation(options) {
   const { config, logger } = options;
   if (config.output.clean) {
     await clean(config.output.path);
   }
   const queueTask = async (id, file) => {
     const { path } = file;
-    let code = fileManager.getSource(file);
-    const loadedResult = await pluginManager.hookFirst("load", [path]);
+    let code = getFileSource(file);
+    const loadedResult = await pluginManager.hookFirst({
+      hookName: "load",
+      parameters: [path]
+    });
     if (loadedResult) {
       code = loadedResult;
     }
     if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0("transform", [code, path], transformReducer);
+      const transformedCode = await pluginManager.hookReduceArg0({
+        hookName: "transform",
+        parameters: [code, path],
+        reduce: transformReducer
+      });
       if (config.output.write || config.output.write === void 0) {
-        await pluginManager.hookParallel("writeFile", [transformedCode, path]);
+        await pluginManager.hookParallel({
+          hookName: "writeFile",
+          parameters: [transformedCode, path]
+        });
       }
     }
   };
   const pluginManager = new PluginManager(config, { logger, task: queueTask });
   const { plugins, fileManager } = pluginManager;
-  await pluginManager.hookParallel("validate", [plugins]);
-  await pluginManager.hookParallel("buildStart", [config]);
-  await pluginManager.hookParallel("buildEnd");
-  setTimeout(() => {
-    done({ files: fileManager.files.map((file) => ({ ...file, source: fileManager.getSource(file) })) });
-  }, 500);
+  await pluginManager.hookParallel({
+    hookName: "validate",
+    parameters: [plugins]
+  });
+  await pluginManager.hookParallel({
+    hookName: "buildStart",
+    parameters: [config]
+  });
   pluginManager.fileManager.add({
     path: isURL(config.input.path) ? config.input.path : pathParser2.resolve(config.root, config.input.path),
     fileName: isURL(config.input.path) ? "input" : config.input.path,
     source: isURL(config.input.path) ? config.input.path : await read(pathParser2.resolve(config.root, config.input.path))
   });
+  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 {
-      await buildImplementation(options, resolve);
+      const output = await buildImplementation(options);
+      setTimeout(() => {
+        resolve(output);
+      }, 500);
     } catch (e) {
       reject(e);
     }
@@ -719,6 +879,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, timeout, validatePlugins, write };
+export { FileManager, Generator, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, validatePlugins, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map