@kubb/core 5.0.0-alpha.35 → 5.0.0-alpha.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.35",
+  "version": "5.0.0-alpha.38",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -31,17 +31,17 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./hooks": {
-      "import": "./dist/hooks.js",
-      "require": "./dist/hooks.cjs"
+    "./mocks": {
+      "import": "./dist/mocks.js",
+      "require": "./dist/mocks.cjs"
     },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
-      "hooks": [
-        "./dist/hooks.d.ts"
+      "mocks": [
+        "./dist/mocks.d.ts"
       ]
     }
   },
@@ -68,8 +68,8 @@
     "remeda": "^2.33.7",
     "semver": "^7.7.4",
     "tinyexec": "^1.1.1",
-    "@kubb/ast": "5.0.0-alpha.35",
-    "@kubb/renderer-jsx": "5.0.0-alpha.35"
+    "@kubb/ast": "5.0.0-alpha.38",
+    "@kubb/renderer-jsx": "5.0.0-alpha.38"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
@@ -77,7 +77,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-alpha.35"
+    "@kubb/renderer-jsx": "5.0.0-alpha.38"
   },
   "engines": {
     "node": ">=22"

package/src/PluginDriver.ts

@@ -73,21 +73,6 @@ export type GetFileOptions<TOptions = object> = {
   options?: TOptions
 }
 
-/**
- * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
- *
- * @example
- * ```ts
- * getMode('src/gen/types.ts')  // 'single'
- * getMode('src/gen/types')     // 'split'
- * ```
- */
-export function getMode(fileOrFolder: string | undefined | null): 'single' | 'split' {
-  if (!fileOrFolder) {
-    return 'split'
-  }
-  return extname(fileOrFolder) ? 'single' : 'split'
-}
 
 const hookFirstNullCheck = (state: unknown) => !!(state as SafeParseResult<'resolveName'> | null)?.result
 
@@ -95,6 +80,22 @@ export class PluginDriver {
   readonly config: Config
   readonly options: Options
 
+  /**
+   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+   *
+   * @example
+   * ```ts
+   * PluginDriver.getMode('src/gen/types.ts')  // 'single'
+   * PluginDriver.getMode('src/gen/types')     // 'split'
+   * ```
+   */
+  static getMode(fileOrFolder: string | undefined | null): 'single' | 'split' {
+    if (!fileOrFolder) {
+      return 'split'
+    }
+    return extname(fileOrFolder) ? 'single' : 'split'
+}
+
   /**
    * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
    * the build pipeline after the adapter's `parse()` resolves.
@@ -301,7 +302,7 @@ export class PluginDriver {
    *
    * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
    */
-  registerGenerator(pluginName: string, gen: Generator<any>): void {
+  registerGenerator(pluginName: string, gen: Generator): void {
     const resolveRenderer = () => {
       const plugin = this.plugins.get(pluginName)
       return gen.renderer === null ? undefined : (gen.renderer ?? plugin?.renderer ?? this.config.renderer)
@@ -422,7 +423,7 @@ export class PluginDriver {
         return resolve(driver.config.root, driver.config.output.path)
       },
       getMode(output: { path: string }): 'single' | 'split' {
-        return getMode(resolve(driver.config.root, driver.config.output.path, output.path))
+        return PluginDriver.getMode(resolve(driver.config.root, driver.config.output.path, output.path))
       },
       hooks: driver.hooks,
       plugin,

package/src/constants.ts

@@ -49,52 +49,4 @@ export const logLevel = {
   debug: 5,
 } as const
 
-/**
- * CLI command descriptors for each supported linter.
- *
- * Each entry contains the executable `command`, an `args` factory that maps an
- * output path to the correct argument list, and an `errorMessage` shown when
- * the linter is not found.
- */
-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
 
-/**
- * CLI command descriptors for each supported code formatter.
- *
- * Each entry contains the executable `command`, an `args` factory that maps an
- * output path to the correct argument list, and an `errorMessage` shown when
- * the formatter is not found.
- */
-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/createKubb.ts

@@ -187,7 +187,7 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
     throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`)
   }
 
-  function resolveRenderer(gen: Generator<any>): RendererFactory | undefined {
+  function resolveRenderer(gen: Generator): RendererFactory | undefined {
     return gen.renderer === null ? undefined : (gen.renderer ?? plugin.renderer ?? context.config.renderer)
   }
 

package/src/defineResolver.ts

@@ -2,7 +2,7 @@ import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
 import type { FileNode, InputNode, Node, OperationNode, SchemaNode } from '@kubb/ast'
 import { createFile, isOperationNode, isSchemaNode } from '@kubb/ast'
-import { getMode } from './PluginDriver.ts'
+import { PluginDriver } from './PluginDriver.ts'
 import type {
   Config,
   PluginFactoryOptions,
@@ -195,7 +195,7 @@ export function defaultResolveOptions<TOptions>(
  * ```
  */
 export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): string {
-  const mode = pathMode ?? getMode(path.resolve(root, output.path))
+  const mode = pathMode ?? PluginDriver.getMode(path.resolve(root, output.path))
 
   if (mode === 'single') {
     return path.resolve(root, output.path)
@@ -236,7 +236,7 @@ export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }:
  * ```
  */
 export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): FileNode {
-  const pathMode = getMode(path.resolve(context.root, context.output.path))
+  const pathMode = PluginDriver.getMode(path.resolve(context.root, context.output.path))
   const resolvedName = pathMode === 'single' ? '' : this.default(name, 'file')
   const baseName = `${resolvedName}${extname}` as FileNode['baseName']
   const filePath = this.resolvePath({ baseName, pathMode, tag, path: groupPath }, context)

package/src/index.ts

@@ -1,34 +1,19 @@
 export { AsyncEventEmitter, URLPath } from '@internals/utils'
 export * as ast from '@kubb/ast'
-export { composeTransformers, definePrinter } from '@kubb/ast'
-export { formatters, linters, logLevel } from './constants.ts'
+export { logLevel } from './constants.ts'
 export { createAdapter } from './createAdapter.ts'
 export { createKubb } from './createKubb.ts'
-export { createPlugin } from './createPlugin.ts'
 export { createRenderer } from './createRenderer.ts'
 export { createStorage } from './createStorage.ts'
 export { defineGenerator } from './defineGenerator.ts'
 export { defineLogger } from './defineLogger.ts'
 export { defineParser } from './defineParser.ts'
 export { definePlugin } from './definePlugin.ts'
-export {
-  buildDefaultBanner,
-  defaultResolveBanner,
-  defaultResolveFile,
-  defaultResolveFooter,
-  defaultResolveOptions,
-  defaultResolvePath,
-  defineResolver,
-} from './defineResolver.ts'
-export { getMode, PluginDriver } from './PluginDriver.ts'
+export { defineResolver } from './defineResolver.ts'
+export { FileManager } from './FileManager.ts'
+export { FileProcessor } from './FileProcessor.ts'
+export { PluginDriver } from './PluginDriver.ts'
 export { fsStorage } from './storages/fsStorage.ts'
 export { memoryStorage } from './storages/memoryStorage.ts'
 export * from './types.ts'
-export type { FunctionParamsAST } from './utils/FunctionParams.ts'
-export { detectFormatter } from './utils/formatters.ts'
-export { getBarrelFiles } from './utils/getBarrelFiles.ts'
-export type { Param, Params } from './utils/getFunctionParams.ts'
-export { createFunctionParams, FunctionParams, getFunctionParams } from './utils/getFunctionParams.ts'
 export { isInputPath } from './utils/isInputPath.ts'
-export { detectLinter } from './utils/linters.ts'
-export { satisfiesDependency } from './utils/packageJSON.ts'

package/src/mocks.ts

@@ -0,0 +1,234 @@
+import { resolve } from 'node:path'
+import type { FileNode, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
+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)
+}
+
+/**
+ * Creates a minimal `PluginDriver` mock suitable for unit tests.
+ */
+export function createMockedPluginDriver(options: { name?: string; plugin?: Plugin; 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 {
+      return options?.plugin
+    },
+    fileManager: new FileManager(),
+  } as unknown as PluginDriver
+}
+
+/**
+ * Creates a minimal `Adapter` mock suitable for unit tests.
+ *
+ * - `parse` returns an empty `InputNode` by default; override via `options.parse`.
+ * - `getImports` returns `[]` by default (single-file mode, no cross-file imports).
+ */
+export function createMockedAdapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions>(
+  options: {
+    name?: TOptions['name']
+    resolvedOptions?: TOptions['resolvedOptions']
+    inputNode?: Adapter<TOptions>['inputNode']
+    parse?: Adapter<TOptions>['parse']
+    getImports?: Adapter<TOptions>['getImports']
+  } = {},
+): Adapter<TOptions> {
+  return {
+    name: (options.name ?? 'oas') as TOptions['name'],
+    options: (options.resolvedOptions ?? {}) as TOptions['resolvedOptions'],
+    inputNode: options.inputNode ?? null,
+    parse: options.parse ?? (async () => ({ kind: 'Input' as const, schemas: [], operations: [] })),
+    getImports: options.getImports ?? ((_node: SchemaNode, _resolve: (schemaName: string) => { name: string; path: string }) => []),
+  } as Adapter<TOptions>
+}
+
+/**
+ * Creates a minimal `Plugin` mock suitable for unit tests.
+ *
+ * @example
+ * const plugin = createMockedPlugin<PluginTs>({ name: '@kubb/plugin-ts', options })
+ */
+export function createMockedPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(params: {
+  name: TOptions['name']
+  options: TOptions['resolvedOptions']
+  resolver?: TOptions['resolver']
+  transformer?: Visitor
+  dependencies?: Array<string>
+}): Plugin<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>
+}
+
+type RenderGeneratorOptions<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  adapter: Adapter
+  driver: PluginDriver
+  plugin: Plugin<TOptions>
+  options: TOptions['resolvedOptions']
+  resolver: TOptions['resolver']
+}
+
+function createMockedPluginContext<TOptions extends PluginFactoryOptions>(opts: RenderGeneratorOptions<TOptions>): Omit<GeneratorContext<TOptions>, 'options'> {
+  const root = resolve(opts.config.root, opts.config.output.path)
+
+  return {
+    config: opts.config,
+    root,
+    getMode: (output: { path: string }) => PluginDriver.getMode(resolve(root, output.path)),
+    adapter: opts.adapter,
+    resolver: opts.resolver,
+    plugin: opts.plugin,
+    driver: opts.driver,
+    inputNode: { kind: 'Input', schemas: [], operations: [] },
+    upsertFile: async (...files: Array<FileNode>) => opts.driver.fileManager.upsert(...files),
+    warn: (msg: string) => console.warn(msg),
+    error: (msg: string) => console.error(msg),
+    info: (msg: string) => console.info(msg),
+    openInStudio: async () => {},
+  } as unknown as Omit<GeneratorContext<TOptions>, 'options'>
+}
+
+/**
+ * Renders a generator's `schema` method in a test context.
+ *
+ * @example
+ * await renderGeneratorSchema(typeGenerator, node, { config, adapter, driver, plugin, options, resolver })
+ * await matchFiles(driver.fileManager.files)
+ */
+export async function renderGeneratorSchema<TOptions extends PluginFactoryOptions>(
+  generator: Generator<TOptions>,
+  node: SchemaNode,
+  opts: RenderGeneratorOptions<TOptions>,
+): Promise<void> {
+  if (!generator.schema) return
+  const context = createMockedPluginContext(opts)
+  const transformedNode = opts.plugin.transformer ? transform(node, opts.plugin.transformer) : node
+  const result = await generator.schema(transformedNode, { ...context, options: opts.options })
+  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+}
+
+/**
+ * Renders a generator's `operation` method in a test context.
+ *
+ * @example
+ * await renderGeneratorOperation(typeGenerator, node, { config, adapter, driver, plugin, options, resolver })
+ * await matchFiles(driver.fileManager.files)
+ */
+export async function renderGeneratorOperation<TOptions extends PluginFactoryOptions>(
+  generator: Generator<TOptions>,
+  node: OperationNode,
+  opts: RenderGeneratorOptions<TOptions>,
+): Promise<void> {
+  if (!generator.operation) return
+  const context = createMockedPluginContext(opts)
+  const transformedNode = opts.plugin.transformer ? transform(node, opts.plugin.transformer) : node
+  const result = await generator.operation(transformedNode, { ...context, options: opts.options })
+  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+}
+
+/**
+ * Renders a generator's `operations` method in a test context.
+ *
+ * @example
+ * await renderGeneratorOperations(classClientGenerator, nodes, { config, adapter, driver, plugin, options, resolver })
+ * await matchFiles(driver.fileManager.files)
+ */
+export async function renderGeneratorOperations<TOptions extends PluginFactoryOptions>(
+  generator: Generator<TOptions>,
+  nodes: Array<OperationNode>,
+  opts: RenderGeneratorOptions<TOptions>,
+): Promise<void> {
+  if (!generator.operations) return
+  const context = createMockedPluginContext(opts)
+  const transformedNodes = opts.plugin.transformer ? nodes.map((n) => transform(n, opts.plugin.transformer!)) : nodes
+  const result = await generator.operations(transformedNodes, { ...context, options: opts.options })
+  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+}

package/src/types.ts

@@ -1,6 +1,5 @@
 import type { AsyncEventEmitter, PossiblePromise } from '@internals/utils'
-import type { FileNode, ImportNode, InputNode, Node, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
-import type { HttpMethod } from '@kubb/oas'
+import type { FileNode, HttpMethod, ImportNode, InputNode, Node, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
 import type { DEFAULT_STUDIO_URL, logLevel } from './constants.ts'
 import type { RendererFactory } from './createRenderer.ts'
 import type { Storage } from './createStorage.ts'
@@ -436,7 +435,7 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
    * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
    * when the plugin declares a renderer.
    */
-  generators?: Array<Generator<any>>
+  generators?: Array<Generator>
   /**
    * Specifies the plugins that the current plugin depends on. The current plugin is executed after all listed plugins.
    * An error is returned if any required dependency plugin is missing.
@@ -556,7 +555,7 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
    * when the plugin declares a renderer.
    */
-  generators?: Array<Generator<any>>
+  generators?: Array<Generator>
 
   buildStart: (this: PluginContext<TOptions>) => PossiblePromise<void>
   /**
@@ -697,7 +696,7 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
   /**
    * Returns the output mode for the given output config.
    * Returns `'single'` when `output.path` has a file extension, `'split'` otherwise.
-   * Shorthand for `getMode(path.resolve(this.root, output.path))`.
+   * Shorthand for `PluginDriver.getMode(path.resolve(this.root, output.path))`.
    */
   getMode: (output: { path: string }) => 'single' | 'split'
   driver: PluginDriver
@@ -1149,14 +1148,6 @@ export type PossibleConfig<TCliOptions = undefined> =
   | PossiblePromise<Config | Config[]>
   | ((...args: [TCliOptions] extends [undefined] ? [] : [TCliOptions]) => PossiblePromise<Config | Config[]>)
 
-/**
- * All accepted forms of a Kubb configuration.
- * @deprecated
- * Kept for backward compatibility. Prefer `PossibleConfig<CLIOptions>` in new code.
- */
-export type ConfigInput = PossibleConfig<CLIOptions>
-
 export type { BuildOutput } from './createKubb.ts'
 export type { Parser } from './defineParser.ts'
-export type { FunctionParamsAST } from './utils/FunctionParams.ts'
 export type { FileMetaBase } from './utils/getBarrelFiles.ts'

package/src/utils/TreeNode.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
 import type { FileNode } from '@kubb/ast'
-import { getMode } from '../PluginDriver.ts'
+import { PluginDriver } from '../PluginDriver.ts'
 
 type BarrelData = {
   file?: FileNode
@@ -155,7 +155,7 @@ export class TreeNode {
         name: filteredTree.name,
         path: filteredTree.path,
         file: filteredTree.file,
-        type: getMode(filteredTree.path),
+        type: PluginDriver.getMode(filteredTree.path),
       })
 
       const recurse = (node: typeof treeNode, item: DirectoryTree) => {
@@ -163,7 +163,7 @@ export class TreeNode {
           name: item.name,
           path: item.path,
           file: item.file,
-          type: getMode(item.path),
+          type: PluginDriver.getMode(item.path),
         })
 
         if (item.children?.length) {

package/src/utils/executeStrategies.ts

@@ -82,19 +82,3 @@ export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TV
 
   return Promise.allSettled(tasks) as TOutput
 }
-
-/**
- * Execution strategy used when dispatching plugin hook calls.
- *  @deprecated
- */
-export type Strategy = 'seq' | 'first' | 'parallel'
-
-type StrategyOutputMap<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = {
-  first: HookFirstOutput<TInput, TValue>
-  seq: SeqOutput<TInput, TValue>
-  parallel: HookParallelOutput<TInput, TValue>
-}
-/**
- *  @deprecated
- */
-export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = StrategyOutputMap<TInput, TValue>[TStrategy]

package/dist/chunk-ByKO4r7w.cjs

@@ -1,38 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-Object.defineProperty(exports, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});

package/dist/hooks.cjs

@@ -1,32 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./chunk-ByKO4r7w.cjs");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-//#region src/hooks/useDriver.ts
-/**
-* @deprecated use `driver` from the generator component props instead
-*/
-function useDriver() {
-	return (0, _kubb_renderer_jsx.inject)(_kubb_renderer_jsx.KubbContext).driver;
-}
-//#endregion
-//#region src/hooks/useMode.ts
-/**
-* @deprecated use `mode` from the generator component props instead
-*/
-function useMode() {
-	return (0, _kubb_renderer_jsx.inject)(_kubb_renderer_jsx.KubbContext).mode;
-}
-//#endregion
-//#region src/hooks/usePlugin.ts
-/**
-* @deprecated use `plugin` from the generator component props instead
-*/
-function usePlugin() {
-	return (0, _kubb_renderer_jsx.inject)(_kubb_renderer_jsx.KubbContext).plugin;
-}
-//#endregion
-exports.useDriver = useDriver;
-exports.useMode = useMode;
-exports.usePlugin = usePlugin;
-
-//# sourceMappingURL=hooks.cjs.map

package/dist/hooks.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.cjs","names":["KubbContext","KubbContext","KubbContext"],"sources":["../src/hooks/useDriver.ts","../src/hooks/useMode.ts","../src/hooks/usePlugin.ts"],"sourcesContent":["import { inject, KubbContext } from '@kubb/renderer-jsx'\nimport type { PluginDriver } from '../PluginDriver.ts'\n\n/**\n * @deprecated use `driver` from the generator component props instead\n */\nexport function useDriver(): PluginDriver {\n  return inject(KubbContext)!.driver as PluginDriver\n}\n","import { inject, KubbContext } from '@kubb/renderer-jsx'\n\n/**\n * @deprecated use `mode` from the generator component props instead\n */\nexport function useMode(): 'single' | 'split' {\n  return inject(KubbContext)!.mode\n}\n","import { inject, KubbContext } from '@kubb/renderer-jsx'\nimport type { Plugin, PluginFactoryOptions } from '../types.ts'\n\n/**\n * @deprecated use `plugin` from the generator component props instead\n */\nexport function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {\n  return inject(KubbContext)!.plugin as Plugin<TOptions>\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,YAA0B;AACxC,SAAA,GAAA,mBAAA,QAAcA,mBAAAA,YAAY,CAAE;;;;;;;ACF9B,SAAgB,UAA8B;AAC5C,SAAA,GAAA,mBAAA,QAAcC,mBAAAA,YAAY,CAAE;;;;;;;ACA9B,SAAgB,YAA4F;AAC1G,SAAA,GAAA,mBAAA,QAAcC,mBAAAA,YAAY,CAAE"}

package/dist/hooks.d.ts

@@ -1,23 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as Plugin, M as PluginFactoryOptions, t as PluginDriver } from "./PluginDriver-D8lWvtUg.js";
-
-//#region src/hooks/useDriver.d.ts
-/**
- * @deprecated use `driver` from the generator component props instead
- */
-declare function useDriver(): PluginDriver;
-//#endregion
-//#region src/hooks/useMode.d.ts
-/**
- * @deprecated use `mode` from the generator component props instead
- */
-declare function useMode(): 'single' | 'split';
-//#endregion
-//#region src/hooks/usePlugin.d.ts
-/**
- * @deprecated use `plugin` from the generator component props instead
- */
-declare function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions>;
-//#endregion
-export { useDriver, useMode, usePlugin };
-//# sourceMappingURL=hooks.d.ts.map