@kubb/core 5.0.0-alpha.42 → 5.0.0-alpha.44

package/src/constants.ts

@@ -15,10 +15,18 @@ export const DEFAULT_CONCURRENCY = 15
  */
 export const PARALLEL_CONCURRENCY_LIMIT = 100
 
+/**
+ * Basename (without extension) of generated barrel files.
+ *
+ * Used to detect whether a path already points at a barrel so the generator
+ * avoids re-creating one on top of it.
+ */
+export const BARREL_BASENAME = 'index' as const
+
 /**
  * File name used for generated barrel (index) files.
  */
-export const BARREL_FILENAME = 'index.ts' as const
+export const BARREL_FILENAME = `${BARREL_BASENAME}.ts` as const
 
 /**
  * Default banner style written at the top of every generated file.
@@ -48,5 +56,3 @@ export const logLevel = {
   verbose: 4,
   debug: 5,
 } as const
-
-

package/src/createKubb.ts

@@ -2,16 +2,17 @@ import { dirname, resolve } from 'node:path'
 import { AsyncEventEmitter, BuildError, exists, formatMs, getElapsedMs, getRelativePath, URLPath } from '@internals/utils'
 import type { ExportNode, FileNode, OperationNode } from '@kubb/ast'
 import { createExport, createFile, transform, walk } from '@kubb/ast'
-import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
+import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
 import type { RendererFactory } from './createRenderer.ts'
 import type { Generator } from './defineGenerator.ts'
 import type { Parser } from './defineParser.ts'
+import type { Plugin } from './definePlugin.ts'
 import { FileProcessor } from './FileProcessor.ts'
 import type { Kubb } from './Kubb.ts'
 import { PluginDriver } from './PluginDriver.ts'
 import { applyHookResult } from './renderNode.ts'
 import { fsStorage } from './storages/fsStorage.ts'
-import type { AdapterSource, Config, GeneratorContext, KubbHooks, Plugin, PluginContext, Storage, UserConfig } from './types.ts'
+import type { AdapterSource, Config, GeneratorContext, KubbHooks, NormalizedPlugin, Storage, UserConfig } from './types.ts'
 import { getDiagnosticInfo } from './utils/diagnostics.ts'
 import type { FileMetaBase } from './utils/getBarrelFiles.ts'
 import { getBarrelFiles } from './utils/getBarrelFiles.ts'
@@ -138,7 +139,6 @@ async function setup(userConfig: UserConfig, options: SetupOptions = {}): Promis
 
   const driver = new PluginDriver(config, {
     hooks,
-    concurrency: DEFAULT_CONCURRENCY,
   })
 
   const adapter = config.adapter
@@ -177,7 +177,7 @@ async function setup(userConfig: UserConfig, options: SetupOptions = {}): Promis
  * Walks the AST and dispatches nodes to a plugin's direct AST hooks
  * (`schema`, `operation`, `operations`).
  */
-async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promise<void> {
+async function runPluginAstHooks(plugin: NormalizedPlugin, context: GeneratorContext): Promise<void> {
   const { adapter, inputNode, resolver, driver } = context
   const { exclude, include, override } = plugin.options
 
@@ -192,9 +192,8 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
   const generators = plugin.generators ?? []
   const collectedOperations: Array<OperationNode> = []
 
-  const baseGeneratorContext = context as GeneratorContext
   const generatorContext = {
-    ...baseGeneratorContext,
+    ...context,
     resolver: driver.getResolver(plugin.name),
   }
 
@@ -282,8 +281,6 @@ async function safeBuild(setupResult: SetupResult): Promise<BuildOutput> {
           logs: ['Starting plugin...', `  • Plugin Name: ${plugin.name}`],
         })
 
-        await plugin.buildStart.call(context)
-
         if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) {
           await runPluginAstHooks(plugin, context)
         }
@@ -421,13 +418,6 @@ async function safeBuild(setupResult: SetupResult): Promise<BuildOutput> {
       },
     })
 
