@kubb/core 1.14.0 → 1.14.2

package/dist/index.js

@@ -2,19 +2,19 @@ import mod, { createRequire } from 'module';
 import pc3 from 'picocolors';
 export { default as pc } from 'picocolors';
 import crypto from 'crypto';
-import pathParser2 from 'path';
-import fs, { remove } from 'fs-extra';
-import { switcher } from 'js-runtime';
-import { performance } from 'perf_hooks';
-import dirTree from 'directory-tree';
-import os from 'os';
-import { pathToFileURL } from 'url';
-import seedrandom from 'seedrandom';
+import fs2, { remove } from 'fs-extra';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { orderBy } from 'natural-orderby';
+import { performance } from 'perf_hooks';
+import seedrandom from 'seedrandom';
+import pathParser from 'path';
+import { switcher } from 'js-runtime';
+import dirTree from 'directory-tree';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/parser';
 import isEqual from 'lodash.isequal';
 import { EventEmitter as EventEmitter$1 } from 'events';
+import os from 'os';
+import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
 import { coerce, satisfies } from 'semver';
 
@@ -28,49 +28,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// 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.dirname(pathParser2.resolve(path));
-  await fs.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path, data) => {
-      try {
-        await fs.stat(path);
-        const oldContent = await fs.readFile(path, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path);
-      return fs.writeFile(pathParser2.resolve(path), data, { encoding: "utf-8" });
-    },
-    bun: async (path, data) => {
-      try {
-        await saveCreateDirectory(path);
-        await Bun.write(pathParser2.resolve(path), data);
-      } catch (e) {
-        console.log(e, pathParser2.resolve(path));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path) {
-  return writer(path, data);
-}
-
 // src/utils/cache.ts
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
   return {
@@ -98,6 +55,211 @@ function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
     }
   };
 }
+async function clean(path) {
+  return remove(path);
+}
+var FunctionParams = class {
+  type;
+  items = [];
+  constructor(type) {
+    this.type = type;
+    return this;
+  }
+  add(item) {
+    if (!item) {
+      return this;
+    }
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => this.items.push(it));
+      return this;
+    }
+    this.items.push(item);
+    return this;
+  }
+  toString() {
+    const sortedData = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
+    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
+      if (!name) {
+        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        return acc;
+      }
+      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
+      if (type) {
+        if (required) {
+          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        } else {
+          acc.push(`${parameterName}?: ${type}`);
+        }
+      } else {
+        acc.push(`${parameterName}`);
+      }
+      return acc;
+    }, []).join(", ");
+  }
+};
+
+// 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/isPromise.ts
+function isPromise(result) {
+  return typeof result?.then === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+
+// src/utils/jsdoc.ts
+function createJSDocBlockText({ comments }) {
+  const filteredComments = comments.filter(Boolean);
+  if (!filteredComments.length) {
+    return "";
+  }
+  return `/**
+ * ${filteredComments.join("\n * ")}
+ */`;
+}
+function createLogger(spinner) {
+  const logs = [];
+  const log = (message) => {
+    if (message && spinner) {
+      spinner.text = message;
+      logs.push(message);
+    }
+  };
+  const error = (message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
+    }
+  };
+  const warn = (message) => {
+    if (message && spinner) {
+      spinner.warn(pc3.yellow(message));
+      logs.push(message);
+    }
+  };
+  const info = (message) => {
+    if (message && spinner) {
+      spinner.info(message);
+      logs.push(message);
+    }
+  };
+  const logger = {
+    log,
+    error,
+    warn,
+    info,
+    spinner,
+    logs
+  };
+  return logger;
+}
+
+// src/utils/nameSorter.ts
+function nameSorter(a, b) {
+  if (a.name < b.name) {
+    return -1;
+  }
+  if (a.name > b.name) {
+    return 1;
+  }
+  return 0;
+}
+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;
+  }
+  get count() {
+    return this.#workerCount;
+  }
+  #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--;
+  }
+};
+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);
+}
 function slash(path, platform = "linux") {
   const isWindowsPath = /^\\\\\?\\/.test(path);
   if (["linux", "mac"].includes(platform) && !isWindowsPath) {
@@ -109,23 +271,23 @@ 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 relativePath = pathParser.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(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)));
   }
