@kubb/core 4.33.0 → 4.33.2

package/src/build.ts

@@ -1,18 +1,17 @@
-import { resolve } from 'node:path'
+import { dirname, resolve } from 'node:path'
+import { AsyncEventEmitter, clean, exists, formatMs, getElapsedMs, getRelativePath, URLPath, write } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Fabric } from '@kubb/react-fabric'
 import { createFabric } from '@kubb/react-fabric'
 import { typescriptParser } from '@kubb/react-fabric/parsers'
 import { fsPlugin } from '@kubb/react-fabric/plugins'
 import { isInputPath } from './config.ts'
+import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION } from './constants.ts'
 import { BuildError } from './errors.ts'
-import { clean, exists, getRelativePath, write } from './fs/index.ts'
 import { PluginManager } from './PluginManager.ts'
 import type { Config, KubbEvents, Output, Plugin, UserConfig } from './types.ts'
-import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
 import { getDiagnosticInfo } from './utils/diagnostics.ts'
-import { formatMs, getElapsedMs } from './utils/formatHrtime.ts'
-import { URLPath } from './utils/URLPath.ts'
+import type { FileMetaBase } from './utils/getBarrelFiles.ts'
 
 type BuildOptions = {
   config: UserConfig
@@ -93,10 +92,8 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
     output: {
       write: true,
       barrelType: 'named',
-      extension: {
-        '.ts': '.ts',
-      },
-      defaultBanner: 'simple',
+      extension: DEFAULT_EXTENSION,
+      defaultBanner: DEFAULT_BANNER,
       ...userConfig.output,
     },
     plugins: userConfig.plugins as Config['plugins'],
@@ -159,7 +156,7 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
   const pluginManager = new PluginManager(definedConfig, {
     fabric,
     events,
-    concurrency: 15, // Increased from 5 to 15 for better parallel plugin execution
+    concurrency: DEFAULT_CONCURRENCY,
   })
 
   return {
@@ -258,7 +255,8 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 
     if (config.output.barrelType) {
       const root = resolve(config.root)
-      const rootPath = resolve(root, config.output.path, 'index.ts')
+      const rootPath = resolve(root, config.output.path, BARREL_FILENAME)
+      const rootDir = dirname(rootPath)
 
       await events.emit('debug', {
         date: new Date(),
@@ -274,45 +272,15 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
         logs: [`Found ${barrelFiles.length} indexable files for barrel export`],
       })
 
-      // Build a Map of plugin keys to plugins for efficient lookups
-      const pluginKeyMap = new Map<string, Plugin>()
-      for (const plugin of pluginManager.plugins) {
-        pluginKeyMap.set(JSON.stringify(plugin.key), plugin)
-      }
+      const existingBarrel = fabric.files.find((f) => f.path === rootPath)
+      const existingExports = new Set(
+        existingBarrel?.exports?.flatMap((e) => (Array.isArray(e.name) ? e.name : [e.name])).filter((n): n is string => Boolean(n)) ?? [],
+      )
 
       const rootFile: KubbFile.File = {
         path: rootPath,
-        baseName: 'index.ts',
-        exports: barrelFiles
-          .flatMap((file) => {
-            const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly)
-
-            return file.sources
-              ?.map((source) => {
-                if (!file.path || !source.isIndexable) {
-                  return undefined
-                }
-
-                // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
-                const meta = file.meta as any
-                const plugin = meta?.pluginKey ? pluginKeyMap.get(JSON.stringify(meta.pluginKey)) : undefined
-                const pluginOptions = plugin?.options as {
-                  output?: Output<any>
-                }
-
-                if (!pluginOptions || pluginOptions?.output?.barrelType === false) {
-                  return undefined
-                }
-
-                return {
-                  name: config.output.barrelType === 'all' ? undefined : [source.name],
-                  path: getRelativePath(rootPath, file.path),
-                  isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
-                } as KubbFile.Export
-              })
-              .filter(Boolean)
-          })
-          .filter(Boolean),
+        baseName: BARREL_FILENAME,
+        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }),
         sources: [],
         imports: [],
         meta: {},
@@ -350,3 +318,49 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
     }
   }
 }
