@kubb/core 2.0.0-canary.20231030T124958 → 2.0.1

package/dist/utils.js

@@ -1,83 +1,16 @@
 import { createRequire } from 'module';
-import fs2, { remove } from 'fs-extra';
-import { camelCase, camelCaseTransformMerge } from 'change-case';
+export { URLPath, getUniqueName, setUniqueName } from './chunk-4A7WG6IA.js';
+import { camelCase } from './chunk-XPOF4D5N.js';
+import { init_esm_shims } from './chunk-54P4AWHI.js';
 import { orderBy } from 'natural-orderby';
-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);
-  
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
-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];
-    }
-  };
-}
-async function clean(path2) {
-  return remove(path2);
-}
+// src/utils/index.ts
+init_esm_shims();
+
+// src/utils/FunctionParams.ts
+init_esm_shims();
 var FunctionParams = class {
   constructor(type) {
     this.items = [];
@@ -102,7 +35,7 @@ var FunctionParams = class {
         acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
         return acc;
       }
-      const parameterName = name.startsWith("{") ? name : camelCase(name, { delimiter: "", transform: camelCaseTransformMerge });
+      const parameterName = name.startsWith("{") ? name : camelCase(name);
       if (type) {
         if (required) {
           acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
@@ -116,50 +49,9 @@ 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) {
-      spinner.info(message);
-      logs.push(message);
-    }
-  };
-  const logger = {
-    name,
-    logLevel,
-    log,
-    error,
-    warn,
-    info,
-    spinner,
-    logs
-  };
-  return logger;
-}
 
 // src/utils/promise.ts
+init_esm_shims();
 function isPromise(result) {
   return !!result && typeof result?.then === "function";
 }
@@ -169,173 +61,9 @@ function isPromiseFulfilledResult(result) {
 function isPromiseRejectedResult(result) {
   return result.status === "rejected";
 }
-var _emitter;
-var EventEmitter = class {
-  constructor() {
-    __privateAdd(this, _emitter, new EventEmitter$1());
-    __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.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.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)) {
-      performance.mark(name + "_start");
-    }
-    job().then((result) => {
-      this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
-      if (__privateGet(this, _debug)) {
-        performance.mark(name + "_stop");
-        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(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
+init_esm_shims();
 function renderTemplate(template, data = void 0) {
   if (!data || !Object.keys(data).length) {
     return template.replace(/{{(.*?)}}/g, "");
@@ -359,847 +87,16 @@ 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
+init_esm_shims();
 async function timeout(ms) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     setTimeout(() => {
-      resolve2(true);
+      resolve(true);
     }, ms);
   });
 }
 
-// src/utils/transformers/combineCodes.ts
-function combineCodes(codes) {
-  return codes.join("\n");
-}
-
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
-  }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
-}
-
-// src/utils/transformers/escape.ts
-function escape(text) {
-  return text ? text.replaceAll("`", "\\`") : "";
-}
-function jsStringEscape(input) {
-  return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-    switch (character) {
-      case '"':
-      case "'":
-      case "\\":
-        return "\\" + character;
-      case "\n":
-        return "\\n";
-      case "\r":
-        return "\\r";
-      case "\u2028":
-        return "\\u2028";
-      case "\u2029":
-        return "\\u2029";
-      default:
-        return "";
-    }
-  });
-}
-
-// src/utils/transformers/indent.ts
-function createIndent(size) {
-  return Array.from({ length: size + 1 }).join(" ");
-}
-
-// src/utils/transformers/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-
-// src/utils/transformers/searchAndReplace.ts
-function searchAndReplace(options) {
-  const { text, replaceBy, prefix = "", key } = options;
-  const searchValues = options.searchValues?.(prefix, key) || [
-    `${prefix}["${key}"]`,
-    `${prefix}['${key}']`,
-    `${prefix}[\`${key}\`]`,
-    `${prefix}"${key}"`,
-    `${prefix}'${key}'`,
-    `${prefix}\`${key}\``,
-    new RegExp(`${prefix}${key}`, "g")
-  ];
-  return searchValues.reduce((prev, searchValue) => {
-    return prev.toString().replaceAll(searchValue, replaceBy);
-  }, text);
-}
-
-// src/utils/transformers/transformReservedWord.ts
-var reservedWords = [
-  "abstract",
-  "arguments",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
-  "char",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "double",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "final",
-  "finally",
-  "float",
-  "for",
-  "function",
-  "goto",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "int",
-  "interface",
-  "let",
-  "long",
-  "native",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "short",
-  "static",
-  "super",
-  "switch",
-  "synchronized",
-  "this",
-  "throw",
-  "throws",
-  "transient",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "volatile",
-  "while",
-  "with",
-  "yield",
-  "Array",
-  "Date",
-  "eval",
-  "function",
-  "hasOwnProperty",
-  "Infinity",
-  "isFinite",
-  "isNaN",
-  "isPrototypeOf",
-  "length",
-  "Math",
-  "name",
-  "NaN",
-  "Number",
-  "Object",
-  "prototype",
-  "String",
-  "toString",
-  "undefined",
-  "valueOf"
-];
-function transformReservedWord(word) {
-  if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
-    return `_${word}`;
-  }
-  return word;
-}
-
-// src/utils/transformers/index.ts
-var transformers = {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  nameSorter,
-  searchAndReplace,
-  JSDoc: {
-    createJSDocBlockText
-  }
-};
-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, {});
-    __privateSet(this, _options, options);
-    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;
-    }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
-        return [];
-      }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && indexPath.includes("index")) {
-            return void 0;
-          }
-          return {
-            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${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.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${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);
-    }
-    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.createImportDeclaration({ name: item.name, 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();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
-  }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-  }
-};
-_add = new WeakSet();
-add_fn = async function(file) {
-  const controller = new AbortController();
-  const resolvedFile = { id: crypto.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 }
-    );
-  }
-  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) => 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(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.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;
-  }
-  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) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    originalName += used;
-  }
-  data[originalName] = 1;
-  return originalName;
-}
-function setUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    return originalName;
-  }
-  data[originalName] = 1;
-  return originalName;
-}
-var URLPath = class {
-  constructor(path2) {
-    this.path = path2;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  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)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
-  }
-  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)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    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);
-      }, this.path);
-    }
-    return `\`${newPath}\``;
-  }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
-    }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
-  }
-};
-
-export { FunctionParams, LogLevel, Queue, TreeNode, URLPath, clean, createLogger, createPluginCache, getRelativePath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, randomColour, randomPicoColour, read, readSync, renderTemplate, setUniqueName, throttle, timeout, transformers, write };
+export { FunctionParams, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, timeout };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=utils.js.map