-  return `./${path.replace(pathParser2.basename(path), pathParser2.basename(path, pathParser2.extname(filePath)))}`;
+  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`;
 }
 function getPathMode(path) {
   if (!path) {
     return "directory";
   }
-  return pathParser2.extname(path) ? "file" : "directory";
+  return pathParser.extname(path) ? "file" : "directory";
 }
 var reader = switcher(
   {
     node: async (path) => {
-      return fs.readFile(path, { encoding: "utf8" });
+      return fs2.readFile(path, { encoding: "utf8" });
     },
     bun: async (path) => {
       const file = Bun.file(path);
@@ -137,7 +299,7 @@ var reader = switcher(
 var syncReader = switcher(
   {
     node: (path) => {
-      return fs.readFileSync(path, { encoding: "utf8" });
+      return fs2.readFileSync(path, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -152,38 +314,66 @@ function readSync(path) {
   return syncReader(path);
 }
 
-// src/utils/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
   }
-  return 0;
+  const matches = template.match(/{{(.*?)}}/g);
+  return matches?.reduce((prev, curr) => {
+    const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
+    if (index === void 0) {
+      return prev;
+    }
+    const value = data[index];
+    if (value === void 0) {
+      return prev;
+    }
+    return prev.replace(curr, () => {
+      if (typeof value === "boolean") {
+        return `${value.toString()}` || "false";
+      }
+      return value || "";
+    }).trim();
+  }, template) || "";
 }
 
-// src/utils/jsdoc.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
+// 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 || [];
   }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
-}
+};
 
-// 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/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/timeout.ts
 async function timeout(ms) {
@@ -193,64 +383,11 @@ async function timeout(ms) {
     }, 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;
-  }
-  get count() {
-    return this.#workerCount;
-  }
-  #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/transformers/combineCodes.ts
+function combineCodes(codes) {
+  return codes.join("\n");
+}
 
 // src/utils/transformers/escape.ts
 function escape(text) {
@@ -369,38 +506,6 @@ function transformReservedWord(word) {
   }
   return word;
 }
-
-// src/utils/transformers/combineCodes.ts
-function combineCodes(codes) {
-  return codes.join("\n");
-}
-
-// 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 index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
-    if (index === void 0) {
-      return prev;
-    }
-    const value = data[index];
-    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 remove(path);
-}
 var TreeNode = class _TreeNode {
   data;
   parent;
@@ -491,144 +596,11 @@ var TreeNode = class _TreeNode {
 
 // 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.createRequire(normalizeDirectory(cwd));
-    location = require2.resolve(path);
-  }
-  return location;
-}
-async function importModule(path, cwd) {
-  try {
-    let location = getLocation(path, cwd);
-    if (os.platform() == "win32") {
-      location = 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 logs = [];
-  const log = (message) => {
-    if (message && spinner) {
-      spinner.text = message;
-      logs.push(message);
-    }
-  };
-  const error = (message) => {
-    if (message) {
-      throw new Error(message || "Something went wrong");
-    }
-  };
-  const warn = (message) => {
-    if (message && spinner) {
-      spinner.warn(pc3.yellow(message));
-      logs.push(message);
-    }
-  };
-  const info = (message) => {
-    if (message && spinner) {
-      spinner.info(message);
-      logs.push(message);
-    }
-  };
-  const logger = {
-    log,
-    error,
-    warn,
-    info,
-    spinner,
-    logs
-  };
-  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(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 {
+var URLPath = class {
   path;
   constructor(path) {
     this.path = path;
+    return this;
   }
   /**
    * Convert Swagger path to URLPath(syntax of Express)
@@ -637,8 +609,16 @@ var URLPath = class _URLPath {
   get URL() {
     return this.toURLPath();
   }
-  get isUrl() {
-    return _URLPath.isURL(this.path);
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
   }
   /**
    * Convert Swagger path to template literals/ template strings(camelcase)
@@ -655,17 +635,18 @@ var URLPath = class _URLPath {
   get params() {
     return this.getParams();
   }
-  toObject(options = {}) {
-    return _URLPath.toObject(this.path, options);
-  }
-  /**
-   * 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(replacer) {
-    return _URLPath.toTemplateString(this.path, replacer);
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type !== "template") {
+        throw new Error("Type should be `template` when using stringiyf");
+      }
+      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+    }
+    return object;
   }
   /**
    * Convert Swagger path to template literals/ template strings(camelcase)
@@ -673,25 +654,22 @@ var URLPath = class _URLPath {
    * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
    * @example /account/userID => `/account/${userId}`
    */
-  static toTemplateString(path, replacer) {
+  toTemplateString(replacer) {
     const regex = /{(\w|-)*}/g;
-    const found = path.match(regex);
-    let newPath = path.replaceAll("{", "${");
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
     if (found) {
       newPath = found.reduce((prev, curr) => {
         const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
         const replacement = `\${${pathParam}}`;
         return prev.replace(curr, replacement);
-      }, path);
+      }, this.path);
     }
     return `\`${newPath}\``;
   }
   getParams(replacer) {
-    return _URLPath.getParams(this.path, replacer);
-  }
-  static getParams(path, replacer) {
     const regex = /{(\w|-)*}/g;
-    const found = path.match(regex);
+    const found = this.path.match(regex);
     if (!found) {
       return void 0;
     }
@@ -700,7 +678,7 @@ var URLPath = class _URLPath {
       item = item.replaceAll("{", "").replaceAll("}", "");
       const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
       params[pathParam] = pathParam;
-    }, path);
+    }, this.path);
     return params;
   }
   /**
@@ -708,77 +686,61 @@ var URLPath = class _URLPath {
    * @example /pet/{petId} => /pet/:petId
    */
   toURLPath() {
-    return _URLPath.toURLPath(this.path);
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
   }
