@kubb/core 1.0.0-beta.8 → 1.0.0

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 }; }
 
@@ -17,20 +18,7 @@ var rimraf__default = /*#__PURE__*/_interopDefault(rimraf);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 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;
-}
+module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('out.js', document.baseURI).href)));
 
 // src/utils/isPromise.ts
 function isPromise(result) {
@@ -53,17 +41,6 @@ async function write(data, path) {
   }
   return safeWriteFileToPath(path, data);
 }
-async function clean(path) {
-  return new Promise((resolve, reject) => {
-    rimraf__default.default(path, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(true);
-      }
-    });
-  });
-}
 
 // src/utils/cache.ts
 function createPluginCache(cache) {
@@ -99,7 +76,7 @@ function slash(path) {
 }
 function getRelativePath(rootDir, filePath) {
   if (!rootDir || !filePath) {
-    throw new Error("Root and file should be filled in when retrieving the relativePath");
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir} ${filePath}`);
   }
   const relativePath = pathParser2__default.default.relative(rootDir, filePath);
   const path = slash(relativePath).replace("../", "").trimEnd();
@@ -123,16 +100,30 @@ 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 = {}) {
+  const { typed } = options;
   return data.reduce((acc, [key, value]) => {
-    if (options.typed) {
-      acc.push(`${key}: ${value}["${key}"], `);
+    if (typed) {
+      acc.push(`${key}: ${value}["${key}"]`);
     } else {
-      acc.push(`${key},`);
+      acc.push(`${key}`);
     }
     return acc;
-  }, []).join("");
+  }, []).join(", ");
 }
 
 // src/utils/nameSorter.ts
@@ -180,7 +171,7 @@ async function timeout(ms) {
   });
 }
 
-// src/utils/queue.ts
+// src/utils/Queue.ts
 var Queue = class {
   queue = [];
   workerCount = 0;
@@ -208,6 +199,205 @@ var Queue = class {
   }
 };
 
+// src/utils/getEncodedText.ts
+function getEncodedText(text) {
+  return text ? text.replaceAll("`", "\\`") : "";
+}
+
+// src/utils/renderTemplate.ts
+function renderTemplate(template, data = void 0) {
+  if (!data) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  return template.replace(/{{(.*?)}}/g, (match) => {
+    const value = data[match.split(/{{|}}/).filter(Boolean)[0].trim()];
+    return value || "";
+  });
+}
+async function clean(path) {
+  return new Promise((resolve, reject) => {
+    rimraf__default.default(path, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+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/utils/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 (reservedWords.includes(word)) {
+    return `_${word}`;
+  }
+  return word;
+}
+
 // src/plugin.ts
 function createPlugin(factory) {
   return (options) => {
@@ -231,11 +421,14 @@ var definePlugin = createPlugin((options) => {
       return options.config;
     },
     fileManager,
-    async addFile(file) {
-      return fileManager.addOrAppend(file);
+    async addFile(...files) {
+      return Promise.all(files.map((file) => file.override ? fileManager.add(file) : fileManager.addOrAppend(file)));
     },
     resolvePath,
-    resolveName,
+    resolveName: (params) => {
+      const name2 = resolveName(params);
+      return transformReservedWord(name2);
+    },
     load,
     cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
@@ -243,11 +436,9 @@ var definePlugin = createPlugin((options) => {
     name,
     options,
     api,
-    resolvePath(fileName, directory) {
-      if (!directory) {
-        return null;
-      }
-      return pathParser2__default.default.resolve(directory, fileName);
+    resolvePath(fileName) {
+      const root = pathParser2__default.default.resolve(this.config.root, this.config.output.path);
+      return pathParser2__default.default.resolve(root, fileName);
     },
     resolveName(name2) {
       return name2;
@@ -294,14 +485,20 @@ var FileManager = class {
     return file;
   }
   addOrAppend(file) {
+    if (!file.path.endsWith(file.fileName)) ;
     const previousCache = this.getCacheByPath(file.path);
     if (previousCache) {
+      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source);
+      if (sourceAlreadyExists) {
+        return Promise.resolve(file);
+      }
       this.cache.delete(previousCache.id);
       return this.add({
         ...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);
@@ -332,85 +529,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;
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
   }
-  find(data) {
-    if (data === this.data) {
-      return this;
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
     }
-    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;
+    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) {
@@ -423,7 +588,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);
@@ -432,10 +598,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) {
@@ -453,19 +621,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, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  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
@@ -787,7 +976,7 @@ async function transformReducer(_previousCode, result, _plugin) {
   }
   return result;
 }
-async function buildImplementation(options, done) {
+async function buildImplementation(options) {
   const { config, logger } = options;
   if (config.output.clean) {
     await clean(config.output.path);
@@ -827,19 +1016,15 @@ async function buildImplementation(options, done) {
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  setTimeout(() => {
-    done({ files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) });
-  }, 500);
-  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))
-  });
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) };
 }
 function build(options) {
   return new Promise(async (resolve, reject) => {
     try {
-      await buildImplementation(options, resolve);
+      const output = await buildImplementation(options);
+      setTimeout(() => {
+        resolve(output);
+      }, 500);
     } catch (e) {
       reject(e);
     }
@@ -888,6 +1073,7 @@ exports.createPlugin = createPlugin;
 exports.createPluginCache = createPluginCache;
 exports.default = src_default;
 exports.defineConfig = defineConfig;
+exports.getEncodedText = getEncodedText;
 exports.getFileSource = getFileSource;
 exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
@@ -899,8 +1085,11 @@ exports.name = name;
 exports.nameSorter = nameSorter;
 exports.objectToParameters = objectToParameters;
 exports.read = read;
+exports.renderTemplate = renderTemplate;
 exports.timeout = timeout;
+exports.transformReservedWord = transformReservedWord;
 exports.validatePlugins = validatePlugins;
 exports.write = write;
+exports.writeIndexes = writeIndexes;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map