@kubb/core 3.0.0-alpha.9 → 3.0.0-beta.2

package/dist/{chunk-27CPVXAT.js → chunk-DXGMSPTW.js}

@@ -1,7 +1,9 @@
-import {
-  camelCase,
-  orderBy
-} from "./chunk-4X5FFJPJ.js";
+import { orderBy, camelCase } from './chunk-BQXM32UO.js';
+import path, { join, extname, relative } from 'node:path';
+import { trimExtName, write, read, getRelativePath } from '@kubb/fs';
+import hash from 'object-hash';
+import { isDeepEqual } from 'remeda';
+import PQueue from 'p-queue';
 
 // src/utils/FunctionParams.ts
 var FunctionParams = class _FunctionParams {
@@ -173,8 +175,8 @@ function setUniqueName(originalName, data) {
 // src/utils/URLPath.ts
 var URLPath = class {
   path;
-  constructor(path) {
-    this.path = path;
+  constructor(path2) {
+    this.path = path2;
     return this;
   }
   /**
@@ -268,24 +270,12 @@ var URLPath = class {
   }
 };
 
-// src/utils/parser.ts
-import { extname as extname2 } from "node:path";
-import { getRelativePath as getRelativePath2 } from "@kubb/fs";
-import hash from "object-hash";
-
-// src/FileManager.ts
-import { extname, join as join2, relative } from "node:path";
-import { isDeepEqual } from "remeda";
-import { read, write } from "@kubb/fs";
-
-// src/BarrelManager.ts
-import { join } from "node:path";
-
 // src/utils/TreeNode.ts
 var TreeNode = class _TreeNode {
   data;
   parent;
   children = [];
+  #cachedLeaves = void 0;
   constructor(data, parent) {
     this.data = data;
     this.parent = parent;
@@ -299,41 +289,28 @@ var TreeNode = class _TreeNode {
     this.children.push(child);
     return child;
   }
-  find(data) {
-    if (!data) {
-      return null;
-    }
-    if (data === this.data) {
+  get root() {
+    if (!this.parent) {
       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;
+    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;
   }
-  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");
@@ -346,35 +323,29 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  filter(callback) {
-    let data = [];
+  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");
     }
-    if (callback(this)) {
-      data.push(this);
-    }
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        const childData = this.children[i]?.filter(callback).filter(Boolean) || [];
-        data = [.../* @__PURE__ */ new Set([...data, ...childData])];
-      }
-    }
-    return data;
+    this.leaves.forEach(callback);
   }
-  map(callback) {
-    let data = [];
+  filterDeep(callback) {
     if (typeof callback !== "function") {
-      throw new TypeError("forEach() callback must be a function");
+      throw new TypeError("filter() callback must be a function");
     }
-    data.push(callback(this));
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        const childData = this.children[i]?.map(callback).filter(Boolean) || [];
-        data = [.../* @__PURE__ */ new Set([...data, ...childData])];
-      }
+    return this.leaves.filter(callback);
+  }
+  mapDeep(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("map() callback must be a function");
     }
