@kubb/core 3.15.1 → 3.16.1

package/dist/chunk-QR7CQIA3.cjs

@@ -0,0 +1,943 @@
+'use strict';
+
+var chunkBHSTNFNQ_cjs = require('./chunk-BHSTNFNQ.cjs');
+var chunkE4XLCCPK_cjs = require('./chunk-E4XLCCPK.cjs');
+var path = require('path');
+var hash = require('object-hash');
+var remeda = require('remeda');
+var pLimit = require('p-limit');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var hash__default = /*#__PURE__*/_interopDefault(hash);
+var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
+
+// src/utils/FunctionParams.ts
+var FunctionParams = class _FunctionParams {
+  #items = [];
+  constructor() {
+    return this;
+  }
+  get items() {
+    return this.#items.flat();
+  }
+  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;
+  }
+  static #orderItems(items) {
+    return chunkBHSTNFNQ_cjs.orderBy(
+      items.filter(Boolean),
+      [
+        (v) => {
+          if (Array.isArray(v)) {
+            return void 0;
+          }
+          return !v.default;
+        },
+        (v) => {
+          if (Array.isArray(v)) {
+            return void 0;
+          }
+          return v.required ?? true;
+        }
+      ],
+      ["desc", "desc"]
+    );
+  }
+  static #addParams(acc, item) {
+    const { enabled = true, name, type, required = true, ...rest } = item;
+    if (!enabled) {
+      return acc;
+    }
+    if (!name) {
+      acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+      return acc;
+    }
+    const parameterName = name.startsWith("{") ? name : chunkBHSTNFNQ_cjs.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;
+  }
+  static toObject(items) {
+    let type = [];
+    let name = [];
+    const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
+    const required = items.every((item) => item.required) ?? true;
+    items.forEach((item) => {
+      name = _FunctionParams.#addParams(name, { ...item, type: void 0 });
+      if (items.some((item2) => item2.type)) {
+        type = _FunctionParams.#addParams(type, item);
+      }
+    });
+    return {
+      name: `{ ${name.join(", ")} }`,
+      type: type.length ? `{ ${type.join("; ")} }` : void 0,
+      enabled,
+      required
+    };
+  }
+  static toString(items) {
+    const sortedData = _FunctionParams.#orderItems(items);
+    return sortedData.reduce((acc, item) => {
+      if (Array.isArray(item)) {
+        if (item.length <= 0) {
+          return acc;
+        }
+        const subItems = _FunctionParams.#orderItems(item);
+        const objectItem = _FunctionParams.toObject(subItems);
+        return _FunctionParams.#addParams(acc, objectItem);
+      }
+      return _FunctionParams.#addParams(acc, item);
+    }, []).join(", ");
+  }
+  toObject() {
+    const items = _FunctionParams.#orderItems(this.#items).flat();
+    return _FunctionParams.toObject(items);
+  }
+  toString() {
+    const items = _FunctionParams.#orderItems(this.#items);
+    return _FunctionParams.toString(items);
+  }
+};
+
+// 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";
+}
+
+// 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/timeout.ts
+async function timeout(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, ms);
+  });
+}
+
+// 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;
+}
+
+// src/utils/URLPath.ts
+var URLPath = class {
+  path;
+  #options;
+  constructor(path2, options = {}) {
+    this.path = path2;
+    this.#options = options;
+    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") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      }
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      }
+      return `{ url: '${object.url}' }`;
+    }
+    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({ prefix = "", replacer } = {}) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, path2) => {
+        const pathWithoutBrackets = path2.replaceAll("{", "").replaceAll("}", "");
+        let param = chunkBHSTNFNQ_cjs.isValidVarName(pathWithoutBrackets) ? pathWithoutBrackets : chunkBHSTNFNQ_cjs.camelCase(pathWithoutBrackets);
+        if (this.#options.casing === "camelcase") {
+          param = chunkBHSTNFNQ_cjs.camelCase(param);
+        }
+        return prev.replace(path2, `\${${replacer ? replacer(param) : param}}`);
+      }, this.path);
+    }
+    return `\`${prefix}${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("}", "");
+      let param = chunkBHSTNFNQ_cjs.isValidVarName(item) ? item : chunkBHSTNFNQ_cjs.camelCase(item);
+      if (this.#options.casing === "camelcase") {
+        param = chunkBHSTNFNQ_cjs.camelCase(param);
+      }
+      const key = replacer ? replacer(param) : param;
+      params[key] = key;
+    }, this.path);
+    return params;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
+  }
+};
+
+// src/utils/TreeNode.ts
+var TreeNode = class _TreeNode {
+  data;
+  parent;
+  children = [];
+  #cachedLeaves = void 0;
+  constructor(data, parent) {
+    this.data = data;
+    this.parent = parent;
+    return this;
+  }
+  addChild(data) {
+    const child = new _TreeNode(data, this);
+    if (!this.children) {
+      this.children = [];
+    }
+    this.children.push(child);
+    return child;
+  }
+  get root() {
+    if (!this.parent) {
+      return this;
+    }
+    return this.parent.root;
+  }
+  get leaves() {
+    if (!this.children || this.children.length === 0) {
+      return [this];
+    }
+    if (this.#cachedLeaves) {
+      return this.#cachedLeaves;
+    }
+    const leaves = [];
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        leaves.push.apply(leaves, this.children[i].leaves);
+      }
+    }
+    this.#cachedLeaves = leaves;
+    return leaves;
+  }
+  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;
+  }
+  findDeep(predicate) {
+    if (typeof predicate !== "function") {
+      throw new TypeError("find() predicate must be a function");
+    }
+    return this.leaves.find(predicate);
+  }
+  forEachDeep(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    this.leaves.forEach(callback);
+  }
+  filterDeep(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("filter() callback must be a function");
+    }
+    return this.leaves.filter(callback);
+  }
+  mapDeep(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("map() callback must be a function");
+    }
+    return this.leaves.map(callback);
+  }
+  static build(files, root) {
+    try {
+      const filteredTree = buildDirectoryTree(files, root);
+      if (!filteredTree) {
+        return null;
+      }
+      const treeNode = new _TreeNode({
+        name: filteredTree.name,
+        path: filteredTree.path,
+        file: filteredTree.file,
+        type: FileManager.getMode(filteredTree.path)
+      });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({
+          name: item.name,
+          path: item.path,
+          file: item.file,
+          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 barrel files with the TreeNode class", { cause: e });
+    }
+  }
+};
+var normalizePath = (p) => p.replace(/\\/g, "/");
+function buildDirectoryTree(files, rootFolder = "") {
+  const normalizedRootFolder = normalizePath(rootFolder);
+  const rootPrefix = normalizedRootFolder.endsWith("/") ? normalizedRootFolder : `${normalizedRootFolder}/`;
+  const filteredFiles = files.filter((file) => {
+    const normalizedFilePath = normalizePath(file.path);
+    return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith(".json") : !normalizedFilePath.endsWith(".json");
+  });
+  if (filteredFiles.length === 0) {
+    return null;
+  }
+  const root = {
+    name: rootFolder || "",
+    path: rootFolder || "",
+    children: []
+  };
+  filteredFiles.forEach((file) => {
+    const path2 = file.path.slice(rootFolder.length);
+    const parts = path2.split("/");
+    let currentLevel = root.children;
+    let currentPath = rootFolder;
+    parts.forEach((part, index) => {
+      if (index !== 0) {
+        currentPath += `/${part}`;
+      } else {
+        currentPath += `${part}`;
+      }
+      let existingNode = currentLevel.find((node) => node.name === part);
+      if (!existingNode) {
+        if (index === parts.length - 1) {
+          existingNode = {
+            name: part,
+            file,
+            path: currentPath
+          };
+        } else {
+          existingNode = {
+            name: part,
+            path: currentPath,
+            children: []
+          };
+        }
+        currentLevel.push(existingNode);
+      }
+      if (!existingNode.file) {
+        currentLevel = existingNode.children;
+      }
+    });
+  });
+  return root;
+}
+
+// src/BarrelManager.ts
+var BarrelManager = class {
+  #options;
+  constructor(options = {}) {
+    this.#options = options;
+    return this;
+  }
+  getFiles({ files: generatedFiles, root }) {
+    const { logger } = this.#options;
+    const cachedFiles = /* @__PURE__ */ new Map();
+    TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
+      if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
+        return void 0;
+      }
+      const barrelFile = {
+        path: path.join(treeNode.parent?.data.path, "index.ts"),
+        baseName: "index.ts",
+        exports: [],
+        sources: []
+      };
+      const previousBarrelFile = cachedFiles.get(barrelFile.path);
+      const leaves = treeNode.leaves;
+      leaves.forEach((item) => {
+        if (!item.data.name) {
+          return void 0;
+        }
+        const sources = item.data.file?.sources || [];
+        if (!sources.some((source) => source.isIndexable)) {
+          logger?.emit(
+            "warning",
+            `No isIndexable source found(source should have a name and isIndexable):
+File: ${JSON.stringify(item.data.file, void 0, 2)}`
+          );
+        }
+        sources.forEach((source) => {
+          if (!item.data.file?.path || !source.isIndexable || !source.name) {
+            return void 0;
+          }
+          const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
+            (item2) => item2.name === source.name && item2.isTypeOnly === source.isTypeOnly
+          );
+          if (alreadyContainInPreviousBarrelFile) {
+            return void 0;
+          }
+          if (!barrelFile.exports) {
+            barrelFile.exports = [];
+          }
+          const isSubExport = !!treeNode.parent?.data.path?.split?.("/")?.length;
+          if (isSubExport) {
+            barrelFile.exports.push({
+              name: [source.name],
+              path: chunkE4XLCCPK_cjs.getRelativePath(treeNode.parent?.data.path, item.data.path),
+              isTypeOnly: source.isTypeOnly
+            });
+          } else {
+            barrelFile.exports.push({
+              name: [source.name],
+              path: `./${item.data.file.baseName}`,
+              isTypeOnly: source.isTypeOnly
+            });
+          }
+          barrelFile.sources.push({
+            name: source.name,
+            isTypeOnly: source.isTypeOnly,
+            //TODO use parser to generate import
+            value: "",
+            isExportable: false,
+            isIndexable: false
+          });
+        });
+      });
+      if (previousBarrelFile) {
+        previousBarrelFile.sources.push(...barrelFile.sources);
+        previousBarrelFile.exports?.push(...barrelFile.exports || []);
+      } else {
+        cachedFiles.set(barrelFile.path, barrelFile);
+      }
+    });
+    return [...cachedFiles.values()];
+  }
+};
+
+// src/utils/Cache.ts
+var Cache = class {
+  #buffer = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.#buffer.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.#buffer.set(key, value);
+  }
+  async delete(key) {
+    this.#buffer.delete(key);
+  }
+  async clear() {
+    this.#buffer.clear();
+  }
+  async keys() {
+    return [...this.#buffer.keys()];
+  }
+  async values() {
+    return [...this.#buffer.values()];
+  }
+  async flush() {
+  }
+};
+
+// src/FileManager.ts
+var FileManager = class {
+  #cache = new Cache();
+  #limit = pLimit__default.default(100);
+  constructor() {
+    return this;
+  }
+  async add(...files) {
+    const resolvedFiles = [];
+    const mergedFiles = /* @__PURE__ */ new Map();
+    files.forEach((file) => {
+      const existing = mergedFiles.get(file.path);
+      if (existing) {
+        mergedFiles.set(file.path, mergeFile(existing, file));
+      } else {
+        mergedFiles.set(file.path, file);
+      }
+    });
+    for (const file of mergedFiles.values()) {
+      const existing = await this.#cache.get(file.path);
+      const merged = existing ? mergeFile(existing, file) : file;
+      const resolvedFile = createFile(merged);
+      await this.#cache.set(resolvedFile.path, resolvedFile);
+      await this.#cache.flush();
+      resolvedFiles.push(resolvedFile);
+    }
+    if (files.length > 1) {
+      return resolvedFiles;
+    }
+    return resolvedFiles[0];
+  }
+  async getByPath(path2) {
+    return this.#cache.get(path2);
+  }
+  async deleteByPath(path2) {
+    await this.#cache.delete(path2);
+  }
+  async clear() {
+    await this.#cache.clear();
+  }
+  async getFiles() {
+    const cachedKeys = await this.#cache.keys();
+    const keys = chunkBHSTNFNQ_cjs.orderBy(cachedKeys, [(v) => v.length, (v) => chunkE4XLCCPK_cjs.trimExtName(v).endsWith("index")]);
+    const filesTasks = keys.map(
+      (key) => this.#limit(async () => {
+        const file = await this.#cache.get(key);
+        return file;
+      })
+    );
+    const files = await Promise.all(filesTasks);
+    return files.filter(Boolean);
+  }
+  async processFiles({ dryRun, root, extension, logger }) {
+    const files = await this.getFiles();
+    logger?.emit("progress_start", { id: "files", size: files.length, message: "Writing files ..." });
+    const promises = files.map((file) => {
+      return this.#limit(async () => {
+        const message = file ? `Writing ${path.relative(root, file.path)}` : "";
+        const extname2 = extension?.[file.extname] || void 0;
+        if (!dryRun) {
+          const source = await getSource(file, { logger, extname: extname2 });
+          await chunkE4XLCCPK_cjs.write(file.path, source, { sanity: false });
+        }
+        logger?.emit("progressed", { id: "files", message });
+      });
+    });
+    await Promise.all(promises);
+    logger?.emit("progress_stop", { id: "files" });
+    return files;
+  }
+  async getBarrelFiles({ type, meta = {}, root, output, logger }) {
+    if (!type || type === "propagate") {
+      return [];
+    }
+    const barrelManager = new BarrelManager({ logger });
+    const files = await this.getFiles();
+    const pathToBuildFrom = path.join(root, output.path);
+    if (chunkE4XLCCPK_cjs.trimExtName(pathToBuildFrom).endsWith("index")) {
+      logger?.emit("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation");
+      return [];
+    }
+    const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta });
+    if (type === "all") {
+      return barrelFiles.map((file) => {
+        return {
+          ...file,
+          exports: file.exports?.map((exportItem) => {
+            return {
+              ...exportItem,
+              name: void 0
+            };
+          })
+        };
+      });
+    }
+    return barrelFiles.map((indexFile) => {
+      return {
+        ...indexFile,
+        meta
+      };
+    });
+  }
+  // statics
+  static getMode(path2) {
+    if (!path2) {
+      return "split";
+    }
+    return path.extname(path2) ? "single" : "split";
+  }
+};
+async function getSource(file, { logger, extname: extname2 } = {}) {
+  const parser = await getFileParser(file.extname);
+  const source = await parser.print(file, { logger, extname: extname2 });
+  return parser.format(source).catch((err) => {
+    console.warn(err);
+    return source;
+  });
+}
+function mergeFile(a, b) {
+  return {
+    ...a,
+    sources: [...a.sources || [], ...b.sources || []],
+    imports: [...a.imports || [], ...b.imports || []],
+    exports: [...a.exports || [], ...b.exports || []]
+  };
+}
+function combineSources(sources) {
+  return remeda.uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly]);
+}
+function combineExports(exports) {
+  return chunkBHSTNFNQ_cjs.orderBy(exports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => Array.isArray(v.name) ? chunkBHSTNFNQ_cjs.orderBy(v.name) : v.name
+  ]).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 && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly);
+      if (prevByPathAndIsTypeOnly) {
+        return prev;
+      }
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && remeda.isDeepEqual(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];
+    },
+    []
+  );
+}
+function combineImports(imports, exports, source) {
+  return chunkBHSTNFNQ_cjs.orderBy(imports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => Array.isArray(v.name) ? chunkBHSTNFNQ_cjs.orderBy(v.name) : v.name
+  ]).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) => {
+          return name2 && source.includes(name2);
+        };
+        return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
+      };
+      if (curr.path === curr.root) {
+        return prev;
+      }
+      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 && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && remeda.isDeepEqual(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];
+    },
+    []
+  );
+}
+
+// src/utils/parser.ts
+function getDefaultBanner({ title, description, version, config }) {
+  try {
+    let source = "";
+    if ("path" in config.input) {
+      source = path__default.default.basename(config.input.path);
+    } else if ("data" in config.input) {
+      source = "text content";
+    }
+    let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
+    if (config.output.defaultBanner === "simple") {
+      banner += "*/\n";
+      return banner;
+    }
+    if (source) {
+      banner += `* Source: ${source}
+`;
+    }
+    if (title) {
+      banner += `* Title: ${title}
+`;
+    }
+    if (description) {
+      const formattedDescription = description.replace(/\n/gm, "\n* ");
+      banner += `* Description: ${formattedDescription}
+`;
+    }
+    if (version) {
+      banner += `* OpenAPI spec version: ${version}
+`;
+    }
+    banner += "*/\n";
+    return banner;
+  } catch (_error) {
+    return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+  }
+}
+function createFile(file) {
+  const extname2 = path__default.default.extname(file.baseName);
+  if (!extname2) {
+    throw new Error(`No extname found for ${file.baseName}`);
+  }
+  const source = file.sources.map((item) => item.value).join("\n\n");
+  const exports = file.exports?.length ? combineExports(file.exports) : [];
+  const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : [];
+  const sources = file.sources?.length ? combineSources(file.sources) : [];
+  return {
+    ...file,
+    id: hash__default.default({ path: file.path }),
+    name: trimExtName2(file.baseName),
+    extname: extname2,
+    imports: imports.map(createFileImport),
+    exports: exports.map(createFileExport),
+    sources: sources.map(createFileSource),
+    meta: file.meta || {}
+  };
+}
+function createFileSource(source) {
+  return source;
+}
+function createFileImport(imp) {
+  return {
+    ...imp
+  };
+}
+function createFileExport(exp) {
+  return {
+    ...exp
+  };
+}
+function createFileParser(parser) {
+  return parser;
+}
+var typeScriptParser = createFileParser({
+  async format(source) {
+    const module = await import('@kubb/parser-ts');
+    return module.format(source);
+  },
+  async print(file, options = { extname: ".ts" }) {
+    const module = await import('@kubb/parser-ts');
+    const source = file.sources.map((item) => item.value).join("\n\n");
+    const importNodes = file.imports.map((item) => {
+      const importPath = item.root ? chunkE4XLCCPK_cjs.getRelativePath(item.root, item.path) : item.path;
+      const hasExtname = !!path__default.default.extname(importPath);
+      return module.factory.createImportDeclaration({
+        name: item.name,
+        path: options.extname && hasExtname ? `${trimExtName2(importPath)}${options.extname}` : item.root ? trimExtName2(importPath) : importPath,
+        isTypeOnly: item.isTypeOnly
+      });
+    }).filter(Boolean);
+    const exportNodes = file.exports.map((item) => {
+      const exportPath = item.path;
+      const hasExtname = !!path__default.default.extname(exportPath);
+      return module.factory.createExportDeclaration({
+        name: item.name,
+        path: options.extname && hasExtname ? `${trimExtName2(item.path)}${options.extname}` : trimExtName2(item.path),
+        isTypeOnly: item.isTypeOnly,
+        asAlias: item.asAlias
+      });
+    }).filter(Boolean);
+    return [file.banner, module.print([...importNodes, ...exportNodes]), source, file.footer].join("\n");
+  }
+});
+var tsxParser = createFileParser({
+  async format(source) {
+    const module = await import('@kubb/parser-ts');
+    return module.format(source);
+  },
+  async print(file, options = { extname: ".tsx" }) {
+    return typeScriptParser.print(file, options);
+  }
+});
+var defaultParser = createFileParser({
+  async format(source) {
+    return source;
+  },
+  async print(file) {
+    return file.sources.map((item) => item.value).join("\n\n");
+  }
+});
+var parsers = {
+  ".ts": typeScriptParser,
+  ".js": typeScriptParser,
+  ".jsx": tsxParser,
+  ".tsx": tsxParser,
+  ".json": defaultParser
+};
+async function getFileParser(extname2) {
+  if (!extname2) {
+    return defaultParser;
+  }
+  const parser = parsers[extname2];
+  if (!parser) {
+    console.warn(`[parser] No parser found for ${extname2}, default parser will be used`);
+  }
+  return parser || defaultParser;
+}
+function trimExtName2(text) {
+  const extname2 = text.split(".").pop();
+  return text.replace(`.${extname2}`, "");
+}
+
+exports.Cache = Cache;
+exports.FileManager = FileManager;
+exports.FunctionParams = FunctionParams;
+exports.URLPath = URLPath;
+exports.createFile = createFile;
+exports.createFileExport = createFileExport;
+exports.createFileImport = createFileImport;
+exports.createFileParser = createFileParser;
+exports.getDefaultBanner = getDefaultBanner;
+exports.getFileParser = getFileParser;
+exports.getSource = getSource;
+exports.getUniqueName = getUniqueName;
+exports.isPromise = isPromise;
+exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
+exports.isPromiseRejectedResult = isPromiseRejectedResult;
+exports.renderTemplate = renderTemplate;
+exports.setUniqueName = setUniqueName;
+exports.timeout = timeout;
+//# sourceMappingURL=chunk-QR7CQIA3.cjs.map
+//# sourceMappingURL=chunk-QR7CQIA3.cjs.map