@kubb/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/index.js

@@ -85,7 +85,7 @@ function createLogger({ logLevel, name, spinner }) {
     }
   };
   const info = (message) => {
-    if (message && spinner) {
+    if (message && spinner && logLevel !== LogLevel.silent) {
       spinner.info(message);
       logs.push(message);
     }
@@ -198,10 +198,13 @@ var URLPath = class {
       params: this.getParams()
     };
     if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
+      if (type === "template") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      }
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
       }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      return `{ url: '${object.url}' }`;
     }
     return object;
   }
@@ -270,14 +273,19 @@ function combineCodes(codes) {
 }
 
 // src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments }) {
+function createJSDocBlockText({ comments, newLine }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
     return "";
   }
-  return `/**
+  const source = `/**
  * ${filteredComments.join("\n * ")}
  */`;
+  if (newLine) {
+    return `${source}
+`;
+  }
+  return source;
 }
 
 // src/utils/transformers/escape.ts
@@ -431,6 +439,11 @@ function transformReservedWord(word) {
   return word;
 }
 
+// src/utils/transformers/trim.ts
+function trim(text) {
+  return text.replaceAll(/\n/g, "").trim();
+}
+
 // src/utils/transformers/index.ts
 var transformers = {
   combineCodes,
@@ -440,6 +453,7 @@ var transformers = {
   transformReservedWord,
   nameSorter,
   searchAndReplace,
+  trim,
   JSDoc: {
     createJSDocBlockText
   }
@@ -621,12 +635,12 @@ var BarrelManager = class {
       if (currentTree.children?.length > 1) {
         const indexPath = path.resolve(currentTree.data.path, "index.ts");
         const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && indexPath.includes("index")) {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+          if (importPath.includes("index") && file.data.type === "file") {
             return void 0;
           }
           return {
-            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+            path: includeExt ? `${importPath}${extName}` : importPath,
             isTypeOnly
           };
         }).filter(Boolean);
@@ -641,10 +655,10 @@ var BarrelManager = class {
       } else {
         currentTree.children?.forEach((child) => {
           const indexPath = path.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
           const exports = [
             {
-              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+              path: includeExt ? `${importPath}${extName}` : importPath,
               isTypeOnly
             }
           ];
@@ -671,6 +685,9 @@ var BarrelManager = class {
 _options = new WeakMap();
 
 // src/FileManager.ts
+var KubbFile;
+((KubbFile2) => {
+})(KubbFile || (KubbFile = {}));
 var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
 var _FileManager = class _FileManager {
   constructor(options) {
@@ -1061,44 +1078,6 @@ function setUniqueName(originalName, data) {
 }
 
 // src/errors.ts
-var PluginError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
-  }
-};
-var ParallelPluginError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.errors = [];
-    this.name = "ParallelPluginError";
-    this.errors = options.errors;
-    this.pluginManager = options.pluginManager;
-  }
-  findError(searchError) {
-    if (!searchError) {
-      return void 0;
-    }
-    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;
-  }
-};
-var SummaryError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
-};
 var Warning = class extends Error {
   constructor(message, options) {
     super(message, { cause: options?.cause });
@@ -1188,21 +1167,37 @@ var definePlugin = createPlugin((options) => {
 
 // src/utils/executeStrategies.ts
 function hookSeq(promises) {
-  return promises.reduce(
+  return promises.filter(Boolean).reduce(
     (promise, func) => {
-      if (!func || typeof func !== "function") {
+      if (typeof func !== "function") {
         throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
       }
-      return promise.then((result) => {
-        const calledFunc = func();
+      return promise.then((state) => {
+        const calledFunc = func(state);
         if (calledFunc) {
-          return calledFunc.then(Array.prototype.concat.bind(result));
+          return calledFunc.then(Array.prototype.concat.bind(state));
         }
       });
     },
     Promise.resolve([])
   );
 }
+function hookFirst(promises, nullCheck = (state) => state !== null) {
+  let promise = Promise.resolve(null);
+  for (const func of promises.filter(Boolean)) {
+    promise = promise.then((state) => {
+      if (nullCheck(state)) {
+        return state;
+      }
+      const calledFunc = func(state);
+      return calledFunc;
+    });
+  }
+  return promise;
+}
+function hookParallel(promises) {
+  return Promise.allSettled(promises.filter(Boolean).map((promise) => promise()));
+}
 
 // src/PromiseManager.ts
 var _options2;
@@ -1216,6 +1211,12 @@ var PromiseManager = class {
     if (strategy === "seq") {
       return hookSeq(promises);
     }
+    if (strategy === "first") {
+      return hookFirst(promises, __privateGet(this, _options2).nullCheck);
+    }
+    if (strategy === "parallel") {
+      return hookParallel(promises);
+    }
     throw new Error(`${strategy} not implemented`);
   }
 };
@@ -1299,10 +1300,11 @@ Names: ${JSON.stringify(names, void 0, 2)}`
       }).result;
       return transformReservedWord(name);
     };
