@kubb/core 3.15.0 → 3.16.0

package/dist/utils.cjs

@@ -1,71 +1,74 @@
 'use strict';
 
-var chunkFAQ7SBKL_cjs = require('./chunk-FAQ7SBKL.cjs');
-require('./chunk-TEEWO6UV.cjs');
-require('./chunk-MKN7YSK2.cjs');
-require('./chunk-KZOJCFA7.cjs');
+var chunkQR7CQIA3_cjs = require('./chunk-QR7CQIA3.cjs');
+require('./chunk-BHSTNFNQ.cjs');
+require('./chunk-E4XLCCPK.cjs');
 
 
 
+Object.defineProperty(exports, "Cache", {
+  enumerable: true,
+  get: function () { return chunkQR7CQIA3_cjs.Cache; }
+});
 Object.defineProperty(exports, "FunctionParams", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.FunctionParams; }
+  get: function () { return chunkQR7CQIA3_cjs.FunctionParams; }
 });
 Object.defineProperty(exports, "URLPath", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.URLPath; }
+  get: function () { return chunkQR7CQIA3_cjs.URLPath; }
 });
 Object.defineProperty(exports, "createFile", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.createFile; }
+  get: function () { return chunkQR7CQIA3_cjs.createFile; }
 });
 Object.defineProperty(exports, "createFileExport", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.createFileExport; }
+  get: function () { return chunkQR7CQIA3_cjs.createFileExport; }
 });
 Object.defineProperty(exports, "createFileImport", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.createFileImport; }
+  get: function () { return chunkQR7CQIA3_cjs.createFileImport; }
 });
 Object.defineProperty(exports, "createFileParser", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.createFileParser; }
+  get: function () { return chunkQR7CQIA3_cjs.createFileParser; }
 });
 Object.defineProperty(exports, "getDefaultBanner", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.getDefaultBanner; }
+  get: function () { return chunkQR7CQIA3_cjs.getDefaultBanner; }
 });
 Object.defineProperty(exports, "getFileParser", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.getFileParser; }
+  get: function () { return chunkQR7CQIA3_cjs.getFileParser; }
 });
 Object.defineProperty(exports, "getUniqueName", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.getUniqueName; }
+  get: function () { return chunkQR7CQIA3_cjs.getUniqueName; }
 });
 Object.defineProperty(exports, "isPromise", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.isPromise; }
+  get: function () { return chunkQR7CQIA3_cjs.isPromise; }
 });
 Object.defineProperty(exports, "isPromiseFulfilledResult", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.isPromiseFulfilledResult; }
+  get: function () { return chunkQR7CQIA3_cjs.isPromiseFulfilledResult; }
 });
 Object.defineProperty(exports, "isPromiseRejectedResult", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.isPromiseRejectedResult; }
+  get: function () { return chunkQR7CQIA3_cjs.isPromiseRejectedResult; }
 });
 Object.defineProperty(exports, "renderTemplate", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.renderTemplate; }
+  get: function () { return chunkQR7CQIA3_cjs.renderTemplate; }
 });
 Object.defineProperty(exports, "setUniqueName", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.setUniqueName; }
+  get: function () { return chunkQR7CQIA3_cjs.setUniqueName; }
 });
 Object.defineProperty(exports, "timeout", {
   enumerable: true,
-  get: function () { return chunkFAQ7SBKL_cjs.timeout; }
+  get: function () { return chunkQR7CQIA3_cjs.timeout; }
 });
 //# sourceMappingURL=utils.cjs.map
 //# sourceMappingURL=utils.cjs.map

package/dist/utils.d.cts

@@ -1,6 +1,6 @@
-import { a as PossiblePromise } from './FileManager-HxsypMy8.cjs';
-export { P as ParserModule, d as createFile, b as createFileExport, c as createFileImport, e as createFileParser, g as getDefaultBanner, a as getFileParser } from './parser-Dwb7eMU3.cjs';
-import './types-CX9JVw2n.cjs';
+import { a as PossiblePromise } from './PluginManager-E3SghPP9.cjs';
+export { P as ParserModule, d as createFile, b as createFileExport, c as createFileImport, e as createFileParser, g as getDefaultBanner, a as getFileParser } from './parser-D6vU1kA9.cjs';
+import './types-CA8nQKwM.cjs';
 import './logger-BWq-oJU_.cjs';
 import 'consola/utils';
 import 'consola';
