@kubb/core 1.1.12 → 1.2.0

package/dist/index.js

@@ -5,6 +5,10 @@ import pathParser2 from 'node:path';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { rimraf } from 'rimraf';
 import dirTree from 'directory-tree';
+import mod from 'node:module';
+import { pathToFileURL } from 'node:url';
+import pc from 'picocolors';
+export { default as pc } from 'picocolors';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
@@ -13,6 +17,12 @@ createRequire(import.meta.url);
 function isPromise(result) {
   return typeof result?.then === "function";
 }
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
 async function safeWriteFileToPath(path, data) {
   const passedPath = pathParser2.dirname(pathParser2.resolve(path));
   await fs.mkdir(passedPath, { recursive: true });
@@ -402,6 +412,31 @@ function getStackTrace(belowFn) {
 
 // src/utils/uniqueId.ts
 var uniqueId = ((counter) => (str = "") => `${str}${++counter}`)(0);
+var SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+function normalizeDirectory(directory) {
+  if (!SLASHES.has(directory[directory.length - 1])) {
+    return `${directory}/`;
+  }
+  return directory;
+}
+function getLocation(path, cwd) {
+  let location = path;
+  if (cwd) {
+    const require2 = mod.createRequire(normalizeDirectory(cwd));
+    location = require2.resolve(path);
+  }
+  return location;
+}
+async function importModule(path, cwd) {
+  try {
+    const location = getLocation(path, cwd);
+    const module = await import(pathToFileURL(location).href);
+    return module?.default ?? module;
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
 
 // src/utils/throttle.ts
 var throttle = (fn, delay) => {
@@ -430,98 +465,53 @@ var throttle = (fn, delay) => {
   ];
 };
 
-// src/managers/fileManager/FileManager.ts
-var FileManager = class {
-  cache = /* @__PURE__ */ new Map();
-  task;
-  queue;
-  constructor(options) {
-    if (options) {
-      this.task = options.task;
-      this.queue = options.queue;
-    }
-  }
-  getCache(id) {
-    return this.cache.get(id);
-  }
-  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;
+// src/utils/SummaryError.ts
+var SummaryError = class extends Error {
+  summary;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "SummaryError";
+    this.summary = options.summary || [];
   }
-  get cachedFiles() {
-    const files = [];
-    this.cache.forEach((item) => {
-      files.push(item);
-    });
-    return files;
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  async add(file) {
-    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
-    this.cache.set(cacheItem.id, cacheItem);
-    if (this.queue) {
-      await this.queue.run(async () => {
-        await this.task?.(cacheItem.id, file);
-      });
+};
+function createLogger(spinner) {
+  const [log] = throttle((message) => {
+    if (message && spinner) {
+      spinner.text = message;
     }
-    return file;
-  }
-  addOrAppend(file) {
-    if (!file.path.endsWith(file.fileName)) ;
-    const previousCache = this.getCacheByPath(file.path);
-    if (previousCache) {
-      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
-      if (sourceAlreadyExists) {
-        return Promise.resolve(file);
-      }
-      this.cache.delete(previousCache.id);
-      return this.add({
-        ...file,
-        source: `${previousCache.file.source}
-${file.source}`,
-        imports: [...previousCache.file.imports || [], ...file.imports || []],
-        exports: [...previousCache.file.exports || [], ...file.exports || []]
-      });
+  }, 100);
+  const [error] = throttle((message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
     }
-    return this.add(file);
-  }
-  setStatus(id, status) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+  }, 100);
+  const [warn] = throttle((message) => {
+    if (message && spinner) {
+      spinner.warn(pc.yellow(message));
     }
-    cacheItem.status = status;
-    this.cache.set(id, cacheItem);
-  }
-  get(id) {
-    const cacheItem = this.getCache(id);
-    return cacheItem?.file;
-  }
-  remove(id) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+  }, 100);
+  const [info] = throttle((message) => {
+    if (message && spinner) {
+      spinner.text = message;
     }
-    this.setStatus(id, "removed");
-  }
-  async write(...params) {
-    return write(...params);
-  }
-  async read(...params) {
-    return read(...params);
-  }
-};
+  }, 100);
+  const logger = {
+    log,
+    error,
+    warn,
+    info,
+    spinner
+  };
+  return logger;
+}
 function writeIndexes(root, options = {}) {
   const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
   if (!tree) {
@@ -579,7 +569,8 @@ function combineFiles(files) {
         source: prev.source && curr.source ? `${prev.source}
 ${curr.source}` : "'",
         imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
+        exports: [...prev.exports || [], ...curr.exports || []],
+        env: { ...prev.env || {}, ...curr.env || {} }
       };
     } else {
       acc.push(curr);
@@ -587,9 +578,10 @@ ${curr.source}` : "'",
     return acc;
   }, []);
 }
+var extensions = [".js", ".ts"];
 function getFileSource(file) {
   let { source } = file;
-  if (!file.fileName.endsWith(".ts")) {
+  if (!extensions.some((extension) => file.fileName.endsWith(extension))) {
     return file.source;
   }
   const imports = [];
@@ -636,6 +628,7 @@ function getFileSource(file) {
     return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
   }, []);
   const exportSource = print(exportNodes);
+  source = getEnvSource(source, file.env);
   if (importSource) {
     source = `${importSource}
 ${source}`;
@@ -646,6 +639,149 @@ ${source}`;
   }
   return source;
 }
+function searchAndReplace(options) {
+  const { text, replaceBy, prefix = "", key } = options;
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, "g")
+  ];
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy);
+  }, text);
+}
+function getEnvSource(source, env) {
+  if (!env) {
+    return source;
+  }
+  const keys = Object.keys(env);
+  if (!keys.length) {
+    return source;
+  }
+  return keys.reduce((prev, key) => {
+    const environmentValue = env[key];
+    const replaceBy = environmentValue ? `'${environmentValue.replaceAll('"', "")?.replaceAll("'", "")}'` : "undefined";
+    if (key.toUpperCase() !== key) {
+      throw new TypeError(`Environment should be in upperCase for ${key}`);
+    }
+    if (typeof replaceBy === "string") {
+      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+`, "ig"), ""), replaceBy, key });
+    }
+    return prev;
+  }, source);
+}
+
+// src/managers/fileManager/FileManager.ts
+var FileManager = class {
+  cache = /* @__PURE__ */ new Map();
+  task;
+  queue;
+  constructor(options) {
+    if (options) {
+      this.task = options.task;
+      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);
+    });
+    return files;
+  }
+  async add(file) {
+    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
+    this.cache.set(cacheItem.id, cacheItem);
+    if (this.queue) {
+      await this.queue.run(async () => {
+        await this.task?.(cacheItem.id, file);
+      });
+    }
+    return file;
+  }
+  addOrAppend(file) {
+    if (!file.path.endsWith(file.fileName)) ;
+    const previousCache = this.getCacheByPath(file.path);
+    if (previousCache) {
+      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
+      if (sourceAlreadyExists) {
+        return Promise.resolve(file);
+      }
+      this.cache.delete(previousCache.id);
+      return this.add({
+        ...file,
+        source: `${previousCache.file.source}
+${file.source}`,
+        imports: [...previousCache.file.imports || [], ...file.imports || []],
+        exports: [...previousCache.file.exports || [], ...file.exports || []]
+      });
+    }
+    return this.add(file);
+  }
+  setStatus(id, status) {
+    const cacheItem = this.getCache(id);
+    if (!cacheItem) {
+      return;
+    }
+    cacheItem.status = status;
+    this.cache.set(id, cacheItem);
+  }
+  get(id) {
+    const cacheItem = this.getCache(id);
+    return cacheItem?.file;
+  }
+  remove(id) {
+    const cacheItem = this.getCache(id);
+    if (!cacheItem) {
+      return;
+    }
+    this.setStatus(id, "removed");
+  }
+  async write(...params) {
+    if (this.queue) {
+      return this.queue.run(async () => {
+        return write(...params);
+      });
+    }
+    return write(...params);
+  }
+  async read(...params) {
+    if (this.queue) {
+      return this.queue.run(async () => {
+        return read(...params);
+      });
+    }
+    return read(...params);
+  }
+};
 function createPlugin(factory) {
   return (options) => {
     const plugin = factory(options);
@@ -660,9 +796,9 @@ function createPlugin(factory) {
     return plugin;
   };
 }
-var name = "core";
+var pluginName = "core";
 var definePlugin = createPlugin((options) => {
-  const { fileManager, resolvePath, resolveName, load } = options;
+  const { fileManager, resolvePath, resolveName, load, logger } = options;
   const api = {
     get config() {
       return options.config;
@@ -679,14 +815,14 @@ var definePlugin = createPlugin((options) => {
         }
         return 0;
       });
-      const pluginName = plugins?.[0]?.name;
+      const pluginName2 = plugins?.[0]?.name;
       return Promise.all(
         files.map((file) => {
           const fileWithMeta = {
             ...file,
             meta: {
               ...file.meta || {},
-              pluginName
+              pluginName: pluginName2
             }
           };
           if (file.override) {
@@ -698,42 +834,58 @@ var definePlugin = createPlugin((options) => {
     },
     resolvePath,
     resolveName: (params) => {
-      const name2 = resolveName(params);
-      return transformReservedWord(name2);
+      const name = resolveName(params);
+      return transformReservedWord(name);
     },
     load,
+    logger,
     cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
   return {
-    name,
+    name: pluginName,
     options,
     api,
     resolvePath(fileName) {
       const root = pathParser2.resolve(this.config.root, this.config.output.path);
       return pathParser2.resolve(root, fileName);
     },
-    resolveName(name2) {
-      return name2;
+    resolveName(name) {
+      return name;
     }
   };
 });
 
 // src/managers/pluginManager/ParallelPluginError.ts
 var ParallelPluginError = class extends Error {
-  errors;
+  errors = [];
   pluginManager;
   constructor(message, options) {
     super(message, { cause: options.cause });
+    this.name = "ParallelPluginError";
     this.errors = options.errors;
     this.pluginManager = options.pluginManager;
   }
+  findError(searchError) {
+    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;
+  }
 };
 
 // src/managers/pluginManager/PluginError.ts
 var PluginError = class extends Error {
   pluginManager;
+  cause;
   constructor(message, options) {
     super(message, { cause: options.cause });
+    this.name = "PluginError";
+    this.cause = options.cause;
     this.pluginManager = options.pluginManager;
   }
 };
@@ -758,12 +910,15 @@ var PluginManager = class {
   queue;
   executer;
   executed = [];
+  logger;
   constructor(config, options) {
     this.onExecute = options.onExecute?.bind(this);
+    this.logger = options.logger;
     this.queue = new Queue(10);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     this.core = definePlugin({
       config,
+      logger: this.logger,
       fileManager: this.fileManager,
       load: this.load,
       resolvePath: this.resolvePath,
@@ -812,11 +967,11 @@ var PluginManager = class {
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginName,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName);
+    const plugin = this.getPlugin(hookName, pluginName2);
     return this.execute({
       strategy: "hookFirst",
       hookName,
@@ -825,11 +980,11 @@ var PluginManager = class {
     });
   }
   hookForPluginSync({
-    pluginName,
+    pluginName: pluginName2,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName);
+    const plugin = this.getPlugin(hookName, pluginName2);
     return this.executeSync({
       strategy: "hookFirst",
       hookName,
@@ -914,9 +1069,13 @@ var PluginManager = class {
       }
     }
     const results = await Promise.allSettled(parallelPromises);
-    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    const errors = results.map((result) => {
+      if (isPromiseRejectedResult(result) && result.reason instanceof PluginError) {
+        return result.reason;
+      }
+      return void 0;
+    }).filter(Boolean);
     if (errors.length) {
-      console.log(errors);
       throw new ParallelPluginError("Error", { errors, pluginManager: this });
     }
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
@@ -966,9 +1125,9 @@ var PluginManager = class {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
     return plugins;
   }
-  getPlugin(hookName, pluginName) {
+  getPlugin(hookName, pluginName2) {
     const plugins = [...this.plugins];
-    const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName]);
+    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
     if (!pluginByPluginName) {
       return this.core;
     }
@@ -1025,6 +1184,7 @@ var PluginManager = class {
       return hook;
     }).catch((e) => {
       this.catcher(e, plugin, hookName);
+      return null;
     });
   }
   /**
@@ -1089,10 +1249,10 @@ function validatePlugins(plugins, dependedPluginNames) {
   } else {
     pluginNames = dependedPluginNames;
   }
-  pluginNames.forEach((pluginName) => {
-    const exists = plugins.some((plugin) => plugin.name === pluginName);
+  pluginNames.forEach((pluginName2) => {
+    const exists = plugins.some((plugin) => plugin.name === pluginName2);
     if (!exists) {
-      throw new ValidationPluginError(`This plugin depends on the ${pluginName} plugin.`);
+      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
     }
   });
   return true;
@@ -1103,7 +1263,7 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function build(options) {
-  const { config, logger } = options;
+  const { config, logger = createLogger() } = options;
   try {
     if (!isURL(config.input.path)) {
       await read(config.input.path);
@@ -1146,11 +1306,12 @@ async function build(options) {
       return;
     }
     const { hookName, plugin } = executer;
-    if (config.logLevel === "info" && logger) {
-      logger.log(null, { logLevel: config.logLevel, params: { hookName, pluginName: plugin.name } });
+    if (config.logLevel === "info") {
+      const messsage = `\u{1FA82} Executing ${hookName || "unknown"}(${pc.yellow(plugin.name || "unknown")})`;
+      logger.log(messsage);
     }
   };
-  const pluginManager = new PluginManager(config, { task: queueTask, onExecute });
+  const pluginManager = new PluginManager(config, { logger, task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1191,4 +1352,6 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };
+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 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map