@kubb/core 2.11.1 → 2.12.1

package/src/FileManager.ts

@@ -9,11 +9,11 @@ import isEqual from 'lodash.isequal'
 import { orderBy } from 'natural-orderby'
 import PQueue from 'p-queue'
 
+import { BarrelManager } from './BarrelManager.ts'
 import { getRelativePath, read } from './fs/read.ts'
 import { write } from './fs/write.ts'
 import { searchAndReplace } from './transformers/searchAndReplace.ts'
 import { trimExtName } from './transformers/trim.ts'
-import { BarrelManager } from './BarrelManager.ts'
 
 import type { GreaterThan } from '@kubb/types'
 import type { BarrelManagerOptions } from './BarrelManager.ts'
@@ -31,11 +31,12 @@ export namespace KubbFile {
     name:
       | string
       | Array<
-        string | {
-          propertyName: string
-          name?: string
-        }
-      >
+          | string
+          | {
+              propertyName: string
+              name?: string
+            }
+        >
     /**
      * Path for the import
      * @xample '@kubb/core'
@@ -48,6 +49,7 @@ export namespace KubbFile {
     /**
      * Add `* as` prefix to the import, this will result in: `import * as path from './path'`.
      */
+
     isNameSpace?: boolean
     /**
      * When root is set it will get the path with relative getRelativePath(root, path).
@@ -109,10 +111,7 @@ export namespace KubbFile {
     pluginKey?: Plugin['key']
   }
 
-  export type File<
-    TMeta extends FileMetaBase = FileMetaBase,
-    TBaseName extends BaseName = BaseName,
-  > = {
+  export type File<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = {
     /**
      * Unique identifier to reuse later
      * @default crypto.randomUUID()
@@ -141,6 +140,11 @@ export namespace KubbFile {
      * Use extra meta, this is getting used to generate the barrel/index files.
      */
     meta?: TMeta
+    /**
+     * Override if a file can be exported by the BarrelManager
+     * @default true
+     */
+    exportable?: boolean
     /**
      * This will override `process.env[key]` inside the `source`, see `getFileSource`.
      */
@@ -151,10 +155,7 @@ export namespace KubbFile {
     language?: string
   }
 
-  export type ResolvedFile<
-    TMeta extends FileMetaBase = FileMetaBase,
-    TBaseName extends BaseName = BaseName,
-  > = KubbFile.File<TMeta, TBaseName> & {
+  export type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = KubbFile.File<TMeta, TBaseName> & {
     /**
      * @default crypto.randomUUID()
      */
@@ -224,9 +225,7 @@ export class FileManager {
     return this.#queue.size !== 0 && this.#queue.pending !== 0
   }
 
-  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(
-    ...files: T
-  ): AddResult<T> {
+  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
     const promises = combineFiles(files).map((file) => {
       if (file.override) {
         return this.#add(file)
@@ -246,7 +245,25 @@ export class FileManager {
 
   async #add(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
     const controller = new AbortController()
-    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), name: trimExtName(file.baseName), ...file }
+    const resolvedFile: KubbFile.ResolvedFile = {
+      id: crypto.randomUUID(),
+      name: trimExtName(file.baseName),
+      ...file,
+    }
+
+    if (resolvedFile.exports?.length) {
+      const folder = resolvedFile.path.replace(resolvedFile.baseName, '')
+
+      resolvedFile.exports = resolvedFile.exports.filter((exportItem) => {
+        const exportedFile = this.files.find((file) => file.path.includes(resolve(folder, exportItem.path)))
+
+        if (exportedFile) {
+          return exportedFile.exportable
+        }
+
+        return true
+      })
+    }
 
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
 
@@ -286,7 +303,10 @@ export class FileManager {
     const pathToBuildFrom = resolve(root, output.path)
     const exportPath = output.path.startsWith('./') ? trimExtName(output.path) : `./${trimExtName(output.path)}`
     const mode = FileManager.getMode(output.path)
-    const barrelManager = new BarrelManager({ extName: output.extName, ...options })
+    const barrelManager = new BarrelManager({
+      extName: output.extName,
+      ...options,
+    })
     let files = barrelManager.getIndexes(pathToBuildFrom)
 
     if (!files) {
@@ -294,7 +314,7 @@ export class FileManager {
     }
 
     if (exportType === 'barrelNamed') {
-      files = files.map(file => {
+      files = files.map((file) => {
         if (file.exports) {
           return {
             ...file,
@@ -322,16 +342,17 @@ export class FileManager {
       exports: [
         output.exportAs
           ? {
-            name: output.exportAs,
-            asAlias: true,
-            path: rootPath,
-            isTypeOnly: options.isTypeOnly,
-          }
+              name: output.exportAs,
+              asAlias: true,
+              path: rootPath,
+              isTypeOnly: options.isTypeOnly,
+            }
           : {
-            path: rootPath,
-            isTypeOnly: options.isTypeOnly,
-          },
+              path: rootPath,
+              isTypeOnly: options.isTypeOnly,
+            },
       ],
+      exportable: true,
     }
 
     if (exportType === 'barrelNamed' && !output.exportAs && rootFile.exports?.[0]) {
@@ -399,39 +420,40 @@ export class FileManager {
   }
 }
 
-function combineFiles<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(
-  files: Array<KubbFile.File<TMeta> | null>,
-): Array<KubbFile.File<TMeta>> {
-  return files.filter(Boolean).reduce((acc, file: KubbFile.File<TMeta>) => {
-    const prevIndex = acc.findIndex((item) => item.path === file.path)
+function combineFiles<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(files: Array<KubbFile.File<TMeta> | null>): Array<KubbFile.File<TMeta>> {
+  return files.filter(Boolean).reduce(
+    (acc, file: KubbFile.File<TMeta>) => {
+      const prevIndex = acc.findIndex((item) => item.path === file.path)
 
-    if (prevIndex === -1) {
-      return [...acc, file]
-    }
+      if (prevIndex === -1) {
+        return [...acc, file]
+      }
 
-    const prev = acc[prevIndex]
+      const prev = acc[prevIndex]
 
-    if (prev && file.override) {
-      acc[prevIndex] = {
-        imports: [],
-        exports: [],
-        ...file,
+      if (prev && file.override) {
+        acc[prevIndex] = {
+          imports: [],
+          exports: [],
+          ...file,
+        }
+        return acc
       }
-      return acc
-    }
 
-    if (prev) {
-      acc[prevIndex] = {
-        ...file,
-        source: prev.source && file.source ? `${prev.source}\n${file.source}` : '',
-        imports: [...(prev.imports || []), ...(file.imports || [])],
-        exports: [...(prev.exports || []), ...(file.exports || [])],
-        env: { ...(prev.env || {}), ...(file.env || {}) },
+      if (prev) {
+        acc[prevIndex] = {
+          ...file,
+          source: prev.source && file.source ? `${prev.source}\n${file.source}` : '',
+          imports: [...(prev.imports || []), ...(file.imports || [])],
+          exports: [...(prev.exports || []), ...(file.exports || [])],
+          env: { ...(prev.env || {}), ...(file.env || {}) },
+        }
       }
-    }
 
-    return acc
-  }, [] as Array<KubbFile.File<TMeta>>)
+      return acc
+    },
+    [] as Array<KubbFile.File<TMeta>>,
+  )
 }
 
 export function getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(file: KubbFile.File<TMeta>): string {
@@ -445,24 +467,26 @@ export function getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMet
   // imports should be defined and source should contain code or we have imports without them being used
   const imports = file.imports && file.source ? combineImports(file.imports, exports, file.source) : []
 
-  const importNodes = imports.filter(item => {
-    // isImportNotNeeded
-    // trim extName
-    return item.path !== trimExtName(file.path)
-  }).map((item) => {
-    return factory.createImportDeclaration({
-      name: item.name,
-      path: item.root ? getRelativePath(item.root, item.path) : item.path,
-      isTypeOnly: item.isTypeOnly,
+  const importNodes = imports
+    .filter((item) => {
+      // isImportNotNeeded
+      // trim extName
+      return item.path !== trimExtName(file.path)
+    })
+    .map((item) => {
+      return factory.createImportDeclaration({
+        name: item.name,
+        path: item.root ? getRelativePath(item.root, item.path) : item.path,
+        isTypeOnly: item.isTypeOnly,
+      })
     })
-  })
   const exportNodes = exports.map((item) =>
     factory.createExportDeclaration({
       name: item.name,
       path: item.path,
       isTypeOnly: item.isTypeOnly,
       asAlias: item.asAlias,
-    })
+    }),
   )
 
   const source = [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
@@ -472,98 +496,104 @@ export function getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMet
 }
 
 export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ['asc']).reduce((prev, curr) => {
-    const name = curr.name
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path)
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
-
-    if (prevByPathAndIsTypeOnly) {
-      // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
-      return prev
-    }
+  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ['asc']).reduce(
+    (prev, curr) => {
+      const name = curr.name
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path)
+      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
+
+      if (prevByPathAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
+        return prev
+      }
 
-    const uniquePrev = prev.findLast(
-      (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
-    )
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
+      )
 
-    if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
-      return prev
-    }
+      if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
+        return prev
+      }
 
-    if (!prevByPath) {
-      return [
-        ...prev,
-        {
-          ...curr,
-          name: Array.isArray(name) ? [...new Set(name)] : name,
-        },
-      ]
-    }
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name: Array.isArray(name) ? [...new Set(name)] : name,
+          },
+        ]
+      }
 
-    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-      prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
 
-      return prev
-    }
+        return prev
+      }
 
-    return [...prev, curr]
-  }, [] as Array<KubbFile.Export>)
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Export>,
+  )
 
   return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ['desc', 'desc'])
 }
 
 export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
-  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ['asc']).reduce((prev, curr) => {
-    let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ['asc']).reduce(
+    (prev, curr) => {
+      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
 
-    const hasImportInSource = (importName: string) => {
-      if (!source) {
-        return true
-      }
+      const hasImportInSource = (importName: string) => {
+        if (!source) {
+          return true
+        }
 
-      const checker = (name?: string) => name && !!source.includes(name)
-      return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
-    }
+        const checker = (name?: string) => name && !!source.includes(name)
+        return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
+      }
 
-    if (Array.isArray(name)) {
-      name = name.filter((item) => typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName))
-    }
+      if (Array.isArray(name)) {
+        name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
+      }
 
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
+      const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
 
-    if (prevByPathNameAndIsTypeOnly) {
-      // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
-      return prev
-    }
+      if (prevByPathNameAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
+        return prev
+      }
 
-    if (uniquePrev || (Array.isArray(name) && !name.length)) {
-      return prev
-    }
+      if (uniquePrev || (Array.isArray(name) && !name.length)) {
+        return prev
+      }
 
-    if (!prevByPath) {
-      return [
-        ...prev,
-        {
-          ...curr,
-          name,
-        },
-      ]
-    }
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name,
+          },
+        ]
+      }
 
-    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-      prevByPath.name = [...new Set([...prevByPath.name, ...name])]
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...name])]
 