+
+type BuildBarrelExportsParams = {
+  barrelFiles: KubbFile.ResolvedFile[]
+  rootDir: string
+  existingExports: Set<string>
+  config: Config
+  pluginManager: PluginManager
+}
+
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }: BuildBarrelExportsParams): KubbFile.Export[] {
+  const pluginKeyMap = new Map<string, Plugin>()
+  for (const plugin of pluginManager.plugins) {
+    pluginKeyMap.set(JSON.stringify(plugin.key), plugin)
+  }
+
+  return barrelFiles.flatMap((file) => {
+    const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly)
+
+    return (file.sources ?? []).flatMap((source) => {
+      if (!file.path || !source.isIndexable) {
+        return []
+      }
+
+      const meta = file.meta as FileMetaBase | undefined
+      const plugin = meta?.pluginKey ? pluginKeyMap.get(JSON.stringify(meta.pluginKey)) : undefined
+      const pluginOptions = plugin?.options as { output?: Output<unknown> } | undefined
+
+      if (!pluginOptions || pluginOptions.output?.barrelType === false) {
+        return []
+      }
+
+      const exportName = config.output.barrelType === 'all' ? undefined : source.name ? [source.name] : undefined
+      if (exportName?.some((n) => existingExports.has(n))) {
+        return []
+      }
+
+      return [
+        {
+          name: exportName,
+          path: getRelativePath(rootDir, file.path),
+          isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
+        } satisfies KubbFile.Export,
+      ]
+    })
+  })
+}

package/src/config.ts

@@ -1,5 +1,5 @@
+import type { PossiblePromise } from '@internals/utils'
 import type { InputPath, UserConfig } from './types.ts'
-import type { PossiblePromise } from './utils/types.ts'
 
 /**
  * CLI options derived from command-line flags.

package/src/constants.ts

@@ -0,0 +1,60 @@
+import type { KubbFile } from '@kubb/fabric-core/types'
+
+export const CORE_PLUGIN_NAME = 'core' as const
+
+export const DEFAULT_MAX_LISTENERS = 100
+
+export const DEFAULT_CONCURRENCY = 15
+
+export const BARREL_FILENAME = 'index.ts' as const
+
+export const DEFAULT_BANNER = 'simple' as const
+
+export const DEFAULT_EXTENSION: Record<KubbFile.Extname, KubbFile.Extname | ''> = { '.ts': '.ts' }
+
+export const PATH_SEPARATORS = ['/', '\\'] as const
+
+export const logLevel = {
+  silent: Number.NEGATIVE_INFINITY,
+  error: 0,
+  warn: 1,
+  info: 3,
+  verbose: 4,
+  debug: 5,
+} as const
+
+export const linters = {
+  eslint: {
+    command: 'eslint',
+    args: (outputPath: string) => [outputPath, '--fix'],
+    errorMessage: 'Eslint not found',
+  },
+  biome: {
+    command: 'biome',
+    args: (outputPath: string) => ['lint', '--fix', outputPath],
+    errorMessage: 'Biome not found',
+  },
+  oxlint: {
+    command: 'oxlint',
+    args: (outputPath: string) => ['--fix', outputPath],
+    errorMessage: 'Oxlint not found',
+  },
+} as const
+
+export const formatters = {
+  prettier: {
+    command: 'prettier',
+    args: (outputPath: string) => ['--ignore-unknown', '--write', outputPath],
+    errorMessage: 'Prettier not found',
+  },
+  biome: {
+    command: 'biome',
+    args: (outputPath: string) => ['format', '--write', outputPath],
+    errorMessage: 'Biome not found',
+  },
+  oxfmt: {
+    command: 'oxfmt',
+    args: (outputPath: string) => [outputPath],
+    errorMessage: 'Oxfmt not found',
+  },
+} as const

package/src/errors.ts

@@ -1,14 +1 @@
-export class ValidationPluginError extends Error {}
-
-export class BuildError extends Error {
-  cause: Error | undefined
-  errors: Array<Error>
-
-  constructor(message: string, options: { cause?: Error; errors: Array<Error> }) {
-    super(message, { cause: options.cause })
-
-    this.name = 'BuildError'
-    this.cause = options.cause
-    this.errors = options.errors
-  }
-}
+export { BuildError, ValidationPluginError } from '@internals/utils'

package/src/index.ts

@@ -1,13 +1,16 @@
-export { BaseGenerator } from './BaseGenerator.ts'
 export { build, build as default, safeBuild, setup } from './build.ts'
 export { type CLIOptions, defineConfig, isInputPath } from './config.ts'
+export { formatters, linters, logLevel } from './constants.ts'
 export { defineLogger } from './defineLogger.ts'
 export { definePlugin } from './definePlugin.ts'
 export { PackageManager } from './PackageManager.ts'
 export { getMode, PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
 export * from './types.ts'
+export type { FunctionParamsAST } from './utils/FunctionParams.ts'
+export { FunctionParams } from './utils/FunctionParams.ts'
+export { detectFormatter } from './utils/formatters.ts'
 export type { FileMetaBase } from './utils/getBarrelFiles.ts'
 export { getBarrelFiles } from './utils/getBarrelFiles.ts'
-export type { PackageManagerInfo, PackageManagerName } from './utils/packageManager.ts'
-export { detectPackageManager } from './utils/packageManager.ts'
+export { getConfigs } from './utils/getConfigs.ts'
+export { detectLinter } from './utils/linters.ts'

package/src/types.ts

@@ -1,9 +1,9 @@
+import type { AsyncEventEmitter, PossiblePromise } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Fabric } from '@kubb/react-fabric'
+import type { logLevel } from './constants.ts'
 import type { KubbEvents } from './Kubb.ts'
 import type { PluginManager } from './PluginManager.ts'
-import type { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
-import type { PossiblePromise } from './utils/types.ts'
 
 declare global {
   namespace Kubb {
@@ -165,7 +165,7 @@ export type PluginFactoryOptions<
   /**
    * Context that you want to expose to other plugins.
    */
