@kubb/core 4.32.4 → 4.33.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "4.32.4",
+  "version": "4.33.1",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -31,36 +31,15 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./fs": {
-      "import": "./dist/fs.js",
-      "require": "./dist/fs.cjs"
-    },
     "./hooks": {
       "import": "./dist/hooks.js",
       "require": "./dist/hooks.cjs"
     },
-    "./transformers": {
-      "import": "./dist/transformers.js",
-      "require": "./dist/transformers.cjs"
-    },
-    "./utils": {
-      "import": "./dist/utils.js",
-      "require": "./dist/utils.cjs"
-    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
-      "utils": [
-        "./dist/utils.d.ts"
-      ],
-      "transformers": [
-        "./dist/transformers.d.ts"
-      ],
-      "fs": [
-        "./dist/fs.d.ts"
-      ],
       "hooks": [
         "./dist/hooks.d.ts"
       ]
@@ -87,14 +66,14 @@
   "dependencies": {
     "@kubb/react-fabric": "0.13.3",
     "empathic": "^2.0.0",
-    "jiti": "2.5.1",
     "remeda": "^2.33.6",
     "semver": "^7.7.4",
     "tinyexec": "^1.0.2"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
-    "p-limit": "^7.3.0"
+    "p-limit": "^7.3.0",
+    "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.13.3"

package/src/BarrelManager.ts

@@ -1,24 +1,18 @@
 /** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
+import { getRelativePath } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import { getRelativePath } from './fs/index.ts'
 
 import type { FileMetaBase } from './utils/getBarrelFiles.ts'
 import { TreeNode } from './utils/TreeNode.ts'
 
-type BarrelManagerOptions = {}
-
 export class BarrelManager {
-  constructor(_options: BarrelManagerOptions = {}) {
-    return this
-  }
-
   getFiles({ files: generatedFiles, root }: { files: KubbFile.File[]; root?: string; meta?: FileMetaBase | undefined }): Array<KubbFile.File> {
     const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
 
     TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
       if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
-        return undefined
+        return
       }
 
       const barrelFile: KubbFile.File = {
@@ -33,43 +27,28 @@ export class BarrelManager {
 
       leaves.forEach((item) => {
         if (!item.data.name) {
-          return undefined
+          return
         }
 
         const sources = item.data.file?.sources || []
 
         sources.forEach((source) => {
           if (!item.data.file?.path || !source.isIndexable || !source.name) {
-            return undefined
+            return
           }
           const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
             (item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly,
           )
 
           if (alreadyContainInPreviousBarrelFile) {
-            return undefined
-          }
-
-          if (!barrelFile.exports) {
-            barrelFile.exports = []
+            return
           }
 
-          // true when we have a subdirectory that also contains barrel files
-          const isSubExport = !!treeNode.parent?.data.path?.split?.('/')?.length
-
-          if (isSubExport) {
-            barrelFile.exports.push({
-              name: [source.name],
-              path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-              isTypeOnly: source.isTypeOnly,
-            })
-          } else {
-            barrelFile.exports.push({
-              name: [source.name],
-              path: `./${item.data.file.baseName}`,
-              isTypeOnly: source.isTypeOnly,
-            })
-          }
+          barrelFile.exports!.push({
+            name: [source.name],
+            path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+            isTypeOnly: source.isTypeOnly,
+          })
 
           barrelFile.sources.push({
             name: source.name,

package/src/PackageManager.ts

@@ -1,11 +1,10 @@
 import mod from 'node:module'
 import os from 'node:os'
 import { pathToFileURL } from 'node:url'
-
+import { read, readSync } from '@internals/utils'
 import * as pkg from 'empathic/package'
 import { coerce, satisfies } from 'semver'
-
-import { read, readSync } from './fs/index.ts'
+import { PATH_SEPARATORS } from './constants.ts'
 
 type PackageJSON = {
   dependencies?: Record<string, string>
@@ -20,13 +19,11 @@ export class PackageManager {
   static #cache: Record<DependencyName, DependencyVersion> = {}
 
   #cwd?: string
-  #SLASHES = new Set(['/', '\\'])
+
   constructor(workspace?: string) {
     if (workspace) {
       this.#cwd = workspace
     }
-
-    return this
   }
 
   set workspace(workspace: string) {
@@ -39,7 +36,7 @@ export class PackageManager {
 
   normalizeDirectory(directory: string): string {
     const lastChar = directory[directory.length - 1]
-    if (lastChar && !this.#SLASHES.has(lastChar)) {
+    if (lastChar && !(PATH_SEPARATORS as readonly string[]).includes(lastChar)) {
       return `${directory}/`
     }
 
@@ -57,21 +54,16 @@ export class PackageManager {
     return location
   }
 
-  async import(path: string): Promise<any | undefined> {
-    try {
-      let location = this.getLocation(path)
+  async import(path: string): Promise<unknown> {
+    let location = this.getLocation(path)
 
-      if (os.platform() === 'win32') {
-        location = pathToFileURL(location).href
-      }
+    if (os.platform() === 'win32') {
+      location = pathToFileURL(location).href
+    }
 
-      const module = await import(location)
+    const module = await import(location)
 
-      return module?.default ?? module
-    } catch (error) {
-      console.error(error)
-      return undefined
-    }
+    return module?.default ?? module
   }
 
   async getPackageJSON(): Promise<PackageJSON | undefined> {
@@ -106,8 +98,8 @@ 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]) {

package/src/PluginManager.ts

@@ -1,14 +1,14 @@
 import path from 'node:path'
 import { performance } from 'node:perf_hooks'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { setUniqueName, transformReservedWord } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Fabric } from '@kubb/react-fabric'
+import { CORE_PLUGIN_NAME } from './constants.ts'
 import { ValidationPluginError } from './errors.ts'
 import { isPromiseRejectedResult, PromiseManager } from './PromiseManager.ts'
-import { transformReservedWord } from './transformers/transformReservedWord.ts'
-import { trim } from './transformers/trim.ts'
 import type {
   Config,
-  GetPluginFactoryOptions,
   KubbEvents,
   Plugin,
   PluginContext,
@@ -21,8 +21,6 @@ import type {
   ResolvePathParams,
   UserPlugin,
 } from './types.ts'
-import type { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
-import { setUniqueName } from './utils/uniqueName.ts'
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>
 
@@ -65,9 +63,9 @@ export class PluginManager {
   readonly config: Config
   readonly options: Options
 
-  readonly #plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
+  readonly #plugins = new Set<Plugin>()
   readonly #usedPluginNames: Record<string, number> = {}
-  readonly #promiseManager: PromiseManager
+  readonly #promiseManager
 
   constructor(config: Config, options: Options) {
     this.config = config
@@ -80,15 +78,13 @@ export class PluginManager {
 
       this.#plugins.add(parsedPlugin)
     })
-
-    return this
   }
 
   get events() {
     return this.options.events
   }
 
-  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, any> {
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown> {
     const plugins = [...this.#plugins]
     const baseContext = {
       fabric: this.options.fabric,
@@ -105,13 +101,14 @@ export class PluginManager {
       },
     } as unknown as PluginContext<TOptions>
 
-    const mergedExtras: Record<string, any> = {}
+    const mergedExtras: Record<string, unknown> = {}
     for (const p of plugins) {
       if (typeof p.inject === 'function') {
-        const injector = p.inject.bind(baseContext as any) as any
-
-        const result = injector(baseContext)
-        if (result && typeof result === 'object') {
+        const result = (p.inject as (this: PluginContext, context: PluginContext) => unknown).call(
+          baseContext as unknown as PluginContext,
+          baseContext as unknown as PluginContext,
+        )
+        if (result !== null && typeof result === 'object') {
           Object.assign(mergedExtras, result)
         }
       }
@@ -174,7 +171,7 @@ export class PluginManager {
       const names = this.hookForPluginSync({
         pluginKey: params.pluginKey,
         hookName: 'resolveName',
-        parameters: [trim(params.name), params.type],
+        parameters: [params.name.trim(), params.type],
       })
 
       const uniqueNames = new Set(names)
@@ -184,10 +181,10 @@ export class PluginManager {
 
     const name = this.hookFirstSync({
       hookName: 'resolveName',
-      parameters: [trim(params.name), params.type],
-    }).result
+      parameters: [params.name.trim(), params.type],
+    })?.result
 
-    return transformReservedWord(name)
+    return transformReservedWord(name ?? params.name)
   }
 
   /**
@@ -252,7 +249,7 @@ export class PluginManager {
           plugin,
         })
       })
-      .filter(Boolean)
+      .filter((x): x is NonNullable<typeof x> => x !== null)
 
     return result
   }
@@ -270,7 +267,7 @@ export class PluginManager {
     skipped?: ReadonlySet<Plugin> | null
   }): Promise<SafeParseResult<H>> {
     const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-      return skipped ? skipped.has(plugin) : true
+      return skipped ? !skipped.has(plugin) : true
     })
 
     this.events.emit('plugins:hook:progress:start', { hookName, plugins })
@@ -309,10 +306,10 @@ export class PluginManager {
     hookName: H
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
-  }): SafeParseResult<H> {
-    let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
+  }): SafeParseResult<H> | null {
+    let parseResult: SafeParseResult<H> | null = null
     const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-      return skipped ? skipped.has(plugin) : true
+      return skipped ? !skipped.has(plugin) : true
     })
 
     for (const plugin of plugins) {
@@ -347,14 +344,18 @@ export class PluginManager {
     const plugins = this.#getSortedPlugins(hookName)
     this.events.emit('plugins:hook:progress:start', { hookName, plugins })
 
+    const pluginStartTimes = new Map<Plugin, number>()
+
     const promises = plugins.map((plugin) => {
-      return () =>
-        this.#execute({
+      return () => {
+        pluginStartTimes.set(plugin, performance.now())
+        return this.#execute({
           strategy: 'hookParallel',
           hookName,
           parameters,
           plugin,
         }) as Promise<TOutput>
+      }
     })
 
     const results = await this.#promiseManager.run('parallel', promises, {
@@ -366,11 +367,12 @@ export class PluginManager {
         const plugin = this.#getSortedPlugins(hookName)[index]
 
         if (plugin) {
+          const startTime = pluginStartTimes.get(plugin) ?? performance.now()
           this.events.emit('error', result.reason, {
             plugin,
             hookName,
             strategy: 'hookParallel',
-            duration: 0,
+            duration: Math.round(performance.now() - startTime),
             parameters,
           })
         }
@@ -473,7 +475,7 @@ export class PluginManager {
     if (!pluginByPluginName?.length) {
       // fallback on the core plugin when there is no match
 
-      const corePlugin = plugins.find((plugin) => plugin.name === 'core' && hookName in plugin)
+      const corePlugin = plugins.find((plugin) => plugin.name === CORE_PLUGIN_NAME && hookName in plugin)
       // Removed noisy debug logs for missing hooks - these are expected behavior, not errors
 
       return corePlugin ? [corePlugin] : []
@@ -488,6 +490,31 @@ export class PluginManager {
    * @param args Arguments passed to the plugin hook.
    * @param plugin The actual pluginObject to run.
    */
+  #emitProcessingEnd<H extends PluginLifecycleHooks>({
+    startTime,
+    output,
+    strategy,
+    hookName,
+    plugin,
+    parameters,
+  }: {
+    startTime: number
+    output: unknown
+    strategy: Strategy
+    hookName: H
+    plugin: PluginWithLifeCycle
+    parameters: unknown[] | undefined
+  }): void {
+    this.events.emit('plugins:hook:processing:end', {
+      duration: Math.round(performance.now() - startTime),
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin,
+    })
+  }
+
   // Implementation signature
   #execute<H extends PluginLifecycleHooks>({
     strategy,
