@kubb/core 1.1.6 → 1.1.8

package/dist/index.d.ts

@@ -13,7 +13,7 @@ interface Cache<T extends object = object> {
 }
 declare function createPluginCache<T extends Record<string, [number, unknown]>>(cache: T): Cache<T>;
 
-declare function getRelativePath(rootDir?: string | null, filePath?: string | null): string;
+declare function getRelativePath(rootDir?: string | null, filePath?: string | null, platform?: 'windows' | 'mac' | 'linux'): string;
 type PathMode = 'file' | 'directory';
 declare function getPathMode(path: string | undefined | null): PathMode;
 declare function read(path: string): Promise<string>;
@@ -67,9 +67,9 @@ declare class TreeNode<T = unknown> {
     children: Array<TreeNode<T>>;
     constructor(data: T, parent?: TreeNode<T>);
     addChild(data: T): TreeNode<T>;
-    find(data: T): {} | null;
-    leaves(): TreeNode<T>[];
-    root(): TreeNode<T>;
+    find(data?: T): TreeNode<T> | null;
+    get leaves(): TreeNode<T>[];
+    get root(): TreeNode<T>;
     forEach(callback: (treeNode: TreeNode<T>) => void): this;
     static build<T = unknown>(path: string, options?: TreeNodeOptions): TreeNode<T> | null;
 }
@@ -78,6 +78,8 @@ declare function transformReservedWord(word?: string | null): string | null | un
 
 declare function getStackTrace(belowFn?: Function): NodeJS.CallSite[];
 
+declare const uniqueId: (str?: string) => string;
+
 type Import = {
     name: string | string[];
     path: string;
@@ -139,7 +141,7 @@ declare class FileManager {
     read(...params: Parameters<typeof read>): Promise<string>;
 }
 
-declare function writeIndexes(root: string, options: TreeNodeOptions): File[] | undefined;
+declare function writeIndexes(root: string, options?: TreeNodeOptions): File[] | null;
 declare function combineFiles(files: Array<File | null>): File[];
 declare function getFileSource(file: File): string;
 
@@ -553,4 +555,4 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-export { Argument0, BuildOutput, CLIOptions, Cache, CacheStore, CorePluginOptions, Executer, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, Logger, MaybePromise, OnExecute, OptionalPath, ParallelPluginError, ParseResult, Path, PathMode, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SafeParseResult, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
+export { Argument0, BuildOutput, CLIOptions, Cache, CacheStore, CorePluginOptions, Executer, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, Logger, MaybePromise, OnExecute, OptionalPath, ParallelPluginError, ParseResult, Path, PathMode, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SafeParseResult, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };

package/dist/index.js

@@ -1,34 +1,14 @@
 import { createRequire } from 'module';
-import pathParser2 from 'node:path';
+import crypto from 'node:crypto';
 import { promises } from 'node:fs';
+import pathParser2 from 'node:path';
 import { camelCase, camelCaseTransformMerge } from 'change-case';
 import { rimraf } from 'rimraf';
 import dirTree from 'directory-tree';
-import crypto from 'node:crypto';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
 
-// src/managers/pluginManager/PluginError.ts
-var PluginError = class extends Error {
-  pluginManager;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.pluginManager = options.pluginManager;
-  }
-};
-
-// src/managers/pluginManager/ParallelPluginError.ts
-var ParallelPluginError = class extends Error {
-  errors;
-  pluginManager;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.errors = options.errors;
-    this.pluginManager = options.pluginManager;
-  }
-};
-
 // src/utils/isPromise.ts
 function isPromise(result) {
   return typeof result?.then === "function";
@@ -76,19 +56,19 @@ function createPluginCache(cache) {
     }
   };
 }
