@kubb/core 1.4.0 → 1.4.2

package/dist/index.js

@@ -1,1519 +0,0 @@
-import { createRequire } from 'module';
-import crypto from 'node:crypto';
-import fs from 'fs-extra';
-import pathParser2 from 'node:path';
-import { camelCase, camelCaseTransformMerge } from 'change-case';
-import { performance } from 'node:perf_hooks';
-import { rimraf } from 'rimraf';
-import dirTree from 'directory-tree';
-import mod from 'node:module';
-import { pathToFileURL } from 'node:url';
-import pc3 from 'picocolors';
-export { default as pc } from 'picocolors';
-import seedrandom from 'seedrandom';
-import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
-import { EventEmitter as EventEmitter$1 } from 'node:events';
-
-createRequire(import.meta.url);
-
-// 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 safeWriteFileToPath(path, data) {
-  const passedPath = pathParser2.dirname(pathParser2.resolve(path));
-  await fs.mkdir(passedPath, { recursive: true });
-  return fs.writeFile(pathParser2.resolve(path), data, { encoding: "utf-8" });
-}
-async function write(data, path) {
-  try {
-    await fs.stat(path);
-    const oldContent = await fs.readFile(path, { encoding: "utf-8" });
-    if (oldContent?.toString() === data) {
-      return;
-    }
-  } catch (_err) {
-    return safeWriteFileToPath(path, data);
-  }
-  return safeWriteFileToPath(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.relative(rootDir, filePath);
-  const path = slash(relativePath, platform);
-  if (path.startsWith("../")) {
-    return path.replace(pathParser2.basename(path), pathParser2.basename(path, pathParser2.extname(filePath)));
-  }
-  return `./${path.replace(pathParser2.basename(path), pathParser2.basename(path, pathParser2.extname(filePath)))}`;
-}
-function getPathMode(path) {
-  if (!path) {
-    return "directory";
-  }
-  return pathParser2.extname(path) ? "file" : "directory";
-}
-async function read(path) {
-  return fs.readFile(path, { encoding: "utf8" });
-}
-function objectToParameters(data, options = {}) {
-  const { typed } = options;
-  return data.reduce((acc, [key, value]) => {
-    const parameterName = camelCase(key, { delimiter: "", transform: 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.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.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) {
-        performance.mark(name + "_start");
-      }
-      job().then((result) => {
-        resolve(result);
-        if (this.debug) {
-          performance.mark(name + "_stop");
-          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) {
-    return template.replace(/{{(.*?)}}/g, "");
-  }
-  return template.replace(/{{(.*?)}}/g, (match) => {
-    const value = data[match.split(/{{|}}/).filter(Boolean)[0].trim()];
-    return value || "";
-  });
-}
-async function clean(path) {
-  return 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(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/getStackTrace.ts
-function getStackTrace(belowFn) {
-  const oldLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = Infinity;
-  const dummyObject = {};
-  const v8Handler = Error.prepareStackTrace;
-  Error.prepareStackTrace = function prepareStackTrace(dummyObject2, v8StackTrace2) {
-    return v8StackTrace2;
-  };
-  Error.captureStackTrace(dummyObject, belowFn || getStackTrace);
-  const v8StackTrace = dummyObject.stack;
-  Error.prepareStackTrace = v8Handler;
-  Error.stackTraceLimit = oldLimit;
-  return v8StackTrace;
-}
-
-// 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) => {
-  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.yellow(message));
-    }
-  };
-  const info = (message) => {
-    if (message && spinner) {
-      spinner.info(message);
-    }
-  };
-  const logger = {
-    log,
-    error,
-    warn,
-    info,
-    spinner
-  };
-  return logger;
-}
-function canLogHierarchy(input, compareTo) {
-  if (input === "stacktrace") {
-    return canLogHierarchy("info", compareTo);
-  }
-  return input === compareTo;
-}
-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(text);
-  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
-  return colour;
-}
-function randomPicoColour(text, colors = defaultColours) {
-  const colours = pc3.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.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 = `\${${camelCase(curr, { delimiter: "", transform: 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.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.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"];
-function getFileSource(file) {
-  let { source } = file;
-  if (!extensions.some((extension) => file.fileName.endsWith(extension))) {
-    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, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
-  }, []);
-  const importSource = print(importNodes);
-  const exportNodes = exports.reduce((prev, curr) => {
-    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}`;
-  }
-  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.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) {
-      const sourceAlreadyExists = file.source && previousCache.source.includes(file.source);
-      if (sourceAlreadyExists) {
-        return Promise.resolve(previousCache);
-      }
-      previousCache.cancel?.();
-      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) {
-          const trace = getStackTrace();
-          const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
-            if (a.name.length < b.name.length) {
-              return 1;
-            }
-            if (a.name.length > b.name.length) {
-              return -1;
-            }
-            return 0;
-          });
-          const pluginName2 = plugins?.[0]?.name;
-          return Promise.all(
-            files.map((file) => {
-              const fileWithMeta = {
-                ...file,
-                meta: {
-                  ...file.meta || {},
-                  pluginName: pluginName2
-                }
-              };
-              if (file.override) {
-                return fileManager.add(fileWithMeta);
-              }
-              return fileManager.addOrAppend(fileWithMeta);
-            })
-          );
-        },
-        resolvePath,
-        resolveName: (params) => {
-          const name = resolveName(params);
-          return transformReservedWord(name);
-        },
-        cache: createPluginCache()
-      };
-    },
-    resolvePath(fileName) {
-      const root = pathParser2.resolve(this.config.root, this.config.output.path);
-      return pathParser2.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 EventEmitter$1();
-  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 this.queue.run(() => 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",
-  stacktrace: "stacktrace"
-};
-
-// src/build.ts
-async function transformReducer(_previousCode, result, _plugin) {
-  return result;
-}
-async function build(options) {
-  const { config, debug, 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.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, 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 (config.logLevel === LogLevel.info && logger?.spinner && parameters) {
-      if (debug) {
-        logger.info(messsage);
-      } else {
-        logger.spinner.suffixText = messsage;
-      }
-    }
-    if (config.logLevel === LogLevel.stacktrace && logger?.spinner && parameters) {
-      logger.info(messsage);
-      const logs = [
-        parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
-        JSON.stringify(parameters, void 0, 2),
-        output && `${pc3.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;
-
-export { FileManager, Generator, LogLevel, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, canLogHierarchy, clean, combineFiles, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, extensions, getEncodedText, getFileSource, getIndexes, getLocation, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, importModule, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, nameSorter, normalizeDirectory, objectToParameters, pluginName, randomColour, randomPicoColour, read, renderTemplate, throttle, timeout, transformReservedWord, uniqueId, validatePlugins, write };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map