-    return data;
+    return this.leaves.map(callback);
   }
   static build(files, root) {
     try {
@@ -420,8 +391,8 @@ function buildDirectoryTree(files, rootFolder = "") {
     children: []
   };
   filteredFiles.forEach((file) => {
-    const path = file.path.slice(rootFolder.length);
-    const parts = path.split("/");
+    const path2 = file.path.slice(rootFolder.length);
+    const parts = path2.split("/");
     let currentLevel = root.children;
     let currentPath = rootFolder;
     parts.forEach((part, index) => {
@@ -454,25 +425,29 @@ function buildDirectoryTree(files, rootFolder = "") {
   });
   return root;
 }
-
-// src/BarrelManager.ts
-import { getRelativePath } from "@kubb/fs";
 var BarrelManager = class {
   #options;
   constructor(options = {}) {
     this.#options = options;
     return this;
   }
-  getFiles(generatedFiles, root) {
+  getFiles({ files: generatedFiles, root, meta }) {
     const { logger } = this.#options;
-    const files = /* @__PURE__ */ new Map();
+    const cachedFiles = /* @__PURE__ */ new Map();
+    logger?.emit("debug", { date: /* @__PURE__ */ new Date(), logs: [`Start barrel generation for pluginKey ${meta?.pluginKey?.join(".")} and root '${root}'`] });
     TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
       if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
         return void 0;
       }
-      const barrelPath = join(treeNode.parent?.data.path, "index.ts");
+      const barrelFile = {
+        path: join(treeNode.parent?.data.path, "index.ts"),
+        baseName: "index.ts",
+        exports: [],
+        sources: []
+      };
+      const previousBarrelFile = cachedFiles.get(barrelFile.path);
       const leaves = treeNode.leaves;
-      const exports = leaves.map((item) => {
+      leaves.forEach((item) => {
         if (!item.data.name) {
           return void 0;
         }
@@ -484,96 +459,88 @@ var BarrelManager = class {
 File: ${JSON.stringify(item.data.file, void 0, 2)}`
           );
         }
-        return sources.map((source) => {
-          if (!item.data.file?.path || !source.isIndexable) {
+        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);
+          if (alreadyContainInPreviousBarrelFile) {
             return void 0;
           }
+          if (!barrelFile.exports) {
+            barrelFile.exports = [];
+          }
           const isSubExport = !!treeNode.parent?.data.path?.split?.("/")?.length;
           if (isSubExport) {
-            return {
+            barrelFile.exports.push({
               name: [source.name],
               path: getRelativePath(treeNode.parent?.data.path, item.data.path),
               isTypeOnly: source.isTypeOnly
-            };
-          }
-          return {
-            name: [source.name],
-            path: `./${item.data.file.baseName}`,
-            isTypeOnly: source.isTypeOnly
-          };
-        });
-      }).flat().filter(Boolean);
-      const barrelFile = {
-        path: barrelPath,
-        baseName: "index.ts",
-        exports,
-        sources: exports.flatMap((item) => {
-          if (Array.isArray(item.name)) {
-            return item.name.map((name) => {
-              return {
-                name,
-                isTypeOnly: item.isTypeOnly,
-                //TODO use parser to generate import
-                value: "",
-                isExportable: false,
-                isIndexable: false
-              };
+            });
+          } else {
+            barrelFile.exports.push({
+              name: [source.name],
+              path: `./${item.data.file.baseName}`,
+              isTypeOnly: source.isTypeOnly
             });
           }
-          return [
-            {
-              name: item.name,
-              isTypeOnly: item.isTypeOnly,
-              //TODO use parser to generate import
-              value: "",
-              isExportable: false,
-              isIndexable: false
-            }
-          ];
-        })
-      };
-      const previousBarrelFile = files.get(barrelFile.path);
-      if (previousBarrelFile) {
-        files.set(barrelFile.path, {
-          ...previousBarrelFile,
-          ...barrelFile,
-          exports: combineExports([...previousBarrelFile.exports || [], ...barrelFile.exports || []]),
-          sources: combineSources([...previousBarrelFile.sources || [], ...barrelFile.sources || []])
+          barrelFile.sources.push({
+            name: source.name,
+            isTypeOnly: source.isTypeOnly,
+            //TODO use parser to generate import
+            value: "",
+            isExportable: false,
+            isIndexable: false
+          });
         });
+      });
+      logger?.emit("debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [
+          `Generating barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with ${barrelFile.sources.length} indexable exports: '${barrelFile.sources?.map((source) => source.name).join(", ")}'`
+        ]
+      });
+      logger?.emit("debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [
+          `Generated barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with exports: '${cachedFiles.get(barrelFile.path)?.sources?.map((source) => source.name).join(", ")}'`
+        ]
+      });
+      if (previousBarrelFile) {
+        previousBarrelFile.sources.push(...barrelFile.sources);
+        previousBarrelFile.exports?.push(...barrelFile.exports || []);
       } else {
-        files.set(barrelFile.path, barrelFile);
+        cachedFiles.set(barrelFile.path, barrelFile);
       }
     });
-    return [...files.values()];
+    return [...cachedFiles.values()];
   }
 };
-
-// src/FileManager.ts
-import { trimExtName } from "@kubb/fs";
-import PQueue from "p-queue";
 var FileManager = class {
   #filesByPath = /* @__PURE__ */ new Map();
-  #files = /* @__PURE__ */ new Set();
   constructor() {
     return this;
   }
   get files() {
-    return Array.from(this.#files);
+    return [...this.#filesByPath.values()];
   }
   get orderedFiles() {
-    return orderBy(Array.from(this.#files), [
-      (v) => v?.meta && "pluginKey" in v.meta && !v.meta.pluginKey,
-      (v) => v.path.length,
-      (v) => trimExtName(v.path).endsWith("index"),
-      (v) => trimExtName(v.baseName),
-      (v) => v.path.split(".").pop()
-    ]);
+    return orderBy(
+      [...this.#filesByPath.values()],
+      [
+        (v) => v?.meta && "pluginKey" in v.meta && !v.meta.pluginKey,
+        (v) => v.path.length,
+        (v) => trimExtName(v.path).endsWith("index"),
+        (v) => trimExtName(v.baseName),
+        (v) => v.path.split(".").pop()
+      ]
+    );
   }
   get groupedFiles() {
-    return buildDirectoryTree(Array.from(this.#files));
+    return buildDirectoryTree([...this.#filesByPath.values()]);
   }
   get treeNode() {
-    return TreeNode.build(Array.from(this.#files));
+    return TreeNode.build([...this.#filesByPath.values()]);
   }
   async add(...files) {
     const promises = files.map((file) => {
@@ -591,55 +558,44 @@ var FileManager = class {
   async #add(file) {
     const resolvedFile = createFile(file);
     this.#filesByPath.set(resolvedFile.path, resolvedFile);
-    this.#files.add(resolvedFile);
     return resolvedFile;
   }
   clear() {
     this.#filesByPath.clear();
-    this.#files.clear();
   }
   async #addOrAppend(file) {
     const previousFile = this.#filesByPath.get(file.path);
     if (previousFile) {
       this.#filesByPath.delete(previousFile.path);
-      this.#files.delete(previousFile);
       return this.#add(mergeFile(previousFile, file));
     }
     return this.#add(file);
   }
   getCacheById(id) {
-    let cache;
-    this.#files.forEach((file) => {
-      if (file.id === id) {
-        cache = file;
-      }
-    });
-    return cache;
+    return [...this.#filesByPath.values()].find((file) => file.id === id);
   }
-  getByPath(path) {
-    return this.#filesByPath.get(path);
+  getByPath(path2) {
+    return this.#filesByPath.get(path2);
   }
-  deleteByPath(path) {
-    const cacheItem = this.getByPath(path);
+  deleteByPath(path2) {
+    const cacheItem = this.getByPath(path2);
     if (!cacheItem) {
       return;
     }
-    this.#filesByPath.delete(path);
-    this.#files.delete(cacheItem);
+    this.#filesByPath.delete(path2);
   }
-  async getBarrelFiles({ files, meta, root, output, logger }) {
-    const { exportType = "barrelNamed" } = output;
-    const barrelManager = new BarrelManager({ logger });
-    if (exportType === false) {
+  async getBarrelFiles({ type, files, meta = {}, root, output, logger }) {
+    if (!type) {
       return [];
     }
-    const pathToBuildFrom = join2(root, output.path);
+    const barrelManager = new BarrelManager({ logger });
+    const pathToBuildFrom = join(root, output.path);
     if (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, pathToBuildFrom);
-    if (exportType === "barrel") {
+    const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta });
+    if (type === "all") {
       return barrelFiles.map((file) => {
         return {
           ...file,
@@ -666,16 +622,17 @@ var FileManager = class {
     return read(...params);
   }
   // statics
-  static getMode(path) {
-    if (!path) {
+  static getMode(path2) {
+    if (!path2) {
       return "split";
     }
-    return extname(path) ? "single" : "split";
+    return extname(path2) ? "single" : "split";
   }
 };
-async function getSource(file, { logger } = {}) {
-  const parser = await getFileParser(file.extName);
-  return parser.print(file, { logger });
+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);
 }
 function mergeFile(a, b) {
   return {
@@ -688,7 +645,7 @@ function mergeFile(a, b) {
 function combineSources(sources) {
   return sources.reduce(
     (prev, curr) => {
-      const prevByName = prev.findLast((imp) => imp.name === curr.name);
+      const prevByName = prev.findLast((imp) => imp.name && imp.name === curr.name);
       const prevByPathAndIsExportable = prev.findLast((imp) => imp.name === curr.name && imp.isExportable);
       if (prevByPathAndIsExportable) {
         return [...prev, curr];
@@ -706,7 +663,13 @@ function combineSources(sources) {
   );
 }
 function combineExports(exports) {
-  const combinedExports = exports.reduce(
+  return orderBy(exports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => Array.isArray(v.name) ? orderBy(v.name) : v.name
+  ]).reduce(
     (prev, curr) => {
       const name = curr.name;
       const prevByPath = prev.findLast((imp) => imp.path === curr.path);
@@ -737,23 +700,24 @@ function combineExports(exports) {
     },
     []
   );
-  return orderBy(combinedExports, [
+}
+function combineImports(imports, exports, source) {
+  return orderBy(imports, [
     (v) => !!Array.isArray(v.name),
     (v) => !v.isTypeOnly,
     (v) => v.path,
     (v) => !!v.name,
     (v) => Array.isArray(v.name) ? orderBy(v.name) : v.name
-  ]);
-}
-function combineImports(imports, exports, source) {
-  const combinedImports = imports.reduce(
+  ]).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);
+        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) {
@@ -791,13 +755,6 @@ function combineImports(imports, exports, source) {
     },
     []
   );
-  return orderBy(combinedImports, [
-    (v) => !!Array.isArray(v.name),
-    (v) => !v.isTypeOnly,
-    (v) => v.path,
-    (v) => !!v.name,
-    (v) => Array.isArray(v.name) ? orderBy(v.name) : v.name
-  ]);
 }
 var queue = new PQueue({ concurrency: 100 });
 async function processFiles({ dryRun, config, logger, files }) {
@@ -807,18 +764,20 @@ async function processFiles({ dryRun, config, logger, files }) {
     (v) => trimExtName(v.path).endsWith("index")
   ]);
   logger.emit("debug", {
+    date: /* @__PURE__ */ new Date(),
     logs: [JSON.stringify({ files: orderedFiles }, null, 2)],
-    fileName: "kubb-files.json",
-    override: true
+    fileName: "kubb-files.log"
   });
   if (!dryRun) {
     const size = orderedFiles.length;
-    logger.emit("progress_start", { id: "files", size });
+    logger.emit("progress_start", { id: "files", size, message: "Writing files ..." });
     const promises = orderedFiles.map(async (file) => {
       await queue.add(async () => {
-        const source = await getSource(file, { logger });
+        const message = file ? `Writing ${relative(config.root, file.path)}` : "";
+        const extname2 = config.output.extension?.[file.extname];
+        const source = await getSource(file, { logger, extname: extname2 });
         await write(file.path, source, { sanity: false });
-        logger.emit("progress", { id: "files", data: file ? relative(config.root, file.path) : "" });
+        logger.emit("progressed", { id: "files", message });
       });
     });
     await Promise.all(promises);
@@ -829,9 +788,9 @@ async function processFiles({ dryRun, config, logger, files }) {
 
 // src/utils/parser.ts
 function createFile(file) {
-  const extName = extname2(file.baseName);
-  if (!extName) {
-    throw new Error(`No extName found for ${file.baseName}`);
+  const extname2 = path.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 ? combineExports(file.exports) : [];
@@ -841,63 +800,64 @@ function createFile(file) {
     ...file,
     id: hash({ path: file.path }),
     name: trimExtName2(file.baseName),
-    extName,
+    extname: extname2,
     imports: imports.map((item) => createFileImport(item)),
     exports: exports.map((item) => createFileExport(item)),
-    sources: sources.map((item) => createFileSource(item))
+    sources: sources.map((item) => createFileSource(item)),
+    meta: file.meta || {}
   };
 }
 function createFileSource(source) {
   return source;
 }
 function createFileImport(imp) {
-  const extName = extname2(imp.path);
   return {
-    ...imp,
-    extName: imp.extName ? imp.extName : extName
+    ...imp
   };
 }
 function createFileExport(exp) {
-  const extName = extname2(exp.path);
   return {
-    ...exp,
-    extName: exp.extName ? exp.extName : extName
+    ...exp
   };
 }
 function createFileParser(parser) {
   return parser;
 }
 var typeScriptParser = createFileParser({
-  render() {
-    return void 0;
+  async format(source) {
+    const module = await import('@kubb/parser-ts');
+    return module.format(source);
   },
-  async print(file) {
-    const module = await import("@kubb/parser-ts");
+  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 path = item.root ? getRelativePath2(item.root, item.path) : item.path;
+      const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
+      const hasExtname = !!path.extname(importPath);
       return module.factory.createImportDeclaration({
         name: item.name,
-        path,
+        path: options.extname && hasExtname ? `${trimExtName2(importPath)}${options.extname}` : trimExtName2(importPath),
         isTypeOnly: item.isTypeOnly
       });
     }).filter(Boolean);
     const exportNodes = file.exports.map((item) => {
+      const exportPath = item.path;
+      const hasExtname = !!path.extname(exportPath);
       return module.factory.createExportDeclaration({
         name: item.name,
-        path: item.path,
+        path: options.extname && hasExtname ? `${trimExtName2(item.path)}${options.extname}` : trimExtName2(item.path),
         isTypeOnly: item.isTypeOnly,
         asAlias: item.asAlias
       });
     }).filter(Boolean);
-    const source = [module.print([...importNodes, ...exportNodes]), file.sources.map((item) => item.value).join("\n\n")].join("\n");
-    return module.print([], { source, noEmitHelpers: false });
+    return [file.banner, module.print([...importNodes, ...exportNodes]), source, file.footer].join("\n");
   }
 });
 var defaultParser = createFileParser({
-  render() {
-    return void 0;
+  async format(source) {
+    return source;
   },
-  async print(file, { logger }) {
+  async print(file) {
     return file.sources.map((item) => item.value).join("\n\n");
   }
 });
@@ -908,38 +868,21 @@ var parsers = {
   ".tsx": typeScriptParser,
   ".json": defaultParser
 };
-async function getFileParser(extName) {
-  if (!extName) {
+async function getFileParser(extname2) {
+  if (!extname2) {
     return defaultParser;
   }
-  const parser = parsers[extName];
+  const parser = parsers[extname2];
   if (!parser) {
-    console.warn(`[parser] No parser found for ${extName}, default parser will be used`);
+    console.warn(`[parser] No parser found for ${extname2}, default parser will be used`);
   }
   return parser || defaultParser;
 }
 function trimExtName2(text) {
-  const extName = text.split(".").pop();
-  return text.replace(`.${extName}`, "");
+  const extname2 = text.split(".").pop();
+  return text.replace(`.${extname2}`, "");
 }
 
-export {
-  FunctionParams,
-  isPromise,
-  isPromiseFulfilledResult,
-  isPromiseRejectedResult,
-  renderTemplate,
-  timeout,
-  getUniqueName,
-  setUniqueName,
-  URLPath,
-  createFile,
-  createFileImport,
-  createFileExport,
-  createFileParser,
-  getFileParser,
-  FileManager,
-  getSource,
-  processFiles
-};
-//# sourceMappingURL=chunk-27CPVXAT.js.map
+export { FileManager, FunctionParams, URLPath, createFile, createFileExport, createFileImport, createFileParser, getFileParser, getSource, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, processFiles, renderTemplate, setUniqueName, timeout };
+//# sourceMappingURL=chunk-DXGMSPTW.js.map
+//# sourceMappingURL=chunk-DXGMSPTW.js.map