-    for (const plugin of driver.plugins.values()) {
-      if (plugin.buildEnd) {
-        const context = driver.getContext(plugin)
-        await plugin.buildEnd.call(context)
-      }
-    }
-
     await hooks.emit('kubb:build:end', {
       files,
       config,
@@ -487,7 +477,7 @@ type BuildBarrelExportsParams = {
 }
 
 function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }: BuildBarrelExportsParams): ExportNode[] {
-  const pluginNameMap = new Map<string, Plugin>()
+  const pluginNameMap = new Map<string, NormalizedPlugin>()
   for (const plugin of driver.plugins.values()) {
     pluginNameMap.set(plugin.name, plugin)
   }

package/src/definePlugin.ts

@@ -2,39 +2,13 @@ import type { KubbHooks } from './Kubb.ts'
 import type { KubbPluginSetupContext, PluginFactoryOptions } from './types.ts'
 
 /**
- * Base hook handlers for all events except `kubb:plugin:setup`.
- * These handlers have identical signatures regardless of the plugin's
- * `PluginFactoryOptions` generic — they are split out so that the
- * interface below only needs to override the one event that depends on
- * the plugin type.
- */
-type PluginHooksBase = {
-  [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void>
-}
-
-/**
- * Plugin hook handlers.
- *
- * `kubb:plugin:setup` is typed with the plugin's own `PluginFactoryOptions` so
- * `ctx.setResolver`, `ctx.setOptions`, `ctx.options` etc. use the correct types.
- *
- * Uses interface + method shorthand for `kubb:plugin:setup`
- * checking, allowing `PluginHooks<PluginTs>` to be assignable to `PluginHooks`.
- *
- * @template TFactory - The plugin's `PluginFactoryOptions` type.
- */
-export interface PluginHooks<TFactory extends PluginFactoryOptions = PluginFactoryOptions> extends PluginHooksBase {
-  'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>
-}
-
-/**
- * A hook-style plugin object produced by `definePlugin`.
+ * A plugin object produced by `definePlugin`.
  * Instead of flat lifecycle methods, it groups all handlers under a `hooks:` property
  * (matching Astro's integration naming convention).
  *
  * @template TFactory - The plugin's `PluginFactoryOptions` type.
  */
-export type HookStylePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
+export type Plugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name for the plugin, following the same naming convention as `createPlugin`.
    */
@@ -52,7 +26,11 @@ export type HookStylePlugin<TFactory extends PluginFactoryOptions = PluginFactor
    * Lifecycle event handlers for this plugin.
    * Any event from the global `KubbHooks` map can be subscribed to here.
    */
-  hooks: PluginHooks<TFactory>
+  hooks: {
+    [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void>
+  } & {
+    'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>
+  }
 }
 
 /**
@@ -61,14 +39,14 @@ export type HookStylePlugin<TFactory extends PluginFactoryOptions = PluginFactor
  * Used by `PluginDriver` to distinguish hook-style plugins from legacy `createPlugin` plugins
  * so it can normalize them and register their handlers on the `AsyncEventEmitter`.
  */
-export function isHookStylePlugin(plugin: unknown): plugin is HookStylePlugin {
+export function isPlugin(plugin: unknown): plugin is Plugin {
   return typeof plugin === 'object' && plugin !== null && 'hooks' in plugin
 }
 
 /**
- * Creates a plugin factory using the new hook-style (`hooks:`) API.
+ * Creates a plugin factory using the hook-style (`hooks:`) API.
  *
- * The returned factory is called with optional options and produces a `HookStylePlugin`
+ * The returned factory is called with optional options and produces a `Plugin`
  * that coexists with plugins created via the legacy `createPlugin` API in the same
  * `kubb.config.ts`.
  *
@@ -89,7 +67,7 @@ export function isHookStylePlugin(plugin: unknown): plugin is HookStylePlugin {
  * ```
  */
 export function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(
-  factory: (options: TFactory['options']) => HookStylePlugin<TFactory>,
-): (options?: TFactory['options']) => HookStylePlugin<TFactory> {
+  factory: (options: TFactory['options']) => Plugin<TFactory>,
+): (options?: TFactory['options']) => Plugin<TFactory> {
   return (options) => factory(options ?? ({} as TFactory['options']))
 }

package/src/defineResolver.ts

@@ -7,7 +7,6 @@ import type {
   Config,
   PluginFactoryOptions,
   ResolveBannerContext,
-  ResolveNameParams,
   ResolveOptionsContext,
   Resolver,
   ResolverContext,
@@ -30,21 +29,37 @@ type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<
     pluginName: T['name']
   } & ThisType<T['resolver']>
 
+// String patterns are compiled lazily and cached — the same filter is reused for every node.
+const stringPatternCache = new Map<string, RegExp>()
+
+function testPattern(value: string, pattern: string | RegExp): boolean {
+  if (typeof pattern === 'string') {
+    let regex = stringPatternCache.get(pattern)
+    if (!regex) {
+      regex = new RegExp(pattern)
+      stringPatternCache.set(pattern, regex)
+    }
+    return regex.test(value)
+  }
+  // Use .match() for user-supplied RegExp to preserve semantics regardless of `g`/`y` flags.
+  return value.match(pattern) !== null
+}
+
 /**
  * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
  */
 function matchesOperationPattern(node: OperationNode, type: string, pattern: string | RegExp): boolean {
   switch (type) {
     case 'tag':
-      return node.tags.some((tag) => !!tag.match(pattern))
+      return node.tags.some((tag) => testPattern(tag, pattern))
     case 'operationId':
-      return !!node.operationId.match(pattern)
+      return testPattern(node.operationId, pattern)
     case 'path':
-      return !!node.path.match(pattern)
+      return testPattern(node.path, pattern)
     case 'method':
-      return !!(node.method.toLowerCase() as string).match(pattern)
+      return testPattern(node.method.toLowerCase(), pattern)
     case 'contentType':
-      return !!node.requestBody?.contentType?.match(pattern)
+      return node.requestBody?.contentType ? testPattern(node.requestBody.contentType, pattern) : false
     default:
       return false
   }
@@ -58,7 +73,7 @@ function matchesOperationPattern(node: OperationNode, type: string, pattern: str
 function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string | RegExp): boolean | null {
   switch (type) {
     case 'schemaName':
-      return node.name ? !!node.name.match(pattern) : false
+      return node.name ? testPattern(node.name, pattern) : false
     default:
       return null
   }
@@ -71,7 +86,7 @@ function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string |
  * - `PascalCase` for `type`.
  * - `camelCase` for everything else.
  */
-function defaultResolver(name: ResolveNameParams['name'], type: ResolveNameParams['type']): string {
+function defaultResolver(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {
   let resolvedName = camelCase(name)
 
   if (type === 'file' || type === 'function') {

package/src/mocks.ts

@@ -4,95 +4,20 @@ import { transform } from '@kubb/ast'
 import { FileManager } from './FileManager.ts'
 import { PluginDriver } from './PluginDriver.ts'
 import { applyHookResult } from './renderNode.ts'
-import type {
-  Adapter,
-  AdapterFactoryOptions,
-  Config,
-  Generator,
-  GeneratorContext,
-  Plugin,
-  PluginFactoryOptions,
-  ResolveNameParams,
-  ResolvePathParams,
-} from './types.ts'
-
-function toCamelOrPascal(text: string, pascal: boolean): string {
-  const normalized = text
-    .trim()
-    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-    .replace(/(\d)([a-z])/g, '$1 $2')
-
-  const words = normalized.split(/[\s\-_./\\:]+/).filter(Boolean)
-
-  return words
-    .map((word, i) => {
-      const allUpper = word.length > 1 && word === word.toUpperCase()
-      if (allUpper) return word
-      if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1)
-      return word.charAt(0).toUpperCase() + word.slice(1)
-    })
-    .join('')
-    .replace(/[^a-zA-Z0-9]/g, '')
-}
-
-function camelCase(text: string): string {
-  return toCamelOrPascal(text, false)
-}
-
-function pascalCase(text: string): string {
-  return toCamelOrPascal(text, true)
-}
+import type { Adapter, AdapterFactoryOptions, Config, Generator, GeneratorContext, NormalizedPlugin, PluginFactoryOptions } from './types.ts'
 
 /**
  * Creates a minimal `PluginDriver` mock suitable for unit tests.
  */
-export function createMockedPluginDriver(options: { name?: string; plugin?: Plugin; config?: Config } = {}): PluginDriver {
+export function createMockedPluginDriver(options: { name?: string; plugin?: NormalizedPlugin; config?: Config } = {}): PluginDriver {
   return {
-    resolveName: (result: ResolveNameParams) => {
-      if (result.type === 'file') {
-        return camelCase(options?.name || result.name)
-      }
-
-      if (result.type === 'type') {
-        return pascalCase(result.name)
-      }
-
-      if (result.type === 'function') {
-        return camelCase(result.name)
-      }
-
-      return camelCase(result.name)
-    },
     config: options?.config ?? {
       root: '.',
       output: {
         path: './path',
       },
     },
-    resolvePath: ({ baseName }: ResolvePathParams) => baseName,
-    getFile: ({
-      name,
-      extname,
-      pluginName,
-      options: fileOptions,
-    }: {
-      name: string
-      extname: `.${string}`
-      pluginName: string
-      options?: { group?: { tag?: string; path?: string } }
-    }) => {
-      const baseName = `${name}${extname}`
-      const groupDir = fileOptions?.group?.tag ?? fileOptions?.group?.path?.split('/').filter(Boolean)[0]
-      const filePath = groupDir ? `${groupDir}/${baseName}` : baseName
-
-      return {
-        path: filePath,
-        baseName,
-        meta: { pluginName },
-      }
-    },
-    getPlugin(_pluginName: Plugin['name']): Plugin | undefined {
+    getPlugin(_pluginName: string): NormalizedPlugin | undefined {
       return options?.plugin
     },
     fileManager: new FileManager(),
@@ -124,7 +49,7 @@ export function createMockedAdapter<TOptions extends AdapterFactoryOptions = Ada
 }
 
 /**
- * Creates a minimal `Plugin` mock suitable for unit tests.
+ * Creates a minimal plugin mock suitable for unit tests.
  *
  * @example
  * const plugin = createMockedPlugin<PluginTs>({ name: '@kubb/plugin-ts', options })
@@ -135,23 +60,22 @@ export function createMockedPlugin<TOptions extends PluginFactoryOptions = Plugi
   resolver?: TOptions['resolver']
   transformer?: Visitor
   dependencies?: Array<string>
-}): Plugin<TOptions> {
+}): NormalizedPlugin<TOptions> {
   return {
     name: params.name,
     options: params.options,
     resolver: params.resolver,
     transformer: params.transformer,
     dependencies: params.dependencies,
-    install: () => {},
-    inject: () => undefined as TOptions['context'],
-  } as unknown as Plugin<TOptions>
+    hooks: {},
+  } as unknown as NormalizedPlugin<TOptions>
 }
 
 type RenderGeneratorOptions<TOptions extends PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
   driver: PluginDriver
-  plugin: Plugin<TOptions>
+  plugin: NormalizedPlugin<TOptions>
   options: TOptions['resolvedOptions']
   resolver: TOptions['resolver']
 }
@@ -168,7 +92,9 @@ function createMockedPluginContext<TOptions extends PluginFactoryOptions>(opts:
     plugin: opts.plugin,
     driver: opts.driver,
     inputNode: { kind: 'Input', schemas: [], operations: [] },
+    addFile: async (...files: Array<FileNode>) => opts.driver.fileManager.add(...files),
     upsertFile: async (...files: Array<FileNode>) => opts.driver.fileManager.upsert(...files),
+    hooks: opts.driver.hooks ?? ({} as never),
     warn: (msg: string) => console.warn(msg),
     error: (msg: string) => console.error(msg),
     info: (msg: string) => console.info(msg),