@kubb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/utils.cjs

@@ -1,48 +1,14 @@
 'use strict';
 
-var fs2 = require('fs-extra');
-var changeCase = require('change-case');
 var naturalOrderby = require('natural-orderby');
-var pc2 = require('picocolors');
+var changeCase = require('change-case');
 var crypto = require('crypto');
 var perf_hooks = require('perf_hooks');
 var events = require('events');
-var seedrandom = require('seedrandom');
-var path = require('path');
-var jsRuntime = require('js-runtime');
-var dirTree = require('directory-tree');
-var parser = require('@kubb/parser');
-var factory = require('@kubb/parser/factory');
-var isEqual = require('lodash.isequal');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
-var pc2__default = /*#__PURE__*/_interopDefault(pc2);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
-var path__default = /*#__PURE__*/_interopDefault(path);
-var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
-var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
-var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -74,376 +40,30 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-
-// 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 camelCase(text) {
+  return changeCase.camelCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.camelCaseTransformMerge });
 }
-async function clean(path2) {
-  return fs2.remove(path2);
-}
-var FunctionParams = class {
-  constructor(type) {
-    this.items = [];
-    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 = naturalOrderby.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 : changeCase.camelCase(name, { delimiter: "", transform: changeCase.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(", ");
-  }
-};
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
-};
-function createLogger({ logLevel, name, 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(pc2__default.default.yellow(message));
-      logs.push(message);
-    }
-  };
-  const info = (message) => {
-    if (message && spinner && logLevel !== LogLevel.silent) {
-      spinner.info(message);
-      logs.push(message);
-    }
-  };
-  const logger = {
-    name,
-    logLevel,
-    log,
-    error,
-    warn,
-    info,
-    spinner,
-    logs
-  };
-  return logger;
+function pascalCase(text) {
+  return changeCase.pascalCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.pascalCaseTransformMerge });
 }
 
