@kubb/core 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/utils.js

@@ -1,19 +1,8 @@
 import { createRequire } from 'module';
-import fs2, { remove } from 'fs-extra';
 import { orderBy } from 'natural-orderby';
-import { camelCase as camelCase$1, camelCaseTransformMerge, pascalCase as pascalCase$1, pascalCaseTransformMerge } from 'change-case';
-import pc2 from 'picocolors';
-export { default as pc } from 'picocolors';
 import crypto from 'crypto';
 import { performance } from 'perf_hooks';
 import { EventEmitter as EventEmitter$1 } from 'events';
-import seedrandom from 'seedrandom';
-import path, { resolve, relative, basename, extname, dirname } from 'path';
-import { switcher } from 'js-runtime';
-import dirTree from 'directory-tree';
-import { print } from '@kubb/parser';
-import * as factory from '@kubb/parser/factory';
-import isEqual from 'lodash.isequal';
 
 createRequire(import.meta.url);
   
@@ -48,41 +37,84 @@ var __privateMethod = (obj, member, 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];
-    }
+// ../../node_modules/.pnpm/change-case@5.2.0/node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_NUMBER_LOWER_RE = /(\d)(\p{Ll})/gu;
+var SPLIT_LETTER_NUMBER_RE = /(\p{L})(\d)/gu;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_CHARACTERS = "";
+function split(input, options) {
+  let result = input.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  if (options?.separateNumbers) {
+    result = result.replace(SPLIT_NUMBER_LOWER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_LETTER_NUMBER_RE, SPLIT_REPLACE_VALUE);
+  }
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function camelCase(input, options) {
+  const prefix = getPrefix(input, options?.prefixCharacters);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + split(input, options).map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "");
+}
+function pascalCase(input, options) {
+  const prefix = getPrefix(input, options?.prefixCharacters);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + split(input, options).map(transform).join(options?.delimiter ?? "");
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
   };
 }
-async function clean(path2) {
-  return remove(path2);
+function getPrefix(input, prefixCharacters = DEFAULT_PREFIX_CHARACTERS) {
+  let prefix = "";
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charAt(i);
+    if (prefixCharacters.includes(char)) {
+      prefix += char;
+    } else {
+      break;
+    }
+  }
+  return prefix;
 }
-function camelCase(text) {
-  return camelCase$1(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: camelCaseTransformMerge });
+
+// src/transformers/casing.ts
+function camelCase2(text) {
+  return camelCase(text, { delimiter: "", mergeAmbiguousCharacters: true });
 }
-function pascalCase(text) {
-  return pascalCase$1(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge });
+function pascalCase2(text) {
+  return pascalCase(text, { delimiter: "", mergeAmbiguousCharacters: true });
 }
 
 // src/transformers/combineCodes.ts
@@ -274,8 +306,8 @@ var transformers_default = {
   JSDoc: {
     createJSDocBlockText
   },
-  camelCase,
-  pascalCase
+  camelCase: camelCase2,
+  pascalCase: pascalCase2
 };
 
 // src/utils/FunctionParams.ts
@@ -317,48 +349,6 @@ var FunctionParams = class {
     }, []).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.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;