-function slash(path) {
+function slash(path, platform = "linux") {
   const isExtendedLengthPath = /^\\\\\?\\/.test(path);
-  if (isExtendedLengthPath) {
-    return path;
+  if (isExtendedLengthPath || platform === "linux" || platform === "mac") {
+    return path.replace("../", "").trimEnd();
   }
-  return path.replace(/\\/g, "/");
+  return path.replace(/\\/g, "/").replace("../", "").trimEnd();
 }
-function getRelativePath(rootDir, filePath) {
+function getRelativePath(rootDir, filePath, platform = "linux") {
   if (!rootDir || !filePath) {
     throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir} ${filePath}`);
   }
   const relativePath = pathParser2.relative(rootDir, filePath);
-  const path = slash(relativePath).replace("../", "").trimEnd();
+  const path = slash(relativePath, platform);
   if (path.startsWith("../")) {
     return path.replace(pathParser2.basename(path), pathParser2.basename(path, pathParser2.extname(filePath)));
   }
@@ -101,12 +81,7 @@ function getPathMode(path) {
   return pathParser2.extname(path) ? "file" : "directory";
 }
 async function read(path) {
-  try {
-    return promises.readFile(path, { encoding: "utf8" });
-  } catch (err) {
-    console.error(err);
-    throw err;
-  }
+  return promises.readFile(path, { encoding: "utf8" });
 }
 
 // src/utils/isURL.ts
@@ -243,10 +218,13 @@ var TreeNode = class {
     return child;
   }
   find(data) {
+    if (!data) {
+      return null;
+    }
     if (data === this.data) {
       return this;
     }
-    if (this.children) {
+    if (this.children?.length) {
       for (let i = 0, { length } = this.children, target = null; i < length; i++) {
         target = this.children[i].find(data);
         if (target) {
@@ -256,23 +234,23 @@ var TreeNode = class {
     }
     return null;
   }
-  leaves() {
+  get 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());
+        leaves.push.apply(leaves, this.children[i].leaves);
       }
     }
     return leaves;
   }
-  root() {
+  get root() {
     if (!this.parent) {
       return this;
     }
-    return this.parent.root();
+    return this.parent.root;
   }
   forEach(callback) {
     if (typeof callback !== "function") {
@@ -287,21 +265,26 @@ var TreeNode = class {
     return this;
   }
   static build(path, options = {}) {
-    const filteredTree = dirTree(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);
-        });
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
+      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      if (!filteredTree) {
+        return null;
       }
-    };
-    filteredTree.children?.forEach((child) => recurse(treeNode, child));
-    return treeNode;
+      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(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 index files with the TreehNode class", { cause: e });
+    }
   }
 };
 
@@ -414,76 +397,10 @@ function getStackTrace(belowFn) {
   return v8StackTrace;
 }
 
-// src/plugin.ts
-function createPlugin(factory) {
-  return (options) => {
-    const plugin = factory(options);
-    if (Array.isArray(plugin)) {
-      throw new Error("Not implemented");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
-    }
-    return plugin;
-  };
-}
-var name = "core";
-var definePlugin = createPlugin((options) => {
-  const { fileManager, resolvePath, resolveName, load } = options;
-  const api = {
-    get config() {
-      return options.config;
-    },
-    fileManager,
-    async addFile(...files) {
-      const trace = getStackTrace();
-      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
-        if (a.name.length < b.name.length)
-          return 1;
-        if (a.name.length > b.name.length)
-          return -1;
-        return 0;
-      });
-      const pluginName = plugins?.[0].name;
-      return Promise.all(
-        files.map((file) => {
-          const fileWithMeta = {
-            ...file,
-            meta: {
-              ...file.meta || {},
-              pluginName
-            }
-          };
-          if (file.override) {
-            return fileManager.add(fileWithMeta);
-          }
-          return fileManager.addOrAppend(fileWithMeta);
-        })
-      );
-    },
-    resolvePath,
-    resolveName: (params) => {
-      const name2 = resolveName(params);
-      return transformReservedWord(name2);
-    },
-    load,
-    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
-  };
-  return {
-    name,
-    options,
-    api,
-    resolvePath(fileName) {
-      const root = pathParser2.resolve(this.config.root, this.config.output.path);
-      return pathParser2.resolve(root, fileName);
-    },
-    resolveName(name2) {
-      return name2;
-    }
-  };
-});
+// src/utils/uniqueId.ts
+var uniqueId = ((counter) => (str = "") => `${str}${++counter}`)(0);
+
+// src/managers/fileManager/FileManager.ts
 var FileManager = class {
   cache = /* @__PURE__ */ new Map();
   task;
@@ -575,6 +492,219 @@ ${file.source}`,
     return read(...params);
   }
 };
+function writeIndexes(root, options = {}) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return null;
+  }
+  const fileReducer = (files2, currentTree) => {
+    if (!currentTree.children) {
+      return [];
+    }
+    if (currentTree.children?.length > 1) {
+      const path = pathParser2.resolve(currentTree.data.path, "index.ts");
+      const exports = currentTree.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        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 {
+      currentTree.children?.forEach((child) => {
+        const path = pathParser2.resolve(currentTree.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 }]
+        });
+      });
+    }
+    currentTree.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: `${prev.source}
+${curr.source}`,
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const existingImport = imports.find((imp) => imp.path === curr.path);
+    if (!existingImport) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (existingImport && !Array.isArray(existingImport.name) && existingImport.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (existingImport && Array.isArray(existingImport.name)) {
+      if (Array.isArray(curr.name)) {
+        existingImport.name = [.../* @__PURE__ */ new Set([...existingImport.name, ...curr.name])];
+      }
+    }
+  });
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(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 = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  const importSource = print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = print(exportNodes);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
+function createPlugin(factory) {
+  return (options) => {
+    const plugin = factory(options);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
+    }
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
+    }
+    return plugin;
+  };
+}
+var name = "core";
+var definePlugin = createPlugin((options) => {
+  const { fileManager, resolvePath, resolveName, load } = options;
+  const api = {
+    get config() {
+      return options.config;
+    },
+    fileManager,
+    async addFile(...files) {
+      const trace = getStackTrace();
+      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
+        if (a.name.length < b.name.length)
+          return 1;
+        if (a.name.length > b.name.length)
+          return -1;
+        return 0;
+      });
+      const pluginName = plugins?.[0].name;
+      return Promise.all(
+        files.map((file) => {
+          const fileWithMeta = {
+            ...file,
+            meta: {
+              ...file.meta || {},
+              pluginName
+            }
+          };
+          if (file.override) {
+            return fileManager.add(fileWithMeta);
+          }
+          return fileManager.addOrAppend(fileWithMeta);
+        })
+      );
+    },
+    resolvePath,
+    resolveName: (params) => {
+      const name2 = resolveName(params);
+      return transformReservedWord(name2);
+    },
+    load,
+    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
+  };
+  return {
+    name,
+    options,
+    api,
+    resolvePath(fileName) {
+      const root = pathParser2.resolve(this.config.root, this.config.output.path);
+      return pathParser2.resolve(root, fileName);
+    },
+    resolveName(name2) {
+      return name2;
+    }
+  };
+});
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors;
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.errors = options.errors;
+    this.pluginManager = options.pluginManager;
+  }
+};
+
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.pluginManager = options.pluginManager;
+  }
+};
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -932,133 +1062,6 @@ function validatePlugins(plugins, dependedPluginNames) {
   });
   return true;
 }
-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.resolve(item.data.path, "index.ts");
-      const exports = item.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
-        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.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 }]
-        });
-      });
-    }
-    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) {
-      return acc;
-    }
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex];
-      acc[prevIndex] = {
-        ...curr,
-        source: `${prev.source}
-${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
-      };
-    } else {
-      acc.push(curr);
-    }
-    return acc;
-  }, []);
-}
-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) {
-      imports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
-      imports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
-      }
-    }
-  });
-  file.exports?.forEach((curr) => {
-    const exists = exports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      exports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(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 = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
-      }
-    }
-  });
-  const importNodes = imports.reduce((prev, curr) => {
-    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
-  }, []);
-  const importSource = print(importNodes);
-  const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
-  }, []);
-  const exportSource = print(exportNodes);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
@@ -1071,7 +1074,7 @@ async function build(options) {
       await read(config.input.path);
     }
   } catch (e) {
-    throw new Error("Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
+    throw new Error("Cannot read file/URL defined in `input.path` or set with --input in the CLI of your Kubb config", { cause: e });
   }
   if (config.output.clean) {
     await clean(config.output.path);
@@ -1154,4 +1157,4 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
+export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, uniqueId, validatePlugins, write, writeIndexes };