@kubb/core 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/index.cjs

@@ -521,9 +521,9 @@ function isInputPath(result) {
 
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     setTimeout(() => {
-      resolve2(true);
+      resolve3(true);
     }, ms);
   });
 }
@@ -677,78 +677,67 @@ var TreeNode = class _TreeNode {
 var _options;
 var BarrelManager = class {
   constructor(options = {}) {
-    __privateAdd(this, _options, {});
+    __privateAdd(this, _options, void 0);
     __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 });
+  getIndexes(pathToBuild) {
+    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
+    const tree = TreeNode.build(pathToBuild, treeNode);
     if (!tree) {
       return null;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files, treeNode2) => {
+      if (!treeNode2.children) {
         return [];
       }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && file.data.type === "file") {
+      if (treeNode2.children.length > 1) {
+        const indexPath = path4__default.default.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: includeExt ? `${importPath}${extName}` : importPath,
+            path: extName ? `${importPath}${extName}` : importPath,
             isTypeOnly
           };
         }).filter(Boolean);
-        files2.push({
+        files.push({
           path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
+      } else if (treeNode2.children.length === 1) {
+        const [treeNodeChild] = treeNode2.children;
+        const indexPath = path4__default.default.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
+          }
         });
       }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
+      treeNode2.children.forEach((childItem) => {
+        fileReducer(files, childItem);
       });
-      return files2;
+      return files;
     };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
+    return fileReducer([], tree).reverse();
   }
 };
 _options = new WeakMap();
@@ -801,12 +790,33 @@ var _FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
+  async addIndexes({ root, output, meta, options = {} }) {
+    const exportPath = output.path.startsWith("./") ? output.path : `./${output.path}`;
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options });
+    const files = barrelManager.getIndexes(path4.resolve(root, output.path));
     if (!files) {
       return void 0;
     }
+    const rootFile = {
+      path: path4.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, {
@@ -922,7 +932,7 @@ _validate = new WeakSet();
 _add = new WeakSet();
 add_fn = async function(file) {
   const controller = new AbortController();
-  const resolvedFile = { id: crypto2__default.default.randomUUID(), ...file };
+  const resolvedFile = { id: crypto2__default.default.randomUUID(), name: transformers_default.trimExtName(file.baseName), ...file };
   __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
   if (__privateGet(this, _queue)) {
     await __privateGet(this, _queue).run(
@@ -1081,8 +1091,8 @@ var Queue = class {
     __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    return new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
         reject("Aborted");
@@ -1092,8 +1102,8 @@ var Queue = class {
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
       });
@@ -1120,13 +1130,13 @@ work_fn = function() {
   __privateWrapper(this, _workerCount)._++;
   let entry;
   while (entry = __privateGet(this, _queue2).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
+    const { reject, resolve: resolve3, job, name, description } = entry;
     if (__privateGet(this, _debug)) {
       perf_hooks.performance.mark(name + "_start");
     }
     job().then((result) => {
       this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
+      resolve3(result);
       if (__privateGet(this, _debug)) {
         perf_hooks.performance.mark(name + "_stop");
         perf_hooks.performance.measure(description, name + "_start", name + "_stop");
@@ -1964,18 +1974,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve2, args) => {
+  const run = async (fn, resolve3, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve2(result);
+    resolve3(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve2, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve2, args));
+  const enqueue = (fn, resolve3, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve3, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1983,8 +1993,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve2) => {
-    enqueue(fn, resolve2, args);
+  const generator = (fn, ...args) => new Promise((resolve3) => {
+    enqueue(fn, resolve3, args);
   });
   Object.defineProperties(generator, {
     activeCount: {