+    this.config = config;
     this.logger = options.logger;
     this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
-    __privateSet(this, _promiseManager, new PromiseManager());
+    __privateSet(this, _promiseManager, new PromiseManager({ nullCheck: (state) => !!state?.result }));
     const plugins = config.plugins || [];
     const core = definePlugin({
       config,
@@ -1359,20 +1361,15 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   /**
    * Chains, first non-null result stops and returns
    */
-  hookFirst({
+  async hookFirst({
     hookName,
     parameters,
     skipped
   }) {
-    let promise = Promise.resolve(null);
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      if (skipped && skipped.has(plugin)) {
-        continue;
-      }
-      promise = promise.then(async (parseResult) => {
-        if (parseResult?.result != null) {
-          return parseResult;
-        }
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true;
+    }).map((plugin) => {
+      return async () => {
         const value = await __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookFirst",
           hookName,
@@ -1385,9 +1382,9 @@ Names: ${JSON.stringify(names, void 0, 2)}`
             result: value
           }
         );
-      });
-    }
-    return promise;
+      };
+    });
+    return __privateGet(this, _promiseManager).run("first", promises);
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1424,23 +1421,16 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     hookName,
     parameters
   }) {
-    const parallelPromises = [];
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      const promise = __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
-      if (promise) {
-        parallelPromises.push(promise);
-      }
-    }
-    const results = await Promise.allSettled(parallelPromises);
-    const errors = results.map((result) => {
-      if (isPromiseRejectedResult(result) && result.reason instanceof PluginError) {
-        return result.reason;
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
+    });
+    const results = await __privateGet(this, _promiseManager).run("parallel", promises);
+    results.forEach((result, index) => {
+      if (isPromiseRejectedResult(result)) {
+        const plugin = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)[index];
+        __privateMethod(this, _catcher, catcher_fn).call(this, result.reason, plugin, hookName);
       }
-      return void 0;
-    }).filter(Boolean);
-    if (errors.length) {
-      throw new ParallelPluginError("Error", { errors, pluginManager: this });
-    }
+    });
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   /**
@@ -1469,7 +1459,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   /**
    * Chains plugins
    */
-  hookSeq({ hookName, parameters }) {
+  async hookSeq({ hookName, parameters }) {
     const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
       return () => __privateMethod(this, _execute, execute_fn).call(this, {
         strategy: "hookSeq",
@@ -1574,11 +1564,6 @@ execute_fn = function({
     return hook;
   }).then((result) => {
     output = result;
-    return result;
-  }).catch((e) => {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  }).finally(() => {
     __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
@@ -1586,6 +1571,10 @@ execute_fn = function({
       hookName,
       plugin
     });
+    return result;
+  }).catch((e) => {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
   });
   return task;
 };
@@ -1609,11 +1598,6 @@ executeSync_fn = function({
       return fn;
     }
     output = hook;
-    return hook;
-  } catch (e) {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  } finally {
     __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
@@ -1621,15 +1605,18 @@ executeSync_fn = function({
       hookName,
       plugin
     });
+    return hook;
+  } catch (e) {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
   }
 };
 _catcher = new WeakSet();
 catcher_fn = function(e, plugin, hookName) {
-  const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
+  const text = `${e.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})
 `;
-  const pluginError = new PluginError(text, { cause: e, pluginManager: this });
-  this.eventEmitter.emit("error", pluginError);
-  throw pluginError;
+  this.logger.error(text);
+  this.eventEmitter.emit("error", e);
 };
 _parse = new WeakSet();
 parse_fn = function(plugin, pluginManager, context) {
@@ -1662,7 +1649,7 @@ parse_fn = function(plugin, pluginManager, context) {
 async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
-async function build(options) {
+async function setup(options) {
   const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
@@ -1716,7 +1703,6 @@ async function build(options) {
     }
   };
   const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
-  const { plugins, fileManager } = pluginManager;
   pluginManager.on("execute", (executer) => {
     const { hookName, parameters, plugin } = executer;
     if (hookName === "writeFile" && logger.spinner) {
@@ -1754,13 +1740,18 @@ ${code}`);
       console.log(logs.join("\n"));
     }
   });
+  return pluginManager;
+}
+async function build(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
-    parameters: [plugins]
+    parameters: [pluginManager.plugins]
   });
   await pluginManager.hookParallel({
     hookName: "buildStart",
-    parameters: [config]
+    parameters: [options.config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
   if (!fileManager.isExecuting && logger.spinner) {
@@ -1769,6 +1760,28 @@ ${code}`);
   }
   return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
 }
+async function safeBuild(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
+  try {
+    await pluginManager.hookParallel({
+      hookName: "validate",
+      parameters: [pluginManager.plugins]
+    });
+    await pluginManager.hookParallel({
+      hookName: "buildStart",
+      parameters: [options.config]
+    });
+    await pluginManager.hookParallel({ hookName: "buildEnd" });
+    if (!fileManager.isExecuting && logger.spinner) {
+      logger.spinner.suffixText = "";
+      logger.spinner.succeed(`\u{1F4BE} Writing completed`);
+    }
+  } catch (e) {
+    return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager, error: e };
+  }
+  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
+}
 
 // src/Generator.ts
 var _options3, _context;
@@ -1796,9 +1809,10 @@ var Generator = class {
 };
 _options3 = new WeakMap();
 _context = new WeakMap();
-var _cache2, _cwd, _SLASHES;
+var _cache2, _cwd, _SLASHES, _match, match_fn;
 var _PackageManager = class _PackageManager {
   constructor(workspace) {
+    __privateAdd(this, _match);
     __privateAdd(this, _cwd, void 0);
     __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
@@ -1861,30 +1875,33 @@ var _PackageManager = class _PackageManager {
     __privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache2)[dependency]) {
       return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
       return void 0;
     }
-    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+    return __privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
   }
   getVersionSync(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache2)[dependency]) {
       return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
       return void 0;
     }
-    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+    return __privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
   }
   async isValid(dependency, version) {
     const packageVersion = await this.getVersion(dependency);
     if (!packageVersion) {
       return false;
     }
+    if (packageVersion === version) {
+      return true;
+    }
     const semVer = coerce(packageVersion);
     if (!semVer) {
       throw new Error(`${packageVersion} is not valid`);
@@ -1906,6 +1923,18 @@ var _PackageManager = class _PackageManager {
 _cache2 = new WeakMap();
 _cwd = new WeakMap();
 _SLASHES = new WeakMap();
+_match = new WeakSet();
+match_fn = function(packageJSON, dependency) {
+  const dependencies = {
+    ...packageJSON["dependencies"] || {},
+    ...packageJSON["devDependencies"] || {}
+  };
+  if (typeof dependency === "string" && dependencies[dependency]) {
+    return dependencies[dependency];
+  }
+  const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
+  return matchedDependency ? dependencies[matchedDependency] : void 0;
+};
 __privateAdd(_PackageManager, _cache2, {});
 var PackageManager = _PackageManager;
 
@@ -1916,6 +1945,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, PackageManager, ParallelPluginError, PluginError, PluginManager, PromiseManager, SchemaGenerator, SummaryError, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName };
+export { FileManager, Generator, KubbFile, PackageManager, PluginManager, PromiseManager, SchemaGenerator, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName, safeBuild };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map