@@ -501,7 +528,6 @@ export class PluginManager {
     plugin: PluginWithLifeCycle
   }): Promise<ReturnType<ParseResult<H>> | null> | null {
     const hook = plugin[hookName]
-    let output: unknown
 
     if (!hook) {
       return null
@@ -518,36 +544,12 @@ export class PluginManager {
 
     const task = (async () => {
       try {
-        if (typeof hook === 'function') {
-          const context = this.getContext(plugin)
-          const result = await Promise.resolve((hook as Function).apply(context, parameters))
-
-          output = result
-
-          this.events.emit('plugins:hook:processing:end', {
-            duration: Math.round(performance.now() - startTime),
-            parameters,
-            output,
-            strategy,
-            hookName,
-            plugin,
-          })
-
-          return result
-        }
+        const output =
+          typeof hook === 'function' ? await Promise.resolve((hook as (...args: unknown[]) => unknown).apply(this.getContext(plugin), parameters ?? [])) : hook
 
-        output = hook
-
-        this.events.emit('plugins:hook:processing:end', {
-          duration: Math.round(performance.now() - startTime),
-          parameters,
-          output,
-          strategy,
-          hookName,
-          plugin,
-        })
+        this.#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters })
 
-        return hook
+        return output as ReturnType<ParseResult<H>>
       } catch (error) {
         this.events.emit('error', error as Error, {
           plugin,
@@ -568,7 +570,6 @@ export class PluginManager {
    * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
    * @param args Arguments passed to the plugin hook.
    * @param plugin The actual plugin
-   * @param replaceContext When passed, the plugin context can be overridden.
    */
   #executeSync<H extends PluginLifecycleHooks>({
     strategy,
@@ -582,7 +583,6 @@ export class PluginManager {
     plugin: PluginWithLifeCycle
   }): ReturnType<ParseResult<H>> | null {
     const hook = plugin[hookName]
-    let output: unknown
 
     if (!hook) {
       return null
@@ -598,36 +598,14 @@ export class PluginManager {
     const startTime = performance.now()
 
     try {
-      if (typeof hook === 'function') {
-        const context = this.getContext(plugin)
-        const fn = (hook as Function).apply(context, parameters) as ReturnType<ParseResult<H>>
-
-        output = fn
-
-        this.events.emit('plugins:hook:processing:end', {
-          duration: Math.round(performance.now() - startTime),
-          parameters,
-          output,
-          strategy,
-          hookName,
-          plugin,
-        })
-
-        return fn
-      }
+      const output =
+        typeof hook === 'function'
+          ? ((hook as (...args: unknown[]) => unknown).apply(this.getContext(plugin), parameters) as ReturnType<ParseResult<H>>)
+          : (hook as ReturnType<ParseResult<H>>)
 
-      output = hook
-
-      this.events.emit('plugins:hook:processing:end', {
-        duration: Math.round(performance.now() - startTime),
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin,
-      })
+      this.#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters })
 
-      return hook
+      return output
     } catch (error) {
       this.events.emit('error', error as Error, {
         plugin,

package/src/PromiseManager.ts

@@ -3,17 +3,15 @@ import { hookFirst, hookParallel, hookSeq } from './utils/executeStrategies.ts'
 
 type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2
 
-type Options<TState = any> = {
+type Options<TState = unknown> = {
   nullCheck?: (state: TState) => boolean
 }
 
-export class PromiseManager<TState = any> {
+export class PromiseManager<TState = unknown> {
   #options: Options<TState> = {}
 
   constructor(options: Options<TState> = {}) {
     this.#options = options
-
-    return this
   }
 
   run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(
@@ -26,7 +24,7 @@ export class PromiseManager<TState = any> {
     }
 
     if (strategy === 'first') {
-      return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck)
+      return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck as ((state: unknown) => boolean) | undefined)
     }
 
     if (strategy === 'parallel') {