-// src/utils/promise.ts
-function isPromise(result) {
-  return !!result && typeof result?.then === "function";
-}
-function isPromiseFulfilledResult(result) {
-  return result.status === "fulfilled";
-}
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
-}
-var _emitter;
-var EventEmitter = class {
-  constructor() {
-    __privateAdd(this, _emitter, new events.EventEmitter());
-    __privateGet(this, _emitter).setMaxListeners(100);
-  }
-  emit(eventName, ...eventArg) {
-    __privateGet(this, _emitter).emit(eventName, ...eventArg);
-  }
-  on(eventName, handler) {
-    __privateGet(this, _emitter).on(eventName, handler);
-  }
-  off(eventName, handler) {
-    __privateGet(this, _emitter).off(eventName, handler);
-  }
-  removeAll() {
-    __privateGet(this, _emitter).removeAllListeners();
-  }
-};
-_emitter = new WeakMap();
-
-// src/utils/Queue.ts
-var _queue, _workerCount, _maxParallel, _debug, _work, work_fn;
-var Queue = class {
-  constructor(maxParallel, debug = false) {
-    __privateAdd(this, _work);
-    __privateAdd(this, _queue, []);
-    this.eventEmitter = new EventEmitter();
-    __privateAdd(this, _workerCount, 0);
-    __privateAdd(this, _maxParallel, void 0);
-    __privateAdd(this, _debug, false);
-    __privateSet(this, _maxParallel, maxParallel);
-    __privateSet(this, _debug, debug);
-  }
-  run(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
-        reject("Aborted");
-      });
-      __privateGet(this, _queue).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
-  }
-  runSync(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
-      });
-      __privateGet(this, _queue).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
-  }
-  get hasJobs() {
-    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue).length > 0;
-  }
-  get count() {
-    return __privateGet(this, _workerCount);
-  }
-};
-_queue = new WeakMap();
-_workerCount = new WeakMap();
-_maxParallel = new WeakMap();
-_debug = new WeakMap();
-_work = new WeakSet();
-work_fn = function() {
-  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
-    return;
-  }
-  __privateWrapper(this, _workerCount)._++;
-  let entry;
-  while (entry = __privateGet(this, _queue).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
-    if (__privateGet(this, _debug)) {
-      perf_hooks.performance.mark(name + "_start");
-    }
-    job().then((result) => {
-      this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
-      if (__privateGet(this, _debug)) {
-        perf_hooks.performance.mark(name + "_stop");
-        perf_hooks.performance.measure(description, name + "_start", name + "_stop");
-      }
-    }).catch((err) => {
-      this.eventEmitter.emit("jobFailed", err);
-      reject(err);
-    });
-  }
-  __privateWrapper(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__default.default(text);
-  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
-  return colour;
-}
-function randomPicoColour(text, colors = defaultColours) {
-  const colours = pc2__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 pc2__default.default.bold(formatter(text));
-  }
-  if (typeof formatter !== "function") {
-    throw new Error("Formatter for picoColor is not of type function/Formatter");
-  }
-  return formatter(text);
-}
-function slash(path2, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path2);
-  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path2.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-  }
-  return path2.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 = path.relative(rootDir, filePath);
-  const slashedPath = slash(relativePath, platform);
-  if (slashedPath.startsWith("../")) {
-    return slashedPath.replace(path.basename(slashedPath), path.basename(slashedPath, path.extname(filePath)));
-  }
-  return `./${slashedPath.replace(path.basename(slashedPath), path.basename(slashedPath, path.extname(filePath)))}`;
-}
-var reader = jsRuntime.switcher(
-  {
-    node: async (path2) => {
-      return fs2__default.default.readFile(path2, { encoding: "utf8" });
-    },
-    bun: async (path2) => {
-      const file = Bun.file(path2);
-      return file.text();
-    }
-  },
-  "node"
-);
-var syncReader = jsRuntime.switcher(
-  {
-    node: (path2) => {
-      return fs2__default.default.readFileSync(path2, { encoding: "utf8" });
-    },
-    bun: () => {
-      throw new Error("Bun cannot read sync");
-    }
-  },
-  "node"
-);
-async function read(path2) {
-  return reader(path2);
-}
-function readSync(path2) {
-  return syncReader(path2);
-}
-
-// 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) || "";
-}
-
-// 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) {
-  return new Promise((resolve2) => {
-    setTimeout(() => {
-      resolve2(true);
-    }, ms);
-  });
-}
-
-// src/utils/transformers/combineCodes.ts
+// src/transformers/combineCodes.ts
 function combineCodes(codes) {
   return codes.join("\n");
 }
 
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments, newLine }) {
+// src/transformers/createJSDocBlockText.ts
+function createJSDocBlockText({ comments }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
     return "";
   }
-  const source = `/**
+  return `/**
  * ${filteredComments.join("\n * ")}
  */`;
-  if (newLine) {
-    return `${source}
-`;
-  }
-  return source;
 }
 
-// src/utils/transformers/escape.ts
+// src/transformers/escape.ts
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
 }
@@ -468,12 +88,12 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/indent.ts
+// src/transformers/indent.ts
 function createIndent(size) {
   return Array.from({ length: size + 1 }).join(" ");
 }
 
-// src/utils/transformers/nameSorter.ts
+// src/transformers/nameSorter.ts
 function nameSorter(a, b) {
   if (a.name < b.name) {
     return -1;
@@ -484,7 +104,7 @@ function nameSorter(a, b) {
   return 0;
 }
 
-// src/utils/transformers/searchAndReplace.ts
+// src/transformers/searchAndReplace.ts
 function searchAndReplace(options) {
   const { text, replaceBy, prefix = "", key } = options;
   const searchValues = options.searchValues?.(prefix, key) || [
@@ -501,7 +121,7 @@ function searchAndReplace(options) {
   }, text);
 }
 
-// src/utils/transformers/transformReservedWord.ts
+// src/transformers/transformReservedWord.ts
 var reservedWords = [
   "abstract",
   "arguments",
@@ -594,13 +214,16 @@ function transformReservedWord(word) {
   return word;
 }
 
-// src/utils/transformers/trim.ts
+// src/transformers/trim.ts
 function trim(text) {
   return text.replaceAll(/\n/g, "").trim();
 }
+function trimExtName(text) {
+  return text.replace(/\.[^/.]+$/, "");
+}
 
-// src/utils/transformers/index.ts
-var transformers = {
+// src/transformers/index.ts
+var transformers_default = {
   combineCodes,
   escape,
   jsStringEscape,
@@ -609,522 +232,189 @@ var transformers = {
   nameSorter,
   searchAndReplace,
   trim,
+  trimExtName,
   JSDoc: {
     createJSDocBlockText
-  }
+  },
+  camelCase,
+  pascalCase
 };
-async function saveCreateDirectory(path2) {
-  const passedPath = path.dirname(path.resolve(path2));
-  await fs2__default.default.mkdir(passedPath, { recursive: true });
-}
-var writer = jsRuntime.switcher(
-  {
-    node: async (path2, data) => {
-      try {
-        await fs2__default.default.stat(path.resolve(path2));
-        const oldContent = await fs2__default.default.readFile(path.resolve(path2), { encoding: "utf-8" });
-        if (oldContent?.toString() === data?.toString()) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path2);
-      await fs2__default.default.writeFile(path.resolve(path2), data, { encoding: "utf-8" });
-      const savedData = await fs2__default.default.readFile(path.resolve(path2), { encoding: "utf-8" });
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path2}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-      }
-      return savedData;
-    },
-    bun: async (path2, data) => {
-      try {
-        await saveCreateDirectory(path2);
-        await Bun.write(path.resolve(path2), data);
-        const file = Bun.file(path.resolve(path2));
-        const savedData = await file.text();
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path2}
 
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-        }
-        return savedData;
-      } catch (e) {
-        console.log(e, path.resolve(path2));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path2) {
-  if (data.trim() === "") {
-    return void 0;
-  }
-  return writer(path2, data.trim());
-}
-var _options;
-var BarrelManager = class {
-  constructor(options = {}) {
-    __privateAdd(this, _options, {});
-    __privateSet(this, _options, options);
+// src/utils/FunctionParams.ts
+var FunctionParams = class {
+  constructor(type) {
+    this.items = [];
+    this.type = type;
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
-      }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
-    if (!tree) {
-      return null;
+  add(item) {
+    if (!item) {
+      return this;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
-        return [];
-      }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path__default.default.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && file.data.type === "file") {
-            return void 0;
-          }
-          return {
-            path: includeExt ? `${importPath}${extName}` : importPath,
-            isTypeOnly
-          };
-        }).filter(Boolean);
-        files2.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
-        });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path__default.default.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
-        });
-      }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
-      });
-      return files2;
-    };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
-  }
-};
-_options = new WeakMap();
-var _cache, _task, _isWriting, _timeout, _queue2, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
-var _FileManager = class _FileManager {
-  constructor(options) {
-    __privateAdd(this, _validate);
-    __privateAdd(this, _add);
-    __privateAdd(this, _addOrAppend);
-    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
-    __privateAdd(this, _task, void 0);
-    __privateAdd(this, _isWriting, false);
-    /**
-     * Timeout between writes
-     */
-    __privateAdd(this, _timeout, 0);
-    __privateAdd(this, _queue2, void 0);
-    if (options) {
-      __privateSet(this, _task, options.task);
-      __privateSet(this, _queue2, options.queue);
-      __privateSet(this, _timeout, options.timeout || 0);
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => this.items.push(it));
+      return this;
     }
+    this.items.push(item);
     return this;
   }
-  get files() {
-    const files = [];
-    __privateGet(this, _cache).forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
-  }
-  get isExecuting() {
-    return __privateGet(this, _queue2)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
-  }
-  async add(...files) {
-    const promises = files.map((file) => {
-      __privateMethod(this, _validate, validate_fn).call(this, file);
-      if (file.override) {
-        return __privateMethod(this, _add, add_fn).call(this, file);
-      }
-      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
-    });
-    const resolvedFiles = await Promise.all(promises);
-    if (files.length > 1) {
-      return resolvedFiles;
-    }
-    return resolvedFiles[0];
-  }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
-    if (!files) {
-      return void 0;
-    }
-    return await Promise.all(
-      files.map((file) => {
-        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
-          ...file,
-          meta: meta ? meta : file.meta
-        });
-      })
-    );
-  }
-  getCacheByUUID(UUID) {
-    let cache;
-    __privateGet(this, _cache).forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
-    });
-    return cache;
-  }
-  get(path2) {
-    return __privateGet(this, _cache).get(path2);
-  }
-  remove(path2) {
-    const cacheItem = this.get(path2);
-    if (!cacheItem) {
-      return;
-    }
-    __privateGet(this, _cache).delete(path2);
-  }
-  async write(...params) {
-    if (!__privateGet(this, _isWriting)) {
-      __privateSet(this, _isWriting, true);
-      const text = await write(...params);
-      __privateSet(this, _isWriting, false);
-      return text;
-    }
-    await timeout(__privateGet(this, _timeout));
-    return this.write(...params);
-  }
-  async read(...params) {
-    return read(...params);
-  }
-  // statics
-  static getSource(file) {
-    if (!_FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source;
-    }
-    const exports = file.exports ? combineExports(file.exports) : [];
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory__namespace.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-    const exportNodes = exports.map(
-      (item) => factory__namespace.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    );
-    return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
-  }
-  static combineFiles(files) {
-    return files.filter(Boolean).reduce((acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
-      const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
+  toString() {
+    const sortedData = naturalOrderby.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;
       }
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
-        };
+      const parameterName = name.startsWith("{") ? name : transformers_default.camelCase(name);
+      if (type) {
+        if (required) {
+          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+        } else {
+          acc.push(`${parameterName}?: ${type}`);
+        }
+      } else {
+        acc.push(`${parameterName}`);
       }
       return acc;
-    }, []);
+    }, []).join(", ");
   }
-  static getMode(path2) {
-    if (!path2) {
-      return "directory";
-    }
-    return path.extname(path2) ? "file" : "directory";
+};
+
+// src/utils/promise.ts
+function isPromise(result) {
+  return !!result && typeof result?.then === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+var _emitter;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _emitter, new events.EventEmitter());
+    __privateGet(this, _emitter).setMaxListeners(100);
   }
-  static get extensions() {
-    return [".js", ".ts", ".tsx"];
+  emit(eventName, ...eventArg) {
+    __privateGet(this, _emitter).emit(eventName, ...eventArg);
   }
-  static isExtensionAllowed(baseName) {
-    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
+  on(eventName, handler) {
+    __privateGet(this, _emitter).on(eventName, handler);
   }
-};
-_cache = new WeakMap();
-_task = new WeakMap();
-_isWriting = new WeakMap();
-_timeout = new WeakMap();
-_queue2 = new WeakMap();
-_validate = new WeakSet();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
+  off(eventName, handler) {
+    __privateGet(this, _emitter).off(eventName, handler);
   }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
+  removeAll() {
+    __privateGet(this, _emitter).removeAllListeners();
   }
 };
-_add = new WeakSet();
-add_fn = async function(file) {
-  const controller = new AbortController();
-  const resolvedFile = { id: crypto__default.default.randomUUID(), ...file };
-  __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-  if (__privateGet(this, _queue2)) {
-    await __privateGet(this, _queue2).run(
-      async () => {
-        var _a;
-        return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
-      },
-      { controller }
-    );
+_emitter = new WeakMap();
+
+// src/utils/Queue.ts
+var _queue, _workerCount, _maxParallel, _debug, _work, work_fn;
+var Queue = class {
+  constructor(maxParallel, debug = false) {
+    __privateAdd(this, _work);
+    __privateAdd(this, _queue, []);
+    this.eventEmitter = new EventEmitter();
+    __privateAdd(this, _workerCount, 0);
+    __privateAdd(this, _maxParallel, void 0);
+    __privateAdd(this, _debug, false);
+    __privateSet(this, _maxParallel, maxParallel);
+    __privateSet(this, _debug, debug);
   }
-  return resolvedFile;
-};
-_addOrAppend = new WeakSet();
-addOrAppend_fn = async function(file) {
-  const previousCaches = __privateGet(this, _cache).get(file.path);
-  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
-  if (previousCache) {
-    __privateGet(this, _cache).delete(previousCache.path);
-    return __privateMethod(this, _add, add_fn).call(this, {
-      ...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 || {} }
+  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", () => {
+        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
+        reject("Aborted");
+      });
+      __privateGet(this, _queue).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
   }
-  return __privateMethod(this, _add, add_fn).call(this, file);
-};
-var FileManager = _FileManager;
-function combineExports(exports) {
-  const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
-    const name = curr.name;
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathAndIsTypeOnly) {
-      return prev;
-    }
-    const uniquePrev = prev.findLast(
-      (imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
-    );
-    if (uniquePrev || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) {
-      return prev;
-    }
-    if (!prevByPath) {
-      return [
-        ...prev,
-        {
-          ...curr,
-          name: Array.isArray(name) ? [...new Set(name)] : name
-        }
-      ];
-    }
-    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-      prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...curr.name])];
-      return prev;
-    }
-    return [...prev, curr];
-  }, []);
-  return naturalOrderby.orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
-}
-function combineImports(imports, exports, source) {
-  const combinedImports = naturalOrderby.orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
-    let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
-    const hasImportInSource = (importName) => {
-      if (!source) {
-        return true;
-      }
-      const checker = (name2) => name2 && !!source.includes(name2);
-      return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
-    };
-    if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item));
-    }
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathNameAndIsTypeOnly) {
-      return prev;
-    }
-    if (uniquePrev || Array.isArray(name) && !name.length) {
-      return prev;
-    }
-    if (!prevByPath) {
-      return [
-        ...prev,
-        {
-          ...curr,
-          name
-        }
-      ];
-    }
-    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-      prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...name])];
-      return prev;
-    }
-    if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-      return prev;
-    }
-    return [...prev, curr];
-  }, []);
-  return naturalOrderby.orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
-}
-function getEnvSource(source, env) {
-  if (!env) {
-    return source;
-  }
-  const keys = Object.keys(env);
-  if (!keys.length) {
-    return source;
+  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", () => {
+        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
+      });
+      __privateGet(this, _queue).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
+    });
   }
-  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 = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
-`, "ig"), ""), replaceBy, key });
-    }
-    return prev;
-  }, source);
-}
-
-// src/utils/TreeNode.ts
-var TreeNode = class _TreeNode {
-  constructor(data, parent) {
-    this.children = [];
-    this.data = data;
-    this.parent = parent;
-    return this;
+  get hasJobs() {
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue).length > 0;
   }
-  addChild(data) {
-    const child = new _TreeNode(data, this);
-    if (!this.children) {
-      this.children = [];
-    }
-    this.children.push(child);
-    return child;
+  get count() {
+    return __privateGet(this, _workerCount);
   }
-  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;
+};
+_queue = new WeakMap();
+_workerCount = new WeakMap();
+_maxParallel = new WeakMap();
+_debug = new WeakMap();
+_work = new WeakSet();
+work_fn = function() {
+  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
+    return;
   }
-  get leaves() {
-    if (!this.children || this.children.length === 0) {
-      return [this];
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue).shift()) {
+    const { reject, resolve, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      perf_hooks.performance.mark(name + "_start");
     }
-    const leaves = [];
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        leaves.push.apply(leaves, this.children[i].leaves);
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve(result);
+      if (__privateGet(this, _debug)) {
+        perf_hooks.performance.mark(name + "_stop");
+        perf_hooks.performance.measure(description, name + "_start", name + "_stop");
       }
-    }
-    return leaves;
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
-  get root() {
-    if (!this.parent) {
-      return this;
-    }
-    return this.parent.root;
+  __privateWrapper(this, _workerCount)._--;
+};
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
   }
