@kubb/core 1.1.5 → 1.1.7

package/dist/index.cjs

@@ -3,42 +3,22 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var module$1 = require('module');
-var pathParser2 = require('path');
+var crypto = require('crypto');
 var fs = require('fs');
+var pathParser2 = require('path');
 var changeCase = require('change-case');
 var rimraf = require('rimraf');
 var dirTree = require('directory-tree');
-var crypto = require('crypto');
 var tsCodegen = require('@kubb/ts-codegen');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var pathParser2__default = /*#__PURE__*/_interopDefault(pathParser2);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
 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/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";
@@ -424,76 +404,7 @@ 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__default.default.resolve(this.config.root, this.config.output.path);
-      return pathParser2__default.default.resolve(root, fileName);
-    },
-    resolveName(name2) {
-      return name2;
-    }
-  };
-});
+// src/managers/fileManager/FileManager.ts
 var FileManager = class {
   cache = /* @__PURE__ */ new Map();
   task;
@@ -523,6 +434,13 @@ var FileManager = class {
     });
     return files;
   }
+  get cachedFiles() {
+    const files = [];
+    this.cache.forEach((item) => {
+      files.push(item);
+    });
+    return files;
+  }
   async add(file) {
     const cacheItem = { id: crypto__default.default.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
@@ -578,6 +496,222 @@ ${file.source}`,
     return read(...params);
   }
 };
+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;
+        }
+        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 }]
+        });
+      });
+    }
+    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, 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) {
+    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__default.default.resolve(this.config.root, this.config.output.path);
+      return pathParser2__default.default.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 = {
@@ -691,9 +825,9 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      promise = promise.then(async (result) => {
-        if (result != null) {
-          return result;
+      promise = promise.then(async (parseResult) => {
+        if (parseResult?.result != null) {
+          return parseResult;
         }
         const value = await this.execute({
           strategy: "hookFirst",
@@ -718,45 +852,38 @@ var PluginManager = class {
     parameters,
     skipped
   }) {
-    let result = null;
+    let parseResult = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = {
+      parseResult = {
         result: this.executeSync({
           strategy: "hookFirst",
           hookName,
           parameters,
           plugin
-        })
+        }),
+        plugin
       };
-      if (result != null) {
+      if (parseResult?.result != null) {
         break;
       }
     }
-    return result;
+    return parseResult;
   }
-  // parallel
+  /**
+   *
+   * Parallel, runs all plugins
+   */
   async hookParallel({
     hookName,
     parameters
   }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
-      if (plugin[hookName]?.sequential) {
-        await Promise.all(parallelPromises);
-        parallelPromises.length = 0;
-        await this.execute({
-          strategy: "hookParallel",
-          hookName,
-          parameters,
-          plugin
-        });
-      } else {
-        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
-        if (promise) {
-          parallelPromises.push(promise);
-        }
+      const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+      if (promise) {
+        parallelPromises.push(promise);
       }
     }
     const results = await Promise.allSettled(parallelPromises);
@@ -766,7 +893,10 @@ var PluginManager = class {
     }
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
-  // chains, reduces returned value, handling the reduced value as the first hook argument
+  /**
+   *
+   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   */
   hookReduceArg0({
     hookName,
     parameters,
@@ -775,11 +905,11 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then((argument02) => {
+      promise = promise.then((arg0) => {
         const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
-          parameters: [argument02, ...rest],
+          parameters: [arg0, ...rest],
           plugin
         });
         return value;
@@ -787,7 +917,9 @@ var PluginManager = class {
     }
     return promise;
   }
-  // chains
+  /**
+   * Chains plugins
+   */
   hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
@@ -937,139 +1069,9 @@ 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__default.default.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__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 }]
-        });
-      });
-    }
-    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, 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) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
-  if (result === null) {
-    return null;
-  }
   return result;
 }
 async function build(options) {

package/dist/index.d.ts

@@ -124,11 +124,12 @@ declare class FileManager {
     private queue?;
     constructor(options?: {
         queue: Queue;
-        task: QueueTask<unknown>;
+        task?: QueueTask<unknown>;
     });
     private getCache;
     getCacheByPath(path: string | undefined): CacheStore | undefined;
     get files(): File[];
+    get cachedFiles(): CacheStore[];
     add(file: File): Promise<File>;
     addOrAppend(file: File): Promise<File>;
     setStatus(id: UUID, status: Status): void;
@@ -210,21 +211,32 @@ declare class PluginManager {
         parameters: Parameters<PluginLifecycle[H]>;
         skipped?: ReadonlySet<KubbPlugin> | null;
     }): SafeParseResult<H>;
+    /**
+     *
+     * Parallel, runs all plugins
+     */
     hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
         hookName: H;
         parameters?: Parameters<PluginLifecycle[H]> | undefined;
     }): Promise<Awaited<TOuput>[]>;
+    /**
+     *
+     * Chains, reduces returned value, handling the reduced value as the first hook argument
+     */
     hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
         hookName: H;
         parameters: Parameters<PluginLifecycle[H]>;
         reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
     }): Promise<Argument0<H>>;
+    /**
+     * Chains plugins
+     */
     hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
         hookName: H;
         parameters?: Parameters<PluginLifecycle[H]>;
     }): Promise<void>;
     private getSortedPlugins;
-    private getPlugin;
+    getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin;
     private addExecuter;
     /**
      * Run an async plugin hook and return the result.