@kubb/core 1.1.13 → 1.2.0

package/dist/index.cjs

@@ -8,6 +8,9 @@ var pathParser2 = require('path');
 var changeCase = require('change-case');
 var rimraf = require('rimraf');
 var dirTree = require('directory-tree');
+var mod = require('module');
+var url = require('url');
+var pc = require('picocolors');
 var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -16,6 +19,8 @@ var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 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);
 
 // src/managers/fileManager/FileManager.ts
 
@@ -23,6 +28,12 @@ var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 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__default.default.dirname(pathParser2__default.default.resolve(path));
   await fs__default.default.mkdir(passedPath, { recursive: true });
@@ -412,6 +423,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__default.default.createRequire(normalizeDirectory(cwd));
+    location = require2.resolve(path);
+  }
+  return location;
+}
+async function importModule(path, cwd) {
+  try {
+    const location = getLocation(path, cwd);
+    const module = await import(url.pathToFileURL(location).href);
+    return module?.default ?? module;
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
 
 // src/utils/throttle.ts
 var throttle = (fn, delay) => {
@@ -440,108 +476,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;
-  }
-  get cachedFiles() {
-    const files = [];
-    this.cache.forEach((item) => {
-      files.push(item);
-    });
-    return files;
-  }
-  async add(file) {
-    const cacheItem = { id: crypto__default.default.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;
+// 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 || [];
   }
-  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);
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  setStatus(id, status) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+};
+function createLogger(spinner) {
+  const [log] = throttle((message) => {
+    if (message && spinner) {
+      spinner.text = 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 [error] = throttle((message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
     }
-    this.setStatus(id, "removed");
-  }
-  async write(...params) {
-    if (this.queue) {
-      return this.queue.run(async () => {
-        return write(...params);
-      });
+  }, 100);
+  const [warn] = throttle((message) => {
+    if (message && spinner) {
+      spinner.warn(pc__default.default.yellow(message));
     }
-    return write(...params);
-  }
-  async read(...params) {
-    if (this.queue) {
-      return this.queue.run(async () => {
-        return read(...params);
-      });
+  }, 100);
+  const [info] = throttle((message) => {
+    if (message && spinner) {
+      spinner.text = message;
     }
-    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) {
@@ -599,7 +580,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);
@@ -607,9 +589,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 = [];
@@ -656,6 +639,7 @@ function getFileSource(file) {
     return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
   }, []);
   const exportSource = tsCodegen.print(exportNodes);
+  source = getEnvSource(source, file.env);
   if (importSource) {
     source = `${importSource}
 ${source}`;
@@ -666,6 +650,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__default.default.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);
@@ -680,9 +807,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;
@@ -699,14 +826,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) {
@@ -718,29 +845,30 @@ 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__default.default.resolve(this.config.root, this.config.output.path);
       return pathParser2__default.default.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 });
@@ -748,14 +876,27 @@ var ParallelPluginError = class extends Error {
     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;
   }
 };
@@ -780,12 +921,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,
@@ -834,11 +978,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,
@@ -847,11 +991,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,
@@ -936,7 +1080,12 @@ 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) {
       throw new ParallelPluginError("Error", { errors, pluginManager: this });
     }
@@ -987,9 +1136,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;
     }
@@ -1046,6 +1195,7 @@ var PluginManager = class {
       return hook;
     }).catch((e) => {
       this.catcher(e, plugin, hookName);
+      return null;
     });
   }
   /**
@@ -1110,31 +1260,21 @@ 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;
 }
 
-// src/managers/pluginManager/SummaryError.ts
-var SummaryError = class extends Error {
-  summary;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
-};
-
 // src/build.ts
 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);
@@ -1177,11 +1317,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__default.default.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",
@@ -1222,6 +1363,10 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
+Object.defineProperty(exports, 'pc', {
+  enumerable: true,
+  get: function () { return pc__default.default; }
+});
 exports.FileManager = FileManager;
 exports.Generator = Generator;
 exports.ParallelPluginError = ParallelPluginError;
@@ -1232,26 +1377,35 @@ exports.SchemaGenerator = SchemaGenerator;
 exports.SummaryError = SummaryError;
 exports.TreeNode = TreeNode;
 exports.ValidationPluginError = ValidationPluginError;
+exports.Warning = Warning;
 exports.build = build;
 exports.clean = clean;
 exports.combineFiles = combineFiles;
 exports.createJSDocBlockText = createJSDocBlockText;
+exports.createLogger = createLogger;
 exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
 exports.defineConfig = defineConfig;
+exports.extensions = extensions;
 exports.getEncodedText = getEncodedText;
 exports.getFileSource = getFileSource;
+exports.getLocation = getLocation;
 exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
 exports.getStackTrace = getStackTrace;
 exports.getUniqueName = getUniqueName;
 exports.hooks = hooks;
+exports.importModule = importModule;
 exports.isPromise = isPromise;
+exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
+exports.isPromiseRejectedResult = isPromiseRejectedResult;
 exports.isURL = isURL;
-exports.name = name;
+exports.name = pluginName;
 exports.nameSorter = nameSorter;
+exports.normalizeDirectory = normalizeDirectory;
 exports.objectToParameters = objectToParameters;
+exports.pluginName = pluginName;
 exports.read = read;
 exports.renderTemplate = renderTemplate;
 exports.throttle = throttle;