-  forEach(callback) {
-    if (typeof callback !== "function") {
-      throw new TypeError("forEach() callback must be a function");
+  const matches = template.match(/{{(.*?)}}/g);
+  return matches?.reduce((prev, curr) => {
+    const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
+    if (index === void 0) {
+      return prev;
     }
-    callback(this);
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        this.children[i].forEach(callback);
-      }
+    const value = data[index];
+    if (value === void 0) {
+      return prev;
     }
-    return this;
-  }
-  static build(path2, options = {}) {
-    try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree__default.default(path2, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
-      if (!filteredTree) {
-        return null;
+    return prev.replace(curr, () => {
+      if (typeof value === "boolean") {
+        return `${value.toString()}` || "false";
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
-      const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(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 });
-    }
-  }
-};
+      return value || "";
+    }).trim();
+  }, template) || "";
+}
+
+// src/utils/timeout.ts
+async function timeout(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, ms);
+  });
+}
 
 // src/utils/uniqueName.ts
 function getUniqueName(originalName, data) {
@@ -1145,9 +435,11 @@ function setUniqueName(originalName, data) {
   data[originalName] = 1;
   return originalName;
 }
+
+// src/utils/URLPath.ts
 var URLPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
     return this;
   }
   /**
@@ -1211,7 +503,7 @@ var URLPath = class {
     let newPath = this.path.replaceAll("{", "${");
     if (found) {
       newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
+        const pathParam = replacer ? replacer(transformers_default.camelCase(curr)) : transformers_default.camelCase(curr);
         const replacement = `\${${pathParam}}`;
         return prev.replace(curr, replacement);
       }, this.path);
@@ -1227,7 +519,7 @@ var URLPath = class {
     const params = {};
     found.forEach((item) => {
       item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
+      const pathParam = replacer ? replacer(transformers_default.camelCase(item)) : transformers_default.camelCase(item);
       params[pathParam] = pathParam;
     }, this.path);
     return params;
@@ -1241,32 +533,15 @@ var URLPath = class {
   }
 };
 
-Object.defineProperty(exports, 'pc', {
-  enumerable: true,
-  get: function () { return pc2__default.default; }
-});
 exports.FunctionParams = FunctionParams;
-exports.LogLevel = LogLevel;
 exports.Queue = Queue;
-exports.TreeNode = TreeNode;
 exports.URLPath = URLPath;
-exports.clean = clean;
-exports.createLogger = createLogger;
-exports.createPluginCache = createPluginCache;
-exports.getRelativePath = getRelativePath;
 exports.getUniqueName = getUniqueName;
 exports.isPromise = isPromise;
 exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
 exports.isPromiseRejectedResult = isPromiseRejectedResult;
-exports.randomColour = randomColour;
-exports.randomPicoColour = randomPicoColour;
-exports.read = read;
-exports.readSync = readSync;
 exports.renderTemplate = renderTemplate;
 exports.setUniqueName = setUniqueName;
-exports.throttle = throttle;
 exports.timeout = timeout;
-exports.transformers = transformers;
-exports.write = write;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=utils.cjs.map