-  static toURLPath(path) {
-    return path.replaceAll("{", ":").replaceAll("}", "");
+};
+
+// src/utils/Warning.ts
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  static toObject(path, { type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? _URLPath.toURLPath(path) : _URLPath.toTemplateString(path, replacer),
-      params: _URLPath.getParams(path)
-    };
-    if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
+};
+async function saveCreateDirectory(path) {
+  const passedPath = pathParser.dirname(pathParser.resolve(path));
+  await fs2.mkdir(passedPath, { recursive: true });
+}
+var writer = switcher(
+  {
+    node: async (path, data) => {
+      try {
+        await fs2.stat(path);
+        const oldContent = await fs2.readFile(path, { encoding: "utf-8" });
+        if (oldContent?.toString() === data) {
+          return;
+        }
+      } catch (_err) {
       }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-    }
-    return object;
-  }
-  static isURL(path) {
-    try {
-      const url = new URL(path);
-      if (url?.href) {
-        return true;
+      await saveCreateDirectory(path);
+      return fs2.writeFile(pathParser.resolve(path), data, { encoding: "utf-8" });
+    },
+    bun: async (path, data) => {
+      try {
+        await saveCreateDirectory(path);
+        await Bun.write(pathParser.resolve(path), data);
+      } catch (e) {
+        console.log(e, pathParser.resolve(path));
       }
-    } catch (error) {
-      return false;
-    }
-    return false;
-  }
-};
-var FunctionParams = class {
-  type;
-  items = [];
-  constructor(type) {
-    this.type = type;
-    return this;
-  }
-  add(item) {
-    if (!item) {
-      return this;
     }
-    if (Array.isArray(item)) {
-      item.filter(Boolean).forEach((it) => this.items.push(it));
-      return this;
+  },
+  "node"
+);
+async function write(data, path) {
+  return writer(path, data);
+}
+function getIndexes(root, extName, options = {}) {
+  const extMapper = {
+    ".ts": {
+      extensions: /\.ts/,
+      exclude: [/schemas/, /json/]
+    },
+    ".json": {
+      extensions: /\.json/,
+      exclude: []
     }
-    this.items.push(item);
-    return this;
-  }
-  toString() {
-    const sortedData = orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
-    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
-      if (!name) {
-        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        return acc;
-      }
-      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
-      if (type) {
-        if (required) {
-          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        } else {
-          acc.push(`${parameterName}?: ${type}`);
-        }
-      } else {
-        acc.push(`${parameterName}`);
-      }
-      return acc;
-    }, []).join(", ");
-  }
-};
-function getIndexes(root, options = {}) {
-  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  };
+  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
   if (!tree) {
     return null;
   }
