@kubb/core 1.5.0 → 1.5.1

package/dist/index.cjs

@@ -0,0 +1,1584 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var crypto = require('crypto');
+var fs = require('fs-extra');
+var pathParser2 = require('path');
+var jsRuntime = require('js-runtime');
+var changeCase = require('change-case');
+var perf_hooks = require('perf_hooks');
+var rimraf = require('rimraf');
+var dirTree = require('directory-tree');
+var mod = require('module');
+var url = require('url');
+var os = require('os');
+var pc3 = require('picocolors');
+var seedrandom = require('seedrandom');
+var tsCodegen = require('@kubb/ts-codegen');
+var events = require('events');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+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 os__default = /*#__PURE__*/_interopDefault(os);
+var pc3__default = /*#__PURE__*/_interopDefault(pc3);
+var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
+
+// src/managers/fileManager/FileManager.ts
+
+// src/utils/isPromise.ts
+function isPromise(result) {
+  return typeof result?.then === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+async function saveCreateDirectory(path) {
+  const passedPath = pathParser2__default.default.dirname(pathParser2__default.default.resolve(path));
+  await fs__default.default.mkdir(passedPath, { recursive: true });
+}
+var writer = jsRuntime.switcher(
+  {
+    node: async (path, data) => {
+      try {
+        await fs__default.default.stat(path);
+        const oldContent = await fs__default.default.readFile(path, { encoding: "utf-8" });
+        if (oldContent?.toString() === data) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path);
+      return fs__default.default.writeFile(pathParser2__default.default.resolve(path), data, { encoding: "utf-8" });
+    },
+    bun: async (path, data) => {
+      try {
+        await saveCreateDirectory(path);
+        await Bun.write(pathParser2__default.default.resolve(path), data);
+      } catch (e) {
+        console.log(e, pathParser2__default.default.resolve(path));
+      }
+    }
+  },
+  "node"
+);
+async function write(data, path) {
+  return writer(path, data);
+}
+
+// src/utils/cache.ts
+function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
+  return {
+    set(id, value) {
+      Store[id] = [0, value];
+    },
+    get(id) {
+      const item = Store[id];
+      if (!item) {
+        return null;
+      }
+      item[0] = 0;
+      return item[1];
+    },
+    has(id) {
+      const item = Store[id];
+      if (!item) {
+        return false;
+      }
+      item[0] = 0;
+      return true;
+    },
+    delete(id) {
+      return delete Store[id];
+    }
+  };
+}
+function slash(path, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  }
+  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+  }
+  const relativePath = pathParser2__default.default.relative(rootDir, filePath);
+  const path = slash(relativePath, platform);
+  if (path.startsWith("../")) {
+    return path.replace(pathParser2__default.default.basename(path), pathParser2__default.default.basename(path, pathParser2__default.default.extname(filePath)));
+  }
+  return `./${path.replace(pathParser2__default.default.basename(path), pathParser2__default.default.basename(path, pathParser2__default.default.extname(filePath)))}`;
+}
+function getPathMode(path) {
+  if (!path) {
+    return "directory";
+  }
+  return pathParser2__default.default.extname(path) ? "file" : "directory";
+}
+var reader = jsRuntime.switcher(
+  {
+    node: async (path) => {
+      return fs__default.default.readFile(path, { encoding: "utf8" });
+    },
+    bun: async (path) => {
+      const file = Bun.file(path);
+      return file.text();
+    }
+  },
+  "node"
+);
+async function read(path) {
+  return reader(path);
+}
+function objectToParameters(data, options = {}) {
+  const { typed } = options;
+  return data.reduce((acc, [key, value]) => {
+    const parameterName = changeCase.camelCase(key, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
+    if (typed) {
+      acc.push(`${parameterName}: ${value}["${key}"]`);
+    } else {
+      acc.push(`${parameterName}`);
+    }
+    return acc;
+  }, []).join(", ");
+}
+
+// src/utils/nameSorter.ts
+function nameSorter(a, b) {
+  if (a.name < b.name) {
+    return -1;
+  }
+  if (a.name > b.name) {
+    return 1;
+  }
+  return 0;
+}
+
+// src/utils/jsdoc.ts
+function createJSDocBlockText({ comments }) {
+  const filteredComments = comments.filter(Boolean);
+  if (!filteredComments.length) {
+    return "";
+  }
+  const text = filteredComments.reduce((acc, comment) => {
+    return `${acc}
+* ${comment}`;
+  }, "/**");
+  return `${text}
+*/`;
+}
+
+// src/utils/getUniqueName.ts
+function getUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    originalName += used;
+  }
+  data[originalName] = 1;
+  return originalName;
+}
+
+// src/utils/timeout.ts
+async function timeout(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, ms);
+  });
+}
+var Queue = class {
+  queue = [];
+  workerCount = 0;
+  maxParallel;
+  debug = false;
+  constructor(maxParallel, debug = false) {
+    this.maxParallel = maxParallel;
+    this.debug = debug;
+  }
+  run(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
+    return new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.queue = this.queue.filter((queueItem) => queueItem.name === item.name);
+        reject("Aborted");
+      });
+      this.queue.push(item);
+      this.work();
+    });
+  }
+  runSync(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
+    new Promise((resolve, reject) => {
+      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        this.queue = this.queue.filter((queueItem) => queueItem.name === item.name);
+      });
+      this.queue.push(item);
+      this.work();
+    });
+  }
+  get hasJobs() {
+    return this.workerCount > 0 || this.queue.length > 0;
+  }
+  work() {
+    if (this.workerCount >= this.maxParallel) {
+      return;
+    }
+    this.workerCount++;
+    let entry;
+    while (entry = this.queue.shift()) {
+      const { reject, resolve, job, name, description } = entry;
+      if (this.debug) {
+        perf_hooks.performance.mark(name + "_start");
+      }
+      job().then((result) => {
+        resolve(result);
+        if (this.debug) {
+          perf_hooks.performance.mark(name + "_stop");
+          perf_hooks.performance.measure(description, name + "_start", name + "_stop");
+        }
+      }).catch((err) => reject(err));
+    }
+    this.workerCount--;
+  }
+};
+
+// src/utils/getEncodedText.ts
+function getEncodedText(text) {
+  return text ? text.replaceAll("`", "\\`") : "";
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  const matches = template.match(/{{(.*?)}}/g);
+  return matches?.reduce((prev, curr) => {
+    const value = data[curr.split(/{{|}}/).filter(Boolean)[0].trim()];
+    if (value === void 0) {
+      return prev;
+    }
+    return prev.replace(curr, () => {
+      if (typeof value === "boolean") {
+        return `${value.toString()}` || "false";
+      }
+      return value || "";
+    }).trim();
+  }, template) || "";
+}
+async function clean(path) {
+  return rimraf.rimraf(path);
+}
+var TreeNode = class _TreeNode {
+  data;
+  parent;
+  children = [];
+  constructor(data, parent) {
+    this.data = data;
+    this.parent = parent;
+    return this;
+  }
+  addChild(data) {
+    const child = new _TreeNode(data, this);
+    if (!this.children) {
+      this.children = [];
+    }
+    this.children.push(child);
+    return child;
+  }
+  find(data) {
+    if (!data) {
+      return null;
+    }
+    if (data === this.data) {
+      return this;
+    }
+    if (this.children?.length) {
+      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
+        target = this.children[i].find(data);
+        if (target) {
+          return target;
+        }
+      }
+    }
+    return null;
+  }
+  get leaves() {
+    if (!this.children || this.children.length === 0) {
+      return [this];
+    }
+    const leaves = [];
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        leaves.push.apply(leaves, this.children[i].leaves);
+      }
+    }
+    return leaves;
+  }
+  get root() {
+    if (!this.parent) {
+      return this;
+    }
+    return this.parent.root;
+  }
+  forEach(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    callback(this);
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        this.children[i].forEach(callback);
+      }
+    }
+    return this;
+  }
+  static build(path, options = {}) {
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
+      const filteredTree = dirTree__default.default(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      if (!filteredTree) {
+        return null;
+      }
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
+        if (item.children?.length) {
+          item.children?.forEach((child) => {
+            recurse(subNode, child);
+          });
+        }
+      };
+      filteredTree.children?.forEach((child) => recurse(treeNode, child));
+      return treeNode;
+    } catch (e) {
+      throw new Error("Something went wrong with creating index files with the TreehNode class", { cause: e });
+    }
+  }
+};
+
+// src/utils/transformReservedWord.ts
+var reservedWords = [
+  "abstract",
+  "arguments",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  "Array",
+  "Date",
+  "eval",
+  "function",
+  "hasOwnProperty",
+  "Infinity",
+  "isFinite",
+  "isNaN",
+  "isPrototypeOf",
+  "length",
+  "Math",
+  "name",
+  "NaN",
+  "Number",
+  "Object",
+  "prototype",
+  "String",
+  "toString",
+  "undefined",
+  "valueOf"
+];
+function transformReservedWord(word) {
+  if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
+    return `_${word}`;
+  }
+  return word;
+}
+
+// src/utils/uniqueIdFactory.ts
+var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
+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 {
+    let location = getLocation(path, cwd);
+    if (os__default.default.platform() == "win32") {
+      location = url.pathToFileURL(location).href;
+    }
+    const module = await import(location);
+    return module?.default ?? module;
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
+
+// src/utils/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout2;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled) {
+        return void 0;
+      }
+      if (wait) {
+        return void 0;
+      }
+      const val = fn(...args);
+      wait = true;
+      timeout2 = setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout2);
+    }
+  ];
+};
+
+// 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 || [];
+  }
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
+  }
+};
+function createLogger(spinner) {
+  const log = (message) => {
+    if (message && spinner) {
+      spinner.text = message;
+    }
+  };
+  const error = (message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
+    }
+  };
+  const warn = (message) => {
+    if (message && spinner) {
+      spinner.warn(pc3__default.default.yellow(message));
+    }
+  };
+  const info = (message) => {
+    if (message && spinner) {
+      spinner.info(message);
+    }
+  };
+  const logger = {
+    log,
+    error,
+    warn,
+    info,
+    spinner
+  };
+  return logger;
+}
+var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
+function randomColour(text, colours = defaultColours) {
+  if (!text) {
+    return "white";
+  }
+  const random = seedrandom__default.default(text);
+  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
+  return colour;
+}
+function randomPicoColour(text, colors = defaultColours) {
+  const colours = pc3__default.default.createColors(true);
+  if (!text) {
+    return colours.white(text);
+  }
+  const colour = randomColour(text, colors);
+  const isDark = colour.includes("dark");
+  const key = colour.replace("dark", "").toLowerCase();
+  const formatter = colours[key];
+  if (isDark) {
+    return pc3__default.default.bold(formatter(text));
+  }
+  if (typeof formatter !== "function") {
+    throw new Error("Formatter for picoColor is not of type function/Formatter");
+  }
+  return formatter(text);
+}
+var URLPath = class _URLPath {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isUrl() {
+    return _URLPath.isURL(this.path);
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString() {
+    return _URLPath.toTemplateString(this.path);
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  static toTemplateString(path) {
+    const regex = /{(\w|-)*}/g;
+    const found = path.match(regex);
+    let newPath = path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const replacement = `\${${changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })}}`;
+        return prev.replace(curr, replacement);
+      }, path);
+    }
+    return `\`${newPath}\``;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return _URLPath.toURLPath(this.path);
+  }
+  static toURLPath(path) {
+    return path.replaceAll("{", ":").replaceAll("}", "");
+  }
+  static isURL(path) {
+    try {
+      const url = new URL(path);
+      if (url?.href) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  }
+};
+function getIndexes(root, options = {}) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return null;
+  }
+  const fileReducer = (files2, currentTree) => {
+    if (!currentTree.children) {
+      return [];
+    }
+    if (currentTree.children?.length > 1) {
+      const path = pathParser2__default.default.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.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 {
+      currentTree.children?.forEach((child) => {
+        const path = pathParser2__default.default.resolve(currentTree.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 }]
+        });
+      });
+    }
+    currentTree.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: prev.source && curr.source ? `${prev.source}
+${curr.source}` : "",
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []],
+        env: { ...prev.env || {}, ...curr.env || {} }
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+var extensions = [".js", ".ts", ".tsx"];
+function isExtensionAllowed(fileName) {
+  return extensions.some((extension) => fileName.endsWith(extension));
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!isExtensionAllowed(file.fileName)) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const existingImport = imports.find((imp) => imp.path === curr.path);
+    if (!existingImport) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (existingImport && !Array.isArray(existingImport.name) && existingImport.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (existingImport && Array.isArray(existingImport.name)) {
+      if (Array.isArray(curr.name)) {
+        existingImport.name = [.../* @__PURE__ */ new Set([...existingImport.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, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = tsCodegen.print(exportNodes);
+  source = getEnvSource(source, file.env);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${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;
+    }
+  }
+  get extensions() {
+    return extensions;
+  }
+  get files() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
+  }
+  get isExecuting() {
+    return this.queue?.hasJobs ?? false;
+  }
+  async add(file) {
+    const controller = new AbortController();
+    const resolvedFile = { id: crypto__default.default.randomUUID(), ...file };
+    this.cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+    if (this.queue) {
+      try {
+        await this.queue.run(
+          async () => {
+            return this.task?.(resolvedFile);
+          },
+          { controller }
+        );
+      } catch {
+        return resolvedFile;
+      }
+    }
+    return resolvedFile;
+  }
+  addOrAppend(file) {
+    const previousCaches = this.cache.get(file.path);
+    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+    if (previousCache) {
+      this.cache.delete(previousCache.path);
+      return this.add({
+        ...file,
+        source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+        imports: [...previousCache.imports || [], ...file.imports || []],
+        exports: [...previousCache.exports || [], ...file.exports || []],
+        env: { ...previousCache.env || {}, ...file.env || {} }
+      });
+    }
+    return this.add(file);
+  }
+  append(path, file) {
+    const previousFiles = this.cache.get(path) || [];
+    this.cache.set(path, [...previousFiles, file]);
+  }
+  getCacheByUUID(UUID) {
+    let cache;
+    this.cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
+  }
+  get(path) {
+    return this.cache.get(path);
+  }
+  remove(path) {
+    const cacheItem = this.get(path);
+    if (!cacheItem) {
+      return;
+    }
+    this.cache.delete(path);
+  }
+  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);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
+    }
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
+    }
+    return plugin;
+  };
+}
+var pluginName = "core";
+var definePlugin = createPlugin((options) => {
+  const { fileManager, resolvePath, resolveName, logger } = options;
+  return {
+    name: pluginName,
+    options,
+    api() {
+      return {
+        get config() {
+          return options.config;
+        },
+        logger,
+        fileManager,
+        async addFile(...files) {
+          return Promise.all(
+            files.map((file) => {
+              if (file.override) {
+                return fileManager.add(file);
+              }
+              return fileManager.addOrAppend(file);
+            })
+          );
+        },
+        resolvePath,
+        resolveName: (params) => {
+          const name = resolveName(params);
+          return transformReservedWord(name);
+        },
+        cache: createPluginCache()
+      };
+    },
+    resolvePath(fileName) {
+      const root = pathParser2__default.default.resolve(this.config.root, this.config.output.path);
+      return pathParser2__default.default.resolve(root, fileName);
+    },
+    resolveName(name) {
+      return name;
+    }
+  };
+});
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors = [];
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    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;
+  }
+};
+
+// 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;
+  }
+};
+var EventEmitter = class {
+  emitter = new events.EventEmitter();
+  emit(eventName, ...eventArg) {
+    this.emitter.emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    this.emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.emitter.off(eventName, handler);
+  }
+};
+
+// src/managers/pluginManager/pluginParser.ts
+function pluginParser(plugin, context) {
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      api
+    };
+  }
+  return null;
+}
+
+// src/managers/pluginManager/PluginManager.ts
+var hookNames = {
+  validate: 1,
+  buildStart: 1,
+  resolvePath: 1,
+  resolveName: 1,
+  load: 1,
+  transform: 1,
+  writeFile: 1,
+  buildEnd: 1
+};
+var hooks = Object.keys(hookNames);
+var PluginManager = class {
+  plugins;
+  fileManager;
+  core;
+  queue;
+  executed = [];
+  logger;
+  eventEmitter = new EventEmitter();
+  constructor(config, options) {
+    this.logger = options.logger;
+    this.queue = new Queue(50, options.debug);
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
+    const core = definePlugin({
+      config,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      resolvePath: this.resolvePath,
+      resolveName: this.resolveName
+    });
+    this.core = pluginParser(core, core.api.call(null));
+    this.plugins = [this.core, ...config.plugins || []].reduce((prev, plugin) => {
+      const convertedApi = pluginParser(plugin, this.core?.api);
+      if (convertedApi) {
+        return [...prev, convertedApi];
+      }
+      return [...prev, plugin];
+    }, []);
+  }
+  resolvePath = (params) => {
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolvePath",
+        parameters: [params.fileName, params.directory, params.options]
+      });
+    }
+    return this.hookFirstSync({
+      hookName: "resolvePath",
+      parameters: [params.fileName, params.directory, params.options]
+    }).result;
+  };
+  resolveName = (params) => {
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolveName",
+        parameters: [params.name]
+      }) || params.name;
+    }
+    return this.hookFirstSync({
+      hookName: "resolveName",
+      parameters: [params.name]
+    }).result;
+  };
+  on(eventName, handler) {
+    this.eventEmitter.on(eventName, handler);
+  }
+  /**
+   *
+   * Run only hook for a specific plugin name
+   */
+  hookForPlugin({
+    pluginName: pluginName2,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.execute({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+  }
+  hookForPluginSync({
+    pluginName: pluginName2,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName2);
+    return this.executeSync({
+      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)) {
+      if (skipped && skipped.has(plugin)) {
+        continue;
+      }
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult;
+        }
+        const value = await this.execute({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        });
+        return Promise.resolve({
+          plugin,
+          result: value
+        });
+      });
+    }
+    return promise;
+  }
+  /**
+   *
+   * Chains, first non-null result stops and returns
+   */
+  hookFirstSync({
+    hookName,
+    parameters,
+    skipped
+  }) {
+    let parseResult = null;
+    for (const plugin of this.getSortedPlugins(hookName)) {
+      if (skipped && skipped.has(plugin)) {
+        continue;
+      }
+      parseResult = {
+        result: this.executeSync({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        }),
+        plugin
+      };
+      if (parseResult?.result != null) {
+        break;
+      }
+    }
+    return parseResult;
+  }
+  /**
+   *
+   * Parallel, runs all plugins
+   */
+  async hookParallel({
+    hookName,
+    parameters
+  }) {
+    const parallelPromises = [];
+    for (const plugin of this.getSortedPlugins(hookName)) {
+      const promise = this.execute({ 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;
+      }
+      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);
+  }
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
+  hookReduceArg0({
+    hookName,
+    parameters,
+    reduce
+  }) {
+    const [argument0, ...rest] = parameters;
+    let promise = Promise.resolve(argument0);
+    for (const plugin of this.getSortedPlugins(hookName)) {
+      promise = promise.then((arg0) => {
+        const value = this.execute({
+          strategy: "hookReduceArg0",
+          hookName,
+          parameters: [arg0, ...rest],
+          plugin
+        });
+        return value;
+      }).then((result) => reduce.call(this.core.api, argument0, result, plugin));
+    }
+    return promise;
+  }
+  /**
+   * Chains plugins
+   */
+  hookSeq({ hookName, parameters }) {
+    let promise = Promise.resolve();
+    for (const plugin of this.getSortedPlugins(hookName)) {
+      promise = promise.then(
+        () => this.execute({
+          strategy: "hookSeq",
+          hookName,
+          parameters,
+          plugin
+        })
+      );
+    }
+    return promise.then(noReturn);
+  }
+  getSortedPlugins(_hookName) {
+    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+    return plugins;
+  }
+  getPlugin(hookName, pluginName2) {
+    const plugins = [...this.plugins];
+    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
+    if (!pluginByPluginName) {
+      return this.core;
+    }
+    return pluginByPluginName;
+  }
+  addExecutedToCallStack(executer) {
+    if (executer) {
+      this.eventEmitter.emit("execute", 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`.
+   * @param args Arguments passed to the plugin hook.
+   * @param plugin The actual pluginObject to run.
+   */
+  // Implementation signature
+  execute({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
+    const hook = plugin[hookName];
+    let output;
+    if (!hook) {
+      return null;
+    }
+    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+    const task = Promise.resolve().then(() => {
+      if (typeof hook === "function") {
+        const possiblePromiseResult = hook.apply(this.core.api, parameters);
+        if (isPromise(possiblePromiseResult)) {
+          return Promise.resolve(possiblePromiseResult);
+        }
+        return possiblePromiseResult;
+      }
+      return hook;
+    }).then((result) => {
+      output = result;
+      return result;
+    }).catch((e) => {
+      this.catcher(e, plugin, hookName);
+      return null;
+    }).finally(() => {
+      this.addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
+    });
+    return task;
+  }
+  /**
+   * Run a sync plugin hook and return the result.
+   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+   * @param args Arguments passed to the plugin hook.
+   * @param plugin The acutal plugin
+   * @param replaceContext When passed, the plugin context can be overridden.
+   */
+  executeSync({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
+    const hook = plugin[hookName];
+    let output;
+    if (!hook) {
+      return null;
+    }
+    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+    try {
+      if (typeof hook === "function") {
+        const fn = hook.apply(this.core.api, parameters);
+        output = fn;
+        return fn;
+      }
+      output = hook;
+      return hook;
+    } catch (e) {
+      this.catcher(e, plugin, hookName);
+      return null;
+    } finally {
+      this.addExecutedToCallStack({
+        parameters,
+        output,
+        strategy,
+        hookName,
+        plugin
+      });
+    }
+  }
+  catcher(e, plugin, hookName) {
+    const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
+`;
+    const pluginError = new PluginError(text, { cause: e, pluginManager: this });
+    this.eventEmitter.emit("error", pluginError);
+    throw pluginError;
+  }
+};
+function noReturn() {
+}
+
+// src/managers/pluginManager/validate.ts
+var ValidationPluginError = class extends Error {
+};
+function validatePlugins(plugins, dependedPluginNames) {
+  let pluginNames = [];
+  if (typeof dependedPluginNames === "string") {
+    pluginNames = [dependedPluginNames];
+  } else {
+    pluginNames = dependedPluginNames;
+  }
+  pluginNames.forEach((pluginName2) => {
+    const exists = plugins.some((plugin) => plugin.name === pluginName2);
+    if (!exists) {
+      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
+    }
+  });
+  return true;
+}
+
+// src/types.ts
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
+};
+
+// src/build.ts
+async function transformReducer(_previousCode, result, _plugin) {
+  return result;
+}
+async function build(options) {
+  const { config, logLevel, logger = createLogger() } = options;
+  try {
+    if (!URLPath.isURL(config.input.path)) {
+      await read(config.input.path);
+    }
+  } catch (e) {
+    throw new Error(
+      "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
+      {
+        cause: e
+      }
+    );
+  }
+  if (config.output.clean) {
+    await clean(config.output.path);
+  }
+  const queueTask = async (file) => {
+    const { path } = file;
+    let code = getFileSource(file);
+    const { result: loadedResult } = await pluginManager.hookFirst({
+      hookName: "load",
+      parameters: [path]
+    });
+    if (loadedResult && isPromise(loadedResult)) {
+      code = await loadedResult;
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
+      code = loadedResult;
+    }
+    if (code) {
+      const transformedCode = await pluginManager.hookReduceArg0({
+        hookName: "transform",
+        parameters: [code, path],
+        reduce: transformReducer
+      });
+      if (config.output.write || config.output.write === void 0) {
+        await pluginManager.hookParallel({
+          hookName: "writeFile",
+          parameters: [transformedCode, path]
+        });
+      }
+    }
+  };
+  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
+  const { plugins, fileManager } = pluginManager;
+  pluginManager.on("execute", (executer) => {
+    const { hookName, plugin, output, parameters } = executer;
+    const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
+    if (logLevel === LogLevel.info) {
+      if (logger.spinner) {
+        logger.spinner.suffixText = messsage;
+      }
+    }
+    if (logLevel === LogLevel.debug) {
+      logger.info(messsage);
+      const logs = [
+        parameters && `${pc3__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(parameters, void 0, 2),
+        output && `${pc3__default.default.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output
+      ].filter(Boolean);
+      console.log(logs.join("\n"));
+    }
+  });
+  await pluginManager.hookParallel({
+    hookName: "validate",
+    parameters: [plugins]
+  });
+  await pluginManager.hookParallel({
+    hookName: "buildStart",
+    parameters: [config]
+  });
+  await pluginManager.hookParallel({ hookName: "buildEnd" });
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager };
+}
+
+// src/config.ts
+function defineConfig(options) {
+  return options;
+}
+
+// src/generators/Generator.ts
+var Generator = class {
+  _options = {};
+  constructor(options = {}) {
+    if (options) {
+      this._options = {
+        ...this._options,
+        ...options
+      };
+    }
+    return this;
+  }
+  get options() {
+    return this._options;
+  }
+};
+
+// src/generators/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
+
+// src/index.ts
+var src_default = build;
+
+Object.defineProperty(exports, 'pc', {
+  enumerable: true,
+  get: function () { return pc3__default.default; }
+});
+exports.FileManager = FileManager;
+exports.Generator = Generator;
+exports.LogLevel = LogLevel;
+exports.ParallelPluginError = ParallelPluginError;
+exports.PluginError = PluginError;
+exports.PluginManager = PluginManager;
+exports.Queue = Queue;
+exports.SchemaGenerator = SchemaGenerator;
+exports.SummaryError = SummaryError;
+exports.TreeNode = TreeNode;
+exports.URLPath = URLPath;
+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.defaultColours = defaultColours;
+exports.defineConfig = defineConfig;
+exports.extensions = extensions;
+exports.getEncodedText = getEncodedText;
+exports.getFileSource = getFileSource;
+exports.getIndexes = getIndexes;
+exports.getLocation = getLocation;
+exports.getPathMode = getPathMode;
+exports.getRelativePath = getRelativePath;
+exports.getUniqueName = getUniqueName;
+exports.hooks = hooks;
+exports.importModule = importModule;
+exports.isExtensionAllowed = isExtensionAllowed;
+exports.isPromise = isPromise;
+exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
+exports.isPromiseRejectedResult = isPromiseRejectedResult;
+exports.name = pluginName;
+exports.nameSorter = nameSorter;
+exports.normalizeDirectory = normalizeDirectory;
+exports.objectToParameters = objectToParameters;
+exports.pluginName = pluginName;
+exports.randomColour = randomColour;
+exports.randomPicoColour = randomPicoColour;
+exports.read = read;
+exports.renderTemplate = renderTemplate;
+exports.throttle = throttle;
+exports.timeout = timeout;
+exports.transformReservedWord = transformReservedWord;
+exports.uniqueIdFactory = uniqueIdFactory;
+exports.validatePlugins = validatePlugins;
+exports.write = write;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map