-      return prev
-    }
+        return prev
+      }
 
-    if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-      return prev
-    }
+      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
+        return prev
+      }
 
-    return [...prev, curr]
-  }, [] as Array<KubbFile.Import>)
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Import>,
+  )
 
   return orderBy(combinedImports, [(v) => !v.isTypeOnly], ['desc'])
 }
@@ -588,9 +618,18 @@ function getEnvSource(source: string, env: NodeJS.ProcessEnv | undefined): strin
     }
 
     if (typeof replaceBy === 'string') {
-      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: 'process.env', key })
+      prev = searchAndReplace({
+        text: prev.replaceAll(`process.env.${key}`, replaceBy),
+        replaceBy,
+        prefix: 'process.env',
+        key,
+      })
       // removes `declare const ...`
-      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*\n`, 'ig'), ''), replaceBy, key })
+      prev = searchAndReplace({
+        text: prev.replaceAll(/(declare const).*\n/gi, ''),
+        replaceBy,
+        key,
+      })
     }
 
     return prev

package/src/PackageManager.ts

@@ -60,7 +60,7 @@ export class PackageManager {
     try {
       let location = this.getLocation(path)
 
-      if (os.platform() == 'win32') {
+      if (os.platform() === 'win32') {
         location = pathToFileURL(location).href
       }
 
@@ -107,15 +107,15 @@ export class PackageManager {
 
   #match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | undefined {
     const dependencies = {
-      ...packageJSON['dependencies'] || {},
-      ...packageJSON['devDependencies'] || {},
+      ...(packageJSON['dependencies'] || {}),
+      ...(packageJSON['devDependencies'] || {}),
     }
 
     if (typeof dependency === 'string' && dependencies[dependency]) {
       return dependencies[dependency]
     }
 
-    const matchedDependency = Object.keys(dependencies).find(dep => dep.match(dependency))
+    const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency))
 
     return matchedDependency ? dependencies[matchedDependency] : undefined
   }

package/src/PluginManager.ts

@@ -102,8 +102,13 @@ export class PluginManager {
     this.config = config
     this.logger = options.logger
     this.queue = new PQueue({ concurrency: 1 })
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue })
-    this.#promiseManager = new PromiseManager({ nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result })
+    this.fileManager = new FileManager({
+      task: options.task,
+      queue: this.queue,
+    })
+    this.#promiseManager = new PromiseManager({
+      nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
+    })
 
     const plugins = config.plugins || []
 
@@ -162,9 +167,9 @@ export class PluginManager {
 
       if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
         this.logger.emit('debug', [
-          `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nPaths: ${
-            JSON.stringify(paths, undefined, 2)
-          }\n\nFalling back on the first item.\n`,
+          `Cannot return a path where the 'pluginKey' ${
+            params.pluginKey ? JSON.stringify(params.pluginKey) : '"'
+          } is not unique enough\n\nPaths: ${JSON.stringify(paths, undefined, 2)}\n\nFalling back on the first item.\n`,
         ])
       }
 
@@ -185,9 +190,9 @@ export class PluginManager {
 
       if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
         this.logger.emit('debug', [
-          `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nNames: ${
-            JSON.stringify(names, undefined, 2)
-          }\n\nFalling back on the first item.\n`,
+          `Cannot return a name where the 'pluginKey' ${
+            params.pluginKey ? JSON.stringify(params.pluginKey) : '"'
+          } is not unique enough\n\nNames: ${JSON.stringify(names, undefined, 2)}\n\nFalling back on the first item.\n`,
         ])
       }
 
@@ -275,25 +280,25 @@ export class PluginManager {
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
   }): Promise<SafeParseResult<H>> {
-    const promises = this.#getSortedPlugins().filter(plugin => {
-      return skipped ? skipped.has(plugin) : true
-    }).map((plugin) => {
-      return async () => {
-        const value = await this.#execute<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        })
+    const promises = this.#getSortedPlugins()
+      .filter((plugin) => {
+        return skipped ? skipped.has(plugin) : true
+      })
+      .map((plugin) => {
+        return async () => {
+          const value = await this.#execute<H>({
+            strategy: 'hookFirst',
+            hookName,
+            parameters,
+            plugin,
+          })
 
-        return Promise.resolve(
-          {
+          return Promise.resolve({
             plugin,
             result: value,
-          } as SafeParseResult<H>,
-        )
-      }
-    })
+          } as SafeParseResult<H>)
+        }
+      })
 
     return this.#promiseManager.run('first', promises)
   }
@@ -313,7 +318,7 @@ export class PluginManager {
     let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
 
     for (const plugin of this.#getSortedPlugins()) {
-      if (skipped && skipped.has(plugin)) {
+      if (skipped?.has(plugin)) {
         continue
       }
 
@@ -345,19 +350,24 @@ export class PluginManager {
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined
   }): Promise<Awaited<TOuput>[]> {
     const promises = this.#getSortedPlugins().map((plugin) => {
-      return () => this.#execute({ strategy: 'hookParallel', hookName, parameters, plugin }) as Promise<TOuput>
+      return () =>
+        this.#execute({
+          strategy: 'hookParallel',
+          hookName,
+          parameters,
+          plugin,
+        }) as Promise<TOuput>
     })
 
     const results = await this.#promiseManager.run('parallel', promises)
 
-    results
-      .forEach((result, index) => {
-        if (isPromiseRejectedResult<Error>(result)) {
-          const plugin = this.#getSortedPlugins()[index]
+    results.forEach((result, index) => {
+      if (isPromiseRejectedResult<Error>(result)) {
+        const plugin = this.#getSortedPlugins()[index]
 
-          this.#catcher<H>(result.reason, plugin, hookName)
-        }
-      })
+        this.#catcher<H>(result.reason, plugin, hookName)
+      }
+    })
 
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
@@ -426,25 +436,27 @@ export class PluginManager {
     }
     // TODO add test case for sorting with pre/post
 
-    return plugins.map(plugin => {
-      if (plugin.pre) {
-        const isValid = plugin.pre.every(pluginName => plugins.find(pluginToFind => pluginToFind.name === pluginName))
+    return plugins
+      .map((plugin) => {
+        if (plugin.pre) {
+          const isValid = plugin.pre.every((pluginName) => plugins.find((pluginToFind) => pluginToFind.name === pluginName))
 
-        if (!isValid) {
-          throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, undefined, 2)})`)
+          if (!isValid) {
+            throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, undefined, 2)})`)
+          }
         }
-      }
 
-      return plugin
-    }).sort((a, b) => {
-      if (b.pre?.includes(a.name)) {
-        return 1
-      }
-      if (b.post?.includes(a.name)) {
-        return -1
-      }
-      return 0
-    })
+        return plugin
+      })
+      .sort((a, b) => {
+        if (b.pre?.includes(a.name)) {
+          return 1
+        }
+        if (b.post?.includes(a.name)) {
+          return -1
+        }
+        return 0
+      })
   }
 
   getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: Plugin['key']): Plugin[] {
@@ -652,9 +664,7 @@ export class PluginManager {
     T1 extends PluginFactoryOptions,
     T2 extends PluginFactoryOptions = never,
     T3 extends PluginFactoryOptions = never,
-    TOutput = T3 extends never ? T2 extends never ? [T1: Plugin<T1>]
-      : [T1: Plugin<T1>, T2: Plugin<T2>]
-      : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>],
+    TOutput = T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>],
   >(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput {
     let pluginNames: string[] = []
     if (typeof dependedPluginNames === 'string') {