@@ -112,4 +112,15 @@ declare class URLPath {
     toURLPath(): string;
 }
 
-export { FunctionParams, type FunctionParamsAST, type URLObject, URLPath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout };
+declare class Cache<T> {
+    #private;
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    values(): Promise<T[]>;
+    flush(): Promise<void>;
+}
+
+export { Cache, FunctionParams, type FunctionParamsAST, type URLObject, URLPath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout };

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
-import { a as PossiblePromise } from './FileManager-Cm7Iylcx.js';
-export { P as ParserModule, d as createFile, b as createFileExport, c as createFileImport, e as createFileParser, g as getDefaultBanner, a as getFileParser } from './parser-CcELSk43.js';
-import './types-CX9JVw2n.js';
+import { a as PossiblePromise } from './PluginManager-PDmRCu9k.js';
+export { P as ParserModule, d as createFile, b as createFileExport, c as createFileImport, e as createFileParser, g as getDefaultBanner, a as getFileParser } from './parser-C1vOjVEd.js';
+import './types-CA8nQKwM.js';
 import './logger-BWq-oJU_.js';
 import 'consola/utils';
 import 'consola';
@@ -112,4 +112,15 @@ declare class URLPath {
     toURLPath(): string;
 }
 
-export { FunctionParams, type FunctionParamsAST, type URLObject, URLPath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout };
+declare class Cache<T> {
+    #private;
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    values(): Promise<T[]>;
+    flush(): Promise<void>;
+}
+
+export { Cache, FunctionParams, type FunctionParamsAST, type URLObject, URLPath, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout };

package/dist/utils.js

@@ -1,5 +1,5 @@
-export { FunctionParams, URLPath, createFile, createFileExport, createFileImport, createFileParser, getDefaultBanner, getFileParser, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout } from './chunk-XTSQKCYI.js';
+export { Cache, FunctionParams, URLPath, createFile, createFileExport, createFileImport, createFileParser, getDefaultBanner, getFileParser, getUniqueName, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, renderTemplate, setUniqueName, timeout } from './chunk-CAZ37TGB.js';
 import './chunk-GBYHPDPK.js';
-import './chunk-CMKZBNCX.js';
+import './chunk-YRPOID7E.js';
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "3.15.0",
+  "version": "3.16.0",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -93,11 +93,11 @@
     "js-runtime": "^0.0.8",
     "natural-orderby": "^5.0.0",
     "object-hash": "^3.0.0",
-    "p-queue": "^8.1.0",
-    "remeda": "^2.25.0",
+    "p-limit": "^6.2.0",
+    "remeda": "^2.26.0",
     "seedrandom": "^3.0.5",
     "semver": "^7.7.2",
-    "@kubb/parser-ts": "3.15.0"
+    "@kubb/parser-ts": "3.16.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -108,8 +108,8 @@
     "prettier": "^3.6.2",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "@kubb/config-ts": "3.15.0",
-    "@kubb/config-tsup": "3.15.0"
+    "@kubb/config-tsup": "3.16.0",
+    "@kubb/config-ts": "3.16.0"
   },
   "engines": {
     "node": ">=20"

package/src/BarrelManager.ts

@@ -18,13 +18,11 @@ export class BarrelManager {
     return this
   }
 
-  getFiles({ files: generatedFiles, root, meta }: { files: KubbFile.File[]; root?: string; meta?: FileMetaBase | undefined }): Array<KubbFile.File> {
+  getFiles({ files: generatedFiles, root }: { files: KubbFile.File[]; root?: string; meta?: FileMetaBase | undefined }): Array<KubbFile.File> {
     const { logger } = this.#options
 
     const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
 
-    logger?.emit('debug', { date: new Date(), logs: [`Start barrel generation for pluginKey ${meta?.pluginKey?.join('.')} and root '${root}'`] })
-
     TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
       if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
         return undefined
@@ -97,23 +95,6 @@ export class BarrelManager {
         })
       })
 