@@ -787,7 +749,7 @@ function getIndexes(root, options = {}) {
       return [];
     }
     if (currentTree.children?.length > 1) {
-      const path = pathParser2.resolve(currentTree.data.path, "index.ts");
+      const path = pathParser.resolve(currentTree.data.path, "index.ts");
       const exports = currentTree.children.map((file) => {
         if (!file) {
           return void 0;
@@ -806,7 +768,7 @@ function getIndexes(root, options = {}) {
       });
     } else {
       currentTree.children?.forEach((child) => {
-        const path = pathParser2.resolve(currentTree.data.path, "index.ts");
+        const path = pathParser.resolve(currentTree.data.path, "index.ts");
         const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
         files2.push({
           path,
@@ -979,6 +941,7 @@ var FileManager = class {
       this.#task = options.task;
       this.#queue = options.queue;
     }
+    return this;
   }
   get extensions() {
     return extensions;
@@ -1011,7 +974,7 @@ var FileManager = class {
     }
     return resolvedFile;
   }
-  addOrAppend(file) {
+  async addOrAppend(file) {
     const previousCaches = this.#cache.get(file.path);
     const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
     if (previousCache) {
@@ -1027,6 +990,20 @@ ${file.source}` : "",
     }
     return this.add(file);
   }
+  async addIndexes(root, extName = ".ts", options = {}) {
+    const files = await getIndexes(root, extName, options);
+    if (!files) {
+      return void 0;
+    }
+    return Promise.all(
+      files.map((file) => {
+        if (file.override) {
+          return this.add(file);
+        }
+        return this.addOrAppend(file);
+      })
+    );
+  }
   #append(path, file) {
     const previousFiles = this.#cache.get(path) || [];
     this.#cache.set(path, [...previousFiles, file]);
@@ -1065,6 +1042,44 @@ ${file.source}` : "",
     return read(...params);
   }
 };
+
+// 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;
+  }
+};
 function createPlugin(factory) {
   return (options) => {
     const plugin = factory(options);
@@ -1112,8 +1127,8 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = pathParser2.resolve(this.config.root, this.config.output.path);
-      return pathParser2.resolve(root, baseName);
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      return pathParser.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
@@ -1139,54 +1154,22 @@ var EventEmitter = class {
   }
 };
 
-// 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;
-  }
-};
-
 // src/managers/pluginManager/pluginParser.ts
+var usedPluginNames = {};
 function pluginParser(plugin, context) {
+  const key = [plugin.kind, plugin.name, getUniqueName(plugin.name, usedPluginNames).split(plugin.name).at(1)];
   if (plugin.api && typeof plugin.api === "function") {
     const api = plugin.api.call(context);
     return {
       ...plugin,
+      key,
       api
     };
   }
-  return null;
+  return {
+    ...plugin,
+    key
+  };
 }
 
 // src/managers/pluginManager/PluginManager.ts
@@ -1220,16 +1203,15 @@ var PluginManager = class {
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this)
+      getPlugins: this.#getSortedPlugins.bind(this),
+      plugin: void 0
     });
     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];
+      return [...prev, convertedApi];
     }, []);