-}
 
 // src/utils/promise.ts
 function isPromise(result) {
@@ -405,8 +395,8 @@ var Queue = class {
     __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
-    return new Promise((resolve3, reject) => {
-      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
+    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");
@@ -416,8 +406,8 @@ var Queue = class {
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
-    new Promise((resolve3, reject) => {
-      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
+    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));
       });
@@ -444,13 +434,13 @@ work_fn = function() {
   __privateWrapper(this, _workerCount)._++;
   let entry;
   while (entry = __privateGet(this, _queue).shift()) {
-    const { reject, resolve: resolve3, job, name, description } = entry;
+    const { reject, resolve, job, name, description } = entry;
     if (__privateGet(this, _debug)) {
       performance.mark(name + "_start");
     }
     job().then((result) => {
       this.eventEmitter.emit("jobDone", result);
-      resolve3(result);
+      resolve(result);
       if (__privateGet(this, _debug)) {
         performance.mark(name + "_stop");
         performance.measure(description, name + "_start", name + "_stop");
@@ -462,79 +452,6 @@ work_fn = function() {
   }
   __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(text);
-  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
-  return colour;
-}
-function randomPicoColour(text, colors = defaultColours) {
-  const colours = pc2.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.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 = relative(rootDir, filePath);
-  const slashedPath = slash(relativePath, platform);
-  if (slashedPath.startsWith("../")) {
-    return slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)));
-  }
-  return `./${slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))}`;
-}
-var reader = switcher(
-  {
-    node: async (path2) => {
-      return fs2.readFile(path2, { encoding: "utf8" });
-    },
-    bun: async (path2) => {
-      const file = Bun.file(path2);
-      return file.text();
-    }
-  },
-  "node"
-);
-var syncReader = switcher(
-  {
-    node: (path2) => {
-      return fs2.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) {
@@ -560,571 +477,14 @@ function renderTemplate(template, data = void 0) {
   }, 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((resolve3) => {
+  return new Promise((resolve) => {
     setTimeout(() => {
-      resolve3(true);
+      resolve(true);
     }, ms);
   });
 }
-async function saveCreateDirectory(path2) {
-  const passedPath = dirname(resolve(path2));
-  await fs2.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path2, data) => {
-      try {
-        await fs2.stat(resolve(path2));
-        const oldContent = await fs2.readFile(resolve(path2), { encoding: "utf-8" });
-        if (oldContent?.toString() === data?.toString()) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path2);
-      await fs2.writeFile(resolve(path2), data, { encoding: "utf-8" });
-      const savedData = await fs2.readFile(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(resolve(path2), data);
-        const file = Bun.file(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, 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, void 0);
-    __privateSet(this, _options, options);
-    return this;
-  }
-  getIndexes(pathToBuild) {
-    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
-    const tree = TreeNode.build(pathToBuild, treeNode);
-    if (!tree) {
-      return null;
-    }
-    const fileReducer = (files, treeNode2) => {
-      if (!treeNode2.children) {
-        return [];
-      }
-      if (treeNode2.children.length > 1) {
-        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
-        const exports = treeNode2.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${transformers_default.trimExtName(file.data.name)}`;
-          if (importPath.endsWith("index") && file.data.type === "file") {
-            return void 0;
-          }
-          return {
-            path: extName ? `${importPath}${extName}` : importPath,
-            isTypeOnly
-          };
-        }).filter(Boolean);
-        files.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports,
-          meta: {
-            treeNode: treeNode2
-          }
-        });
-      } else if (treeNode2.children.length === 1) {
-        const [treeNodeChild] = treeNode2.children;
-        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
-        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${transformers_default.trimExtName(treeNodeChild.data.name)}`;
-        const exports = [
-          {
-            path: extName ? `${importPath}${extName}` : importPath,
-            isTypeOnly
-          }
-        ];
-        files.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports,
-          meta: {
-            treeNode: treeNode2
-          }
-        });
-      }
-      treeNode2.children.forEach((childItem) => {
-        fileReducer(files, childItem);
-      });
-      return files;
-    };
-    return fileReducer([], tree).reverse();
-  }
-};
-_options = new WeakMap();
-var _cache, _task, _isWriting, _timeout, _queue2, _validate, _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);
-    }
-    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) => {
-      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, output, meta, options = {} }) {
-    const { exportType = "barrel" } = output;
-    if (!exportType) {
-      return void 0;
-    }
-    const exportPath = output.path.startsWith("./") ? output.path : `./${output.path}`;
-    const barrelManager = new BarrelManager({ extName: output.extName, ...options });
-    const files = barrelManager.getIndexes(resolve(root, output.path));
-    if (!files) {
-      return void 0;
-    }
-    const rootFile = {
-      path: resolve(root, "index.ts"),
-      baseName: "index.ts",
-      source: "",
-      exports: [
-        output.exportAs ? {
-          name: output.exportAs,
-          asAlias: true,
-          path: exportPath,
-          isTypeOnly: options.isTypeOnly
-        } : {
-          path: exportPath,
-          isTypeOnly: options.isTypeOnly
-        }
-      ]
-    };
-    await __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
-      ...rootFile,
-      meta: meta ? meta : rootFile.meta
-    });
-    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.filter((item) => {
-      return item.path !== transformers_default.trimExtName(file.path);
-    }).map((item) => {
-      return factory.createImportDeclaration({
-        name: item.name,
-        path: item.root ? getRelativePath(item.root, item.path) : item.path,
-        isTypeOnly: item.isTypeOnly
-      });
-    });
-    const exportNodes = exports.map(
-      (item) => factory.createExportDeclaration({
-        name: item.name,
-        path: item.path,
-        isTypeOnly: item.isTypeOnly,
-        asAlias: item.asAlias
-      })
-    );
-    return [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
-        };
-        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 || {} }
-        };
-      }
-      return acc;
-    }, []);
-  }
-  static getMode(path2) {
-    if (!path2) {
-      return "directory";
-    }
-    return extname(path2) ? "file" : "directory";
-  }
-  static get extensions() {
-    return [".js", ".ts", ".tsx"];
-  }
-  static isExtensionAllowed(baseName) {
-    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
-  }
-};
-_cache = new WeakMap();
-_task = new WeakMap();
-_isWriting = new WeakMap();
-_timeout = new WeakMap();
-_queue2 = new WeakMap();
-_validate = new WeakSet();
-_add = new WeakSet();
-add_fn = async function(file) {
-  const controller = new AbortController();
-  const resolvedFile = { id: crypto.randomUUID(), name: transformers_default.trimExtName(file.baseName), ...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 }
-    );
-  }
-  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 || {} }
-    });
-  }
-  return __privateMethod(this, _add, add_fn).call(this, file);
-};
-var FileManager = _FileManager;
-function combineExports(exports) {
-  const combinedExports = 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(imp.name, name) && imp.isTypeOnly);
-    if (prevByPathAndIsTypeOnly) {
-      return prev;
-    }
-    const uniquePrev = prev.findLast(
-      (imp) => imp.path === curr.path && isEqual(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 orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
-}
-function combineImports(imports, exports, source) {
-  const combinedImports = 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) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
-    }
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(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 orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
-}
-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 = transformers_default.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers_default.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;
-  }
-  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(path2, options = {}) {
-    try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree(path2, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
-      if (!filteredTree) {
-        return null;
-      }
-      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 });
-    }
-  }
-};
 
 // src/utils/uniqueName.ts
 function getUniqueName(originalName, data) {
@@ -1148,8 +508,8 @@ function setUniqueName(originalName, data) {
 
 // src/utils/URLPath.ts
 var URLPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
     return this;
   }
   /**
@@ -1243,6 +603,6 @@ var URLPath = class {
   }
 };
 
-export { FunctionParams, LogLevel, Queue, TreeNode, URLPath, clean, createLogger, createPluginCache, getRelativePath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, randomColour, randomPicoColour, read, readSync, renderTemplate, setUniqueName, throttle, timeout, write };
+export { FunctionParams, Queue, URLPath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=utils.js.map