-  TContext = any,
+  TContext = unknown,
   /**
    * When calling `resolvePath` you can specify better types.
    */
@@ -211,7 +211,7 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
 
 export type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>
 
-type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>
+export type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>
 
 export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
@@ -362,20 +362,11 @@ export type Group = {
   name?: (context: GroupContext) => string
 }
 
-export const LogLevel = {
-  silent: Number.NEGATIVE_INFINITY,
-  error: 0,
-  warn: 1,
-  info: 3,
-  verbose: 4,
-  debug: 5,
-} as const
-
 export type LoggerOptions = {
   /**
    * @default 3
    */
-  logLevel: (typeof LogLevel)[keyof typeof LogLevel]
+  logLevel: (typeof logLevel)[keyof typeof logLevel]
 }
 
 /**

package/src/utils/FunctionParams.ts

@@ -1,5 +1,5 @@
+import { camelCase } from '@internals/utils'
 import { sortBy } from 'remeda'
-import { camelCase } from '../transformers/casing.ts'
 
 type FunctionParamsASTWithoutType = {
   name?: string
@@ -38,9 +38,6 @@ export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsAST
  */
 export class FunctionParams {
   #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []
-  constructor() {
-    return this
-  }
 
   get items(): FunctionParamsAST[] {
     return this.#items.flat()
@@ -52,9 +49,11 @@ export class FunctionParams {
     }
 
     if (Array.isArray(item)) {
-      item.filter(Boolean).forEach((it) => {
-        this.#items.push(it)
-      })
+      item
+        .filter((x): x is FunctionParamsAST | FunctionParamsAST[] => x !== undefined)
+        .forEach((it) => {
+          this.#items.push(it)
+        })
       return this
     }
     this.#items.push(item)
@@ -83,7 +82,7 @@ export class FunctionParams {
 
       return acc
     }
-    // TODO check whey we still need the camelcase here
+    // TODO check why we still need the camelcase here
     const parameterName = name.startsWith('{') ? name : camelCase(name)
 
     if (type) {

package/src/utils/TreeNode.ts

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import { getMode } from '../PluginManager.ts'
 
@@ -20,7 +21,6 @@ export class TreeNode {
   constructor(data: BarrelData, parent?: TreeNode) {
     this.data = data
     this.parent = parent
-    return this
   }
 
   addChild(data: BarrelData): TreeNode {
@@ -49,12 +49,9 @@ export class TreeNode {
       return this.#cachedLeaves
     }
 
-    // if not a leaf, return all children's leaves recursively
     const leaves: TreeNode[] = []
-    if (this.children) {
-      for (let childIndex = 0, { length } = this.children; childIndex < length; childIndex++) {
-        leaves.push.apply(leaves, this.children[childIndex]!.leaves)
-      }
+    for (const child of this.children) {
+      leaves.push(...child.leaves)
     }
 
     this.#cachedLeaves = leaves
@@ -67,14 +64,10 @@ export class TreeNode {
       throw new TypeError('forEach() callback must be a function')
     }
 
-    // run this node through function
     callback(this)
 
-    // do the same for all children
-    if (this.children) {
-      for (let childIndex = 0, { length } = this.children; childIndex < length; childIndex++) {
-        this.children[childIndex]?.forEach(callback)
-      }
+    for (const child of this.children) {
+      child.forEach(callback)
     }
 
     return this
@@ -153,16 +146,16 @@ export class TreeNode {
   }
 }
 
-export type DirectoryTree = {
+type DirectoryTree = {
   name: string
   path: string
   file?: KubbFile.File
   children: Array<DirectoryTree>
 }
 
-const normalizePath = (p: string): string => p.replace(/\\/g, '/')
+const normalizePath = (p: string): string => p.replaceAll('\\', '/')
 
-export function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
+function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
   const normalizedRootFolder = normalizePath(rootFolder)
   const rootPrefix = normalizedRootFolder.endsWith('/') ? normalizedRootFolder : `${normalizedRootFolder}/`
 
@@ -182,17 +175,13 @@ export function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = '')
   }
 
   filteredFiles.forEach((file) => {
-    const path = file.path.slice(rootFolder.length)
-    const parts = path.split('/')
+    const relativePath = file.path.slice(rootFolder.length)
+    const parts = relativePath.split('/').filter(Boolean)
     let currentLevel: DirectoryTree[] = root.children
-    let currentPath = rootFolder
+    let currentPath = normalizePath(rootFolder)
 
     parts.forEach((part, index) => {
-      if (index !== 0) {
-        currentPath += `/${part}`
-      } else {
-        currentPath += `${part}`
-      }
+      currentPath = path.posix.join(currentPath, part)
 
       let existingNode = currentLevel.find((node) => node.name === part)
 

package/src/utils/executeStrategies.ts

@@ -20,11 +20,13 @@ export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue,
         const calledFunc = func(state as TValue)
 
         if (calledFunc) {
-          return calledFunc.then(Array.prototype.concat.bind(state))
+          return calledFunc.then(Array.prototype.concat.bind(state) as (result: TValue) => TValue[])
         }
+
+        return state
       })
     },
-    Promise.resolve([] as unknown),
+    Promise.resolve([] as Array<TValue>),
   ) as TOutput
 }
 
@@ -35,7 +37,7 @@ type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = u
  */
 export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
   promises: TInput,
-  nullCheck = (state: any) => state !== null,
+  nullCheck: (state: unknown) => boolean = (state) => state !== null,
 ): TOutput {
   let promise: Promise<unknown> = Promise.resolve(null) as Promise<unknown>
 

package/src/utils/formatters.ts

@@ -1,22 +1,5 @@
 import { x } from 'tinyexec'
-
-export const formatters = {
-  prettier: {
-    command: 'prettier',
-    args: (outputPath: string) => ['--ignore-unknown', '--write', outputPath],
-    errorMessage: 'Prettier not found',
-  },
-  biome: {
-    command: 'biome',
-    args: (outputPath: string) => ['format', '--write', outputPath],
-    errorMessage: 'Biome not found',
-  },
-  oxfmt: {
-    command: 'oxfmt',
-    args: (outputPath: string) => [outputPath],
-    errorMessage: 'Oxfmt not found',
-  },
-} as const
+import type { formatters } from '../constants.ts'
 
 type Formatter = keyof typeof formatters
 
@@ -61,9 +44,9 @@ async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
  * ```
  */
 export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatters: Formatter[] = ['biome', 'oxfmt', 'prettier']
+  const formatterNames: Formatter[] = ['biome', 'oxfmt', 'prettier']
 
-  for (const formatter of formatters) {
+  for (const formatter of formatterNames) {
     if (await isFormatterAvailable(formatter)) {
       return formatter
     }

package/src/utils/getBarrelFiles.ts

@@ -28,7 +28,13 @@ type AddIndexesProps = {
 }
 
 function trimExtName(text: string): string {
-  return text.replace(/\.[^/.]+$/, '')
+  const dotIndex = text.lastIndexOf('.')
+  // Only strip when the dot is found and no path separator follows it
+  // (guards against stripping dots that are part of a directory name like /project.v2/gen)
+  if (dotIndex > 0 && !text.includes('/', dotIndex)) {
+    return text.slice(0, dotIndex)
+  }
+  return text
 }
 
 export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<KubbFile.File[]> {
@@ -36,7 +42,7 @@ export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type
     return []
   }
 
-  const barrelManager = new BarrelManager({})
+  const barrelManager = new BarrelManager()
 
   const pathToBuildFrom = join(root, output.path)
 

package/src/utils/getConfigs.ts

@@ -1,32 +1,23 @@
 import type { CLIOptions, defineConfig } from '../config.ts'
 import type { Config, UserConfig } from '../types.ts'
 import { getPlugins } from './getPlugins.ts'
-import { isPromise } from './promise.ts'
 
 /**
  * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
  */
 export async function getConfigs(config: ReturnType<typeof defineConfig> | UserConfig, args: CLIOptions): Promise<Array<Config>> {
-  let kubbUserConfig = Promise.resolve(config) as Promise<UserConfig | Array<UserConfig>>
+  const resolvedConfig: Promise<UserConfig | Array<UserConfig>> =
+    typeof config === 'function' ? Promise.resolve(config(args as CLIOptions)) : Promise.resolve(config)
 
-  // for ts or js files
-  if (typeof config === 'function') {
-    const possiblePromise = config(args as CLIOptions)
-    if (isPromise(possiblePromise)) {
-      kubbUserConfig = possiblePromise
-    }
-    kubbUserConfig = Promise.resolve(possiblePromise)
-  }
-
-  let JSONConfig = await kubbUserConfig
+  let userConfigs = await resolvedConfig
 
-  if (!Array.isArray(JSONConfig)) {
-    JSONConfig = [JSONConfig]
+  if (!Array.isArray(userConfigs)) {
+    userConfigs = [userConfigs]
   }
 
   const results: Array<Config> = []
 
-  for (const item of JSONConfig) {
+  for (const item of userConfigs) {
     const plugins = item.plugins ? await getPlugins(item.plugins) : undefined
 
     results.push({

package/src/utils/getPlugins.ts

@@ -1,16 +1,16 @@
-import type { UserConfig } from '../types.ts'
+import type { UnknownUserPlugin, UserConfig } from '../types.ts'
 
-function isJSONPlugins(plugins: UserConfig['plugins']) {
-  return !!(plugins as any)?.some((plugin: any) => {
-    return Array.isArray(plugin) && typeof plugin?.at(0) === 'string'
-  })
+type PluginsArray = Array<Omit<UnknownUserPlugin, 'inject'>>
+
+function isJSONPlugins(plugins: UserConfig['plugins']): boolean {
+  return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof (plugin as unknown[])[0] === 'string')
 }
 
-function isObjectPlugins(plugins: UserConfig['plugins']): plugins is any {
+function isObjectPlugins(plugins: UserConfig['plugins']): boolean {
   return plugins instanceof Object && !Array.isArray(plugins)
 }
 
-export function getPlugins(plugins: UserConfig['plugins']): Promise<UserConfig['plugins']> {
+export function getPlugins(plugins: UserConfig['plugins']): Promise<PluginsArray | undefined> {
   if (isObjectPlugins(plugins)) {
     throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
   }

package/src/utils/linters.ts

@@ -1,22 +1,5 @@
 import { x } from 'tinyexec'
-
-export const linters = {
-  eslint: {
-    command: 'eslint',
-    args: (outputPath: string) => [outputPath, '--fix'],
-    errorMessage: 'Eslint not found',
-  },
-  biome: {
-    command: 'biome',
-    args: (outputPath: string) => ['lint', '--fix', outputPath],
-    errorMessage: 'Biome not found',
-  },
-  oxlint: {
-    command: 'oxlint',
-    args: (outputPath: string) => ['--fix', outputPath],
-    errorMessage: 'Oxlint not found',
-  },
-} as const
+import type { linters } from '../constants.ts'
 
 type Linter = keyof typeof linters
 
@@ -30,9 +13,9 @@ async function isLinterAvailable(linter: Linter): Promise<boolean> {
 }
 
 export async function detectLinter(): Promise<Linter | undefined> {
-  const linters: Linter[] = ['biome', 'oxlint', 'eslint']
+  const linterNames: Linter[] = ['biome', 'oxlint', 'eslint']
 
-  for (const linter of linters) {
+  for (const linter of linterNames) {
     if (await isLinterAvailable(linter)) {
       return linter
     }