+    return this;
   }
   resolvePath = (params) => {
     if (params.pluginName) {
@@ -1250,8 +1232,8 @@ var PluginManager = class {
         pluginName: params.pluginName,
         hookName: "resolveName",
         parameters: [params.name, params.type]
-      }) || params.name;
-      return transformReservedWord(name2);
+      });
+      return transformReservedWord(name2 || params.name);
     }
     const name = this.hookFirstSync({
       hookName: "resolveName",
@@ -1263,7 +1245,6 @@ var PluginManager = class {
     this.eventEmitter.on(eventName, handler);
   }
   /**
-   *
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
@@ -1293,7 +1274,6 @@ var PluginManager = class {
     });
   }
   /**
-   *
    * Chains, first non-null result stops and returns
    */
   hookFirst({
@@ -1316,16 +1296,17 @@ var PluginManager = class {
           parameters,
           plugin
         });
-        return Promise.resolve({
-          plugin,
-          result: value
-        });
+        return Promise.resolve(
+          {
+            plugin,
+            result: value
+          }
+        );
       });
     }
     return promise;
   }
   /**
-   *
    * Chains, first non-null result stops and returns
    */
   hookFirstSync({
@@ -1354,7 +1335,6 @@ var PluginManager = class {
     return parseResult;
   }
   /**
-   *
    * Parallel, runs all plugins
    */
   async hookParallel({
@@ -1381,7 +1361,6 @@ var PluginManager = class {
     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({
@@ -1410,14 +1389,14 @@ var PluginManager = class {
   hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.#getSortedPlugins()) {
-      promise = promise.then(
-        () => this.#execute({
+      promise = promise.then(() => {
+        this.#execute({
           strategy: "hookSeq",
           hookName,
           parameters,
           plugin
-        })
-      );
+        });
+      });
     }
     return promise.then(noReturn);
   }
@@ -1463,7 +1442,7 @@ var PluginManager = class {
     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);
+        const possiblePromiseResult = hook.apply({ ...this.#core.api, plugin }, parameters);
         if (isPromise(possiblePromiseResult)) {
           return Promise.resolve(possiblePromiseResult);
         }
@@ -1571,7 +1550,7 @@ async function transformReducer(_previousCode, result, _plugin) {
 async function build(options) {
   const { config, logLevel, logger = createLogger() } = options;
   try {
-    if ("path" in config.input && !URLPath.isURL(config.input.path)) {
+    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
@@ -1651,12 +1630,76 @@ async function build(options) {
 function defineConfig(options) {
   return options;
 }
+
+// src/generators/Generator.ts
+var Generator = class {
+  #options = {};
+  #context = {};
+  constructor(options, context) {
+    if (context) {
+      this.#context = context;
+    }
+    if (options) {
+      this.#options = options;
+    }
+    return this;
+  }
+  get options() {
+    return this.#options;
+  }
+  get context() {
+    return this.#context;
+  }
+  set options(options) {
+    this.#options = { ...this.#options, ...options };
+  }
+};
+
+// src/generators/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
 var PackageManager = class {
   #cwd;
-  constructor(workspace = process.cwd()) {
-    this.#cwd = workspace;
+  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+  constructor(workspace) {
+    if (workspace) {
+      this.#cwd = workspace;
+    }
     return this;
   }
+  set workspace(workspace) {
+    this.#cwd = workspace;
+  }
+  get workspace() {
+    return this.#cwd;
+  }
+  normalizeDirectory(directory) {
+    if (!this.#SLASHES.has(directory[directory.length - 1])) {
+      return `${directory}/`;
+    }
+    return directory;
+  }
+  getLocation(path) {
+    let location = path;
+    if (this.#cwd) {
+      const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
+      location = require2.resolve(path);
+    }
+    return location;
+  }
+  async import(path) {
+    try {
+      let location = this.getLocation(path);
+      if (os.platform() == "win32") {
+        location = pathToFileURL(location).href;
+      }
+      const module = await import(location);
+      return module?.default ?? module;
+    } catch (e) {
+      console.log(e);
+      return void 0;
+    }
+  }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
       cwd: this.#cwd
@@ -1713,37 +1756,9 @@ var PackageManager = class {
   }
 };
 
-// src/generators/Generator.ts
-var Generator = class {
-  #options = {};
-  #context = {};
-  constructor(options, context) {
-    if (context) {
-      this.#context = context;
-    }
-    if (options) {
-      this.#options = options;
-    }
-    return this;
-  }
-  get options() {
-    return this.#options;
-  }
-  get context() {
-    return this.#context;
-  }
-  set options(options) {
-    this.#options = { ...this.#options, ...options };
-  }
-};
-
-// src/generators/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
-
 // src/index.ts
 var src_default = build;
 
-export { FileManager, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getLocation, getPathMode, getRelativePath, getUniqueName, hooks, importModule, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, normalizeDirectory, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
+export { FileManager, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getPathMode, getRelativePath, getUniqueName, hooks, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map