-      logger?.emit('debug', {
-        date: new Date(),
-        logs: [
-          `Generating barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with ${barrelFile.sources.length} indexable exports: '${barrelFile.sources?.map((source) => source.name).join(', ')}'`,
-        ],
-      })
-
-      logger?.emit('debug', {
-        date: new Date(),
-        logs: [
-          `Generated barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with exports: '${cachedFiles
-            .get(barrelFile.path)
-            ?.sources?.map((source) => source.name)
-            .join(', ')}'`,
-        ],
-      })
-
       if (previousBarrelFile) {
         previousBarrelFile.sources.push(...barrelFile.sources)
         previousBarrelFile.exports?.push(...(barrelFile.exports || []))

package/src/FileManager.ts

@@ -1,18 +1,19 @@
 import { extname, join, relative } from 'node:path'
 
 import { orderBy } from 'natural-orderby'
-import PQueue from 'p-queue'
 import { isDeepEqual, uniqueBy } from 'remeda'
+import pLimit from 'p-limit'
+
 import { BarrelManager } from './BarrelManager.ts'
 
 import type { KubbFile } from './fs/index.ts'
-import { read, trimExtName, write } from './fs/index.ts'
+import { trimExtName, write } from './fs/index.ts'
 import type { ResolvedFile } from './fs/types.ts'
 import type { Logger } from './logger.ts'
 import type { BarrelType, Config, Plugin } from './types.ts'
 import { createFile, getFileParser } from './utils'
-import { buildDirectoryTree, type DirectoryTree, TreeNode } from './utils/TreeNode.ts'
 import type { GreaterThan } from './utils/types.ts'
+import { Cache } from './utils/Cache.ts'
 
 export type FileMetaBase = {
   pluginKey?: Plugin['key']
@@ -26,7 +27,6 @@ type AddIndexesProps = {
    * Root based on root and output.path specified in the config
    */
   root: string
-  files: KubbFile.File[]
   /**
    * Output for plugin
    */
@@ -42,47 +42,46 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
+type WriteFilesProps = {
+  root: Config['root']
+  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
+  logger?: Logger
+  dryRun?: boolean
+}
+
 export class FileManager {
-  #filesByPath: Map<KubbFile.Path, KubbFile.ResolvedFile> = new Map()
+  #cache = new Cache<KubbFile.ResolvedFile>()
+  #limit = pLimit(100)
+
   constructor() {
     return this
   }
 
-  get files(): Array<KubbFile.ResolvedFile> {
-    return [...this.#filesByPath.values()]
-  }
+  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
+    const resolvedFiles: KubbFile.ResolvedFile[] = []
 
-  get orderedFiles(): Array<KubbFile.ResolvedFile> {
-    return orderBy(
-      [...this.#filesByPath.values()],
-      [
-        (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
-        (v) => v.path.length,
-        (v) => trimExtName(v.path).endsWith('index'),
-        (v) => trimExtName(v.baseName),
-        (v) => v.path.split('.').pop(),
-      ],
-    )
-  }
+    const mergedFiles = new Map<string, KubbFile.File>()
 
-  get groupedFiles(): DirectoryTree | null {
-    return buildDirectoryTree([...this.#filesByPath.values()])
-  }
+    files.forEach((file) => {
+      const existing = mergedFiles.get(file.path)
+      if (existing) {
+        mergedFiles.set(file.path, mergeFile(existing, file))
+      } else {
+        mergedFiles.set(file.path, file)
+      }
+    })
 
-  get treeNode(): TreeNode | null {
-    return TreeNode.build([...this.#filesByPath.values()])
-  }
+    for (const file of mergedFiles.values()) {
+      const existing = await this.#cache.get(file.path)
 
-  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
-    const promises = files.map((file) => {
-      if (file.override) {
-        return this.#add(file)
-      }
+      const merged = existing ? mergeFile(existing, file) : file
+      const resolvedFile = createFile(merged)
 
-      return this.#addOrAppend(file)
-    })
+      await this.#cache.set(resolvedFile.path, resolvedFile)
+      await this.#cache.flush()
 
-    const resolvedFiles = await Promise.all(promises)
+      resolvedFiles.push(resolvedFile)
+    }
 
     if (files.length > 1) {
       return resolvedFiles as unknown as AddResult<T>
@@ -91,52 +90,68 @@ export class FileManager {
     return resolvedFiles[0] as unknown as AddResult<T>
   }
 
-  async #add(file: KubbFile.File): Promise<ResolvedFile> {
-    const resolvedFile = createFile(file)
-
-    this.#filesByPath.set(resolvedFile.path, resolvedFile)
+  async getByPath(path: KubbFile.Path): Promise<KubbFile.ResolvedFile | null> {
+    return this.#cache.get(path)
+  }
 
-    return resolvedFile
+  async deleteByPath(path: KubbFile.Path): Promise<void> {
+    await this.#cache.delete(path)
   }
 
-  clear() {
-    this.#filesByPath.clear()
+  async clear(): Promise<void> {
+    await this.#cache.clear()
   }
 
-  async #addOrAppend(file: KubbFile.File): Promise<ResolvedFile> {
-    const previousFile = this.#filesByPath.get(file.path)
+  async getFiles(): Promise<Array<KubbFile.ResolvedFile>> {
+    const cachedKeys = await this.#cache.keys()
 
-    if (previousFile) {
-      this.#filesByPath.delete(previousFile.path)
+    // order by path length and if file is a barrel file
+    const keys = orderBy(cachedKeys, [(v) => v.length, (v) => trimExtName(v).endsWith('index')])
 
-      return this.#add(mergeFile(previousFile, file))
-    }
-    return this.#add(file)
-  }
+    const filesTasks = keys.map((key) =>
+      this.#limit(async () => {
+        const file = await this.#cache.get(key)
+        return file as KubbFile.ResolvedFile
+      }),
+    )
 
-  getCacheById(id: string): KubbFile.File | undefined {
-    return [...this.#filesByPath.values()].find((file) => file.id === id)
-  }
+    const files = await Promise.all(filesTasks)
 
-  getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined {
-    return this.#filesByPath.get(path)
+    return files.filter(Boolean)
   }
 
-  deleteByPath(path: KubbFile.Path): void {
-    const cacheItem = this.getByPath(path)
-    if (!cacheItem) {
-      return
-    }
+  async processFiles({ dryRun, root, extension, logger }: WriteFilesProps): Promise<Array<KubbFile.ResolvedFile>> {
+    const files = await this.getFiles()
 
-    this.#filesByPath.delete(path)
-  }
+    logger?.emit('progress_start', { id: 'files', size: files.length, message: 'Writing files ...' })
+
+    const promises = files.map((file) => {
+      return this.#limit(async () => {
+        const message = file ? `Writing ${relative(root, file.path)}` : ''
+        const extname = extension?.[file.extname] || undefined
+
+        if (!dryRun) {
+          const source = await getSource(file, { logger, extname })
+          await write(file.path, source, { sanity: false })
+        }
+
+        logger?.emit('progressed', { id: 'files', message })
+      })
+    })
+
+    await Promise.all(promises)
 
-  async getBarrelFiles({ type, files, meta = {}, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
+    logger?.emit('progress_stop', { id: 'files' })
+
+    return files
+  }
+  async getBarrelFiles({ type, meta = {}, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
     if (!type || type === 'propagate') {
       return []
     }
 
     const barrelManager = new BarrelManager({ logger })
+    const files = await this.getFiles()
 
     const pathToBuildFrom = join(root, output.path)
 
@@ -170,14 +185,6 @@ export class FileManager {
     })
   }
 
-  async write(...params: Parameters<typeof write>): ReturnType<typeof write> {
-    return write(...params)
-  }
-
-  async read(...params: Parameters<typeof read>): ReturnType<typeof read> {
-    return read(...params)
-  }
-
   // statics
   static getMode(path: string | undefined | null): KubbFile.Mode {
     if (!path) {
@@ -285,7 +292,7 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
         }
 
         const checker = (name?: string) => {
-          return name && !!source.includes(name)
+          return name && source.includes(name)
         }
 
         return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
@@ -343,53 +350,3 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     [] as Array<KubbFile.Import>,
   )
 }
-
-type WriteFilesProps = {
-  root: Config['root']
-  files: Array<KubbFile.ResolvedFile>
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  logger?: Logger
-  dryRun?: boolean
-}
-/**
- * Global queue
- */
-const queue = new PQueue({ concurrency: 100 })
-
-export async function processFiles({ dryRun, root, extension, logger, files }: WriteFilesProps) {
-  const orderedFiles = orderBy(files, [
-    (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
-    (v) => v.path.length,
-    (v) => trimExtName(v.path).endsWith('index'),
-  ])
-
-  logger?.emit('debug', {
-    date: new Date(),
-    logs: [JSON.stringify({ files: orderedFiles }, null, 2)],
-    fileName: 'kubb-files.log',
-  })
-
-  if (!dryRun) {
-    const size = orderedFiles.length
-
-    logger?.emit('progress_start', { id: 'files', size, message: 'Writing files ...' })
-    const promises = orderedFiles.map(async (file) => {
-      await queue.add(async () => {
-        const message = file ? `Writing ${relative(root, file.path)}` : ''
-        const extname = extension?.[file.extname] || undefined
-
-        const source = await getSource(file, { logger, extname })
-
-        await write(file.path, source, { sanity: false })
-
-        logger?.emit('progressed', { id: 'files', message })
-      })
-    })
-
-    await Promise.all(promises)
-
-    logger?.emit('progress_stop', { id: 'files' })
-  }
-
-  return files
-}

package/src/PluginManager.ts

@@ -1,5 +1,5 @@
 import { FileManager } from './FileManager.ts'
-import { isPromise, isPromiseRejectedResult } from './PromiseManager.ts'
+import { isPromiseRejectedResult } from './PromiseManager.ts'
 import { PromiseManager } from './PromiseManager.ts'
 import { ValidationPluginError } from './errors.ts'
 import { pluginCore } from './plugin.ts'
@@ -50,6 +50,10 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 
 type Options = {
   logger: Logger
+  /**
+   * @default Number.POSITIVE_INFINITY
+   */
+  concurrency?: number
 }
 
 type Events = {
@@ -215,19 +219,21 @@ export class PluginManager {
 
     this.logger.emit('progress_start', { id: hookName, size: plugins.length, message: 'Running plugins...' })
 
-    const promises = plugins
-      .map((plugin) => {
-        return this.#execute<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-          message,
-        })
+    const items: Array<ReturnType<ParseResult<H>>> = []
+
+    for (const plugin of plugins) {
+      const result = await this.#execute<H>({
+        strategy: 'hookFirst',
+        hookName,
+        parameters,
+        plugin,
+        message,
       })
-      .filter(Boolean)
 
-    const items = await Promise.all(promises)
+      if (result !== undefined && result !== null) {
+        items.push(result)
+      }
+    }
 
     this.logger.emit('progress_stop', { id: hookName })
 
@@ -374,7 +380,7 @@ export class PluginManager {
         }) as Promise<TOuput>
     })
 
-    const results = await this.#promiseManager.run('parallel', promises)
+    const results = await this.#promiseManager.run('parallel', promises, { concurrency: this.options.concurrency })
 
     results.forEach((result, index) => {
       if (isPromiseRejectedResult<Error>(result)) {
@@ -540,25 +546,27 @@ export class PluginManager {
     }
 
     this.events.emit('executing', { strategy, hookName, parameters, plugin, message })
-    const promise = new Promise((resolve) => {
-      resolve(undefined)
-    })
 
-    const task = promise
-      .then(() => {
+    const task = (async () => {
+      try {
         if (typeof hook === 'function') {
-          const possiblePromiseResult = (hook as Function).apply({ ...this.#core.context, plugin }, parameters) as Promise<ReturnType<ParseResult<H>>>
+          const result = await Promise.resolve((hook as Function).apply({ ...this.#core.context, plugin }, parameters))
 
-          if (isPromise(possiblePromiseResult)) {
-            return Promise.resolve(possiblePromiseResult)
-          }
-          return possiblePromiseResult
+          output = result
+
+          this.#addExecutedToCallStack({
+            parameters,
+            output,
+            strategy,
+            hookName,
+            plugin,
+            message,
+          })
+
+          return result
         }
 
-        return hook
-      })
-      .then((result) => {
-        output = result
+        output = hook
 
         this.#addExecutedToCallStack({
           parameters,
@@ -569,13 +577,12 @@ export class PluginManager {
           message,
         })
 
-        return result
-      })
-      .catch((e: Error) => {
-        this.#catcher<H>(e, plugin, hookName)
-
+        return hook
+      } catch (e) {
+        this.#catcher<H>(e as Error, plugin, hookName)
         return null
-      })
+      }
+    })()
 
     return task
   }

package/src/PromiseManager.ts

@@ -21,6 +21,7 @@ export class PromiseManager<TState = any> {
   run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(
     strategy: TStrategy,
     promises: TInput,
+    { concurrency = Number.POSITIVE_INFINITY }: { concurrency?: number } = {},
   ): TOutput {
     if (strategy === 'seq') {
       return hookSeq<TInput, TValue, TOutput>(promises)
@@ -31,7 +32,7 @@ export class PromiseManager<TState = any> {
     }
 
     if (strategy === 'parallel') {
-      return hookParallel<TInput, TValue, TOutput>(promises)
+      return hookParallel<TInput, TValue, TOutput>(promises, concurrency)
     }
 
     throw new Error(`${strategy} not implemented`)