@kubb/core 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/index.cjs

@@ -6,9 +6,10 @@ var module$1 = require('module');
 var pathParser2 = require('path');
 var fs = require('fs');
 var rimraf = require('rimraf');
-var uuid = require('uuid');
 var dirTree = require('directory-tree');
+var uuid = require('uuid');
 var uniq = require('lodash.uniq');
+var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -19,19 +20,6 @@ var uniq__default = /*#__PURE__*/_interopDefault(uniq);
 
 module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('out.js', document.baseURI).href)));
 
-// src/utils/isURL.ts
-function isURL(data) {
-  try {
-    const url = new URL(data);
-    if (url?.href) {
-      return true;
-    }
-  } catch (error) {
-    return false;
-  }
-  return false;
-}
-
 // src/utils/isPromise.ts
 function isPromise(result) {
   return typeof result?.then === "function";
@@ -112,6 +100,19 @@ async function read(path) {
   }
 }
 
+// src/utils/isURL.ts
+function isURL(data) {
+  try {
+    const url = new URL(data);
+    if (url?.href) {
+      return true;
+    }
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+
 // src/utils/objectToParameters.ts
 function objectToParameters(data, options = {}) {
   return data.reduce((acc, [key, value]) => {
@@ -223,6 +224,85 @@ async function clean(path) {
     });
   });
 }
+var TreeNode = class {
+  data;
+  parent;
+  children = [];
+  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;
+  }
+  find(data) {
+    if (data === this.data) {
+      return this;
+    }
+    if (this.children) {
+      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
+        target = this.children[i].find(data);
+        if (target) {
+          return target;
+        }
+      }
+    }
+    return null;
+  }
+  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;
+  }
+  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(path, options = {}) {
+    const filteredTree = dirTree__default.default(path, { extensions: options?.extensions, exclude: options.exclude });
+    if (!filteredTree) {
+      return null;
+    }
+    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
+    const recurse = (node, item) => {
+      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
+      if (item.children?.length) {
+        item.children?.forEach((child) => {
+          recurse(subNode, child);
+        });
+      }
+    };
+    filteredTree.children?.forEach((child) => recurse(treeNode, child));
+    return treeNode;
+  }
+};
 
 // src/plugin.ts
 function createPlugin(factory) {
@@ -248,7 +328,7 @@ var definePlugin = createPlugin((options) => {
     },
     fileManager,
     async addFile(...files) {
-      return Promise.all(files.map((file) => fileManager.addOrAppend(file)));
+      return Promise.all(files.map((file) => file.override ? fileManager.add(file) : fileManager.addOrAppend(file)));
     },
     resolvePath,
     resolveName,
@@ -311,7 +391,7 @@ var FileManager = class {
     if (!file.path.endsWith(file.fileName)) ;
     const previousCache = this.getCacheByPath(file.path);
     if (previousCache) {
-      const sourceAlreadyExists = previousCache.file.source.includes(file.source);
+      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
       if (sourceAlreadyExists) {
         return Promise.resolve(file);
       }
@@ -320,7 +400,8 @@ var FileManager = class {
         ...file,
         source: `${previousCache.file.source}
 ${file.source}`,
-        imports: [...previousCache.file.imports || [], ...file.imports || []]
+        imports: [...previousCache.file.imports || [], ...file.imports || []],
+        exports: [...previousCache.file.exports || [], ...file.exports || []]
       });
     }
     return this.add(file);
@@ -351,85 +432,53 @@ ${file.source}`,
     return read(...params);
   }
 };
-var TreeNode = class {
-  data;
-  parent;
-  children = [];
-  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;
-  }
-  find(data) {
-    if (data === this.data) {
-      return this;
-    }
-    if (this.children) {
-      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
-        target = this.children[i].find(data);
-        if (target) {
-          return target;
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
+  }
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
+    }
+    if (item.children?.length > 1) {
+      const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+      const exports = item.children.map((file) => {
+        if (!file) {
+          return void 0;
         }
-      }
-    }
-    return null;
-  }
-  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;
-  }
-  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(path, options = {}) {
-    const filteredTree = dirTree__default.default(path, { extensions: options?.extensions, exclude: options.exclude });
-    if (!filteredTree) {
-      return null;
-    }
-    const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
-    const recurse = (node, item) => {
-      const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
-      if (item.children?.length) {
-        item.children?.forEach((child) => {
-          recurse(subNode, child);
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        fileName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser2__default.default.resolve(item.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          fileName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
         });
-      }
-    };
-    filteredTree.children?.forEach((child) => recurse(treeNode, child));
-    return treeNode;
-  }
-};
+      });
+    }
+    item.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
 function combineFiles(files) {
   return files.filter(Boolean).reduce((acc, curr) => {
     if (!curr) {
@@ -442,7 +491,8 @@ function combineFiles(files) {
         ...curr,
         source: `${prev.source}
 ${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []]
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
       };
     } else {
       acc.push(curr);
@@ -451,10 +501,12 @@ ${curr.source}`,
   }, []);
 }
 function getFileSource(file) {
+  let { source } = file;
   if (!file.fileName.endsWith(".ts")) {
     return file.source;
   }
   const imports = [];
+  const exports = [];
   file.imports?.forEach((curr) => {
     const exists = imports.find((imp) => imp.path === curr.path);
     if (!exists) {
@@ -472,19 +524,40 @@ function getFileSource(file) {
       }
     }
   });
-  const importSource = imports.reduce((prev, curr) => {
-    if (Array.isArray(curr.name)) {
-      return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}{ ${curr.name.join(", ")} } from "${curr.path}";`;
-    }
-    return `${prev}
-import ${curr.isTypeOnly ? "type " : ""}${curr.name} from "${curr.path}";`;
-  }, "");
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? uniq__default.default(curr.name) : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
+      exports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = uniq__default.default([...exists.name, ...curr.name]);
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createImportDeclaration({ name: curr.name, path: curr.path, asType: curr.asType })];
+  }, []);
+  const importSource = tsCodegen.print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, tsCodegen.createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = tsCodegen.print(exportNodes);
   if (importSource) {
-    return `${importSource}
-${file.source}`;
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
   }
-  return file.source;
+  return source;
 }
 
 // src/managers/pluginManager/PluginManager.ts
@@ -845,11 +918,6 @@ async function buildImplementation(options) {
     hookName: "buildStart",
     parameters: [config]
   });
-  pluginManager.fileManager.add({
-    path: isURL(config.input.path) ? config.input.path : pathParser2__default.default.resolve(config.root, config.input.path),
-    fileName: isURL(config.input.path) ? "input" : config.input.path,
-    source: isURL(config.input.path) ? config.input.path : await read(pathParser2__default.default.resolve(config.root, config.input.path))
-  });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
   return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) };
 }
@@ -924,5 +992,6 @@ exports.renderTemplate = renderTemplate;
 exports.timeout = timeout;
 exports.validatePlugins = validatePlugins;
 exports.write = write;
+exports.writeIndexes = writeIndexes;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map