@kubb/plugin-oas 3.0.0-alpha.15 → 3.0.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-oas",
-  "version": "3.0.0-alpha.15",
+  "version": "3.0.0-alpha.17",
   "description": "Generator swagger",
   "keywords": [
     "typescript",
@@ -77,23 +77,23 @@
     "@stoplight/yaml": "^4.3.0",
     "execa": "^9.3.1",
     "remeda": "^2.12.0",
-    "@kubb/core": "3.0.0-alpha.15",
-    "@kubb/fs": "3.0.0-alpha.15",
-    "@kubb/oas": "3.0.0-alpha.15",
-    "@kubb/react": "3.0.0-alpha.15"
+    "@kubb/core": "3.0.0-alpha.17",
+    "@kubb/fs": "3.0.0-alpha.17",
+    "@kubb/oas": "3.0.0-alpha.17",
+    "@kubb/react": "3.0.0-alpha.17"
   },
   "devDependencies": {
     "@types/react": "^18.3.5",
     "@types/react-dom": "^18.3.0",
     "react": "^18.3.1",
     "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.15",
-    "@kubb/config-ts": "3.0.0-alpha.15",
-    "@kubb/config-tsup": "3.0.0-alpha.15"
+    "typescript": "^5.6.2",
+    "@kubb/config-biome": "3.0.0-alpha.17",
+    "@kubb/config-ts": "3.0.0-alpha.17",
+    "@kubb/config-tsup": "3.0.0-alpha.17"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.15"
+    "@kubb/react": "3.0.0-alpha.17"
   },
   "engines": {
     "node": ">=20"

package/src/OperationGenerator.ts

@@ -12,7 +12,7 @@ import type { Exclude, Include, OperationSchemas, OperationsByMethod, Override }
 /**
  * @deprecated
  */
-export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
+export type GetOperationGeneratorOptions<T = any> = any
 
 export type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
 
@@ -31,10 +31,9 @@ type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
 }
 
 export class OperationGenerator<
-  TOptions = unknown,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
   #operationsByMethod: OperationsByMethod = {}
   get operationsByMethod(): OperationsByMethod {
     return this.#operationsByMethod
@@ -44,7 +43,7 @@ export class OperationGenerator<
     this.#operationsByMethod = paths
   }
 
-  #getOptions(operation: Operation, method: HttpMethod): Partial<TOptions> {
+  #getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']> {
     const { override = [] } = this.context
 
     return (
@@ -131,10 +130,8 @@ export class OperationGenerator<
   getSchemas(
     operation: Operation,
     {
-      forStatusCode,
       resolveName = (name) => name,
     }: {
-      forStatusCode?: string | number
       resolveName?: (name: string) => string
     } = {},
   ): OperationSchemas {
@@ -142,8 +139,7 @@ export class OperationGenerator<
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, 'query')
     const headerParamsSchema = this.context.oas.getParametersSchema(operation, 'header')
     const requestSchema = this.context.oas.getRequestSchema(operation)
-    const responseStatusCode =
-      forStatusCode || (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
+    const responseStatusCode = (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
     const responseSchema = this.context.oas.getResponseSchema(operation, responseStatusCode)
     const statusCodes = operation.getResponseStatusCodes().map((statusCode) => {
       let name = statusCode
@@ -231,7 +227,7 @@ export class OperationGenerator<
 
   #methods = ['get', 'post', 'patch', 'put', 'delete']
 
-  async build(...generators: Array<Generator<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -336,41 +332,41 @@ export class OperationGenerator<
   /**
    * Operation
    */
-  async operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * GET
    */
-  async get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * POST
    */
-  async post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
   /**
    * PATCH
    */
-  async patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * PUT
    */
-  async put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * DELETE
    */
-  async delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 

package/src/SchemaGenerator.ts

@@ -808,7 +808,7 @@ export class SchemaGenerator<
         ].filter(Boolean)
       }
 
-      if (!['boolean', 'object', 'number', 'string', 'integer'].includes(schema.type)) {
+      if (!['boolean', 'object', 'number', 'string', 'integer', 'null'].includes(schema.type)) {
         this.context.pluginManager.logger.emit('warning', `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`)
       }
 
@@ -819,14 +819,18 @@ export class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(...generators: Array<Generator<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
     const schemas = getSchemas({ oas, contentType, includes: include })
 
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+    const promises = Object.entries(schemas).reduce((acc, [name, value]) => {
+      if (!value) {
+        return acc
+      }
+
       const options = this.#getOptions({ name })
-      const promiseOperation = this.schema.call(this, name, schema, {
+      const promiseOperation = this.schema.call(this, name, value, {
         ...this.options,
         ...options,
       })
@@ -836,10 +840,15 @@ export class SchemaGenerator<
       }
 
       generators?.forEach((generator) => {
+        const tree = this.parse({ schema: value, name: name })
+
         const promise = generator.schema?.({
           instance: this,
-          name,
-          schema,
+          schema: {
+            name,
+            value,
+            tree,
+          },
           options: {
             ...this.options,
             ...options,

package/src/components/Schema.tsx

@@ -1,14 +1,8 @@
-import { File, createContext, useApp, useFile } from '@kubb/react'
-
-import { schemaKeywords } from '../SchemaMapper.ts'
-import { useSchema } from '../hooks/useSchema.ts'
+import { createContext } from '@kubb/react'
 
 import type { SchemaObject } from '@kubb/oas'
 import type { KubbNode } from '@kubb/react/types'
-import type { ReactNode } from 'react'
-import { SchemaGenerator } from '../SchemaGenerator.ts'
 import type { Schema as SchemaType } from '../SchemaMapper.ts'
-import type { PluginOas } from '../types.ts'
 
 export type SchemaContextProps = {
   name: string
@@ -32,95 +26,4 @@ export function Schema({ name, value, tree = [], children }: Props): KubbNode {
   return <SchemaContext.Provider value={{ name, schema: value, tree }}>{children}</SchemaContext.Provider>
 }
 
-type FileProps = {
-  isTypeOnly?: boolean
-  output: string | undefined
-  children?: KubbNode
-}
-
-Schema.File = function ({ isTypeOnly, children }: FileProps): ReactNode {
-  const { plugin, pluginManager, mode } = useApp<PluginOas>()
-  const { name } = useSchema()
-
-  if (mode === 'single') {
-    const baseName = `${pluginManager.resolveName({
-      name,
-      pluginKey: plugin.key,
-      type: 'file',
-    })}.ts` as const
-
-    const resolvedPath = pluginManager.resolvePath({
-      baseName: '',
-      pluginKey: plugin.key,
-    })
-
-    if (!resolvedPath) {
-      return null
-    }
-
-    return (
-      <File
-        baseName={baseName}
-        path={resolvedPath}
-        meta={{
-          pluginKey: plugin.key,
-        }}
-      >
-        {children}
-      </File>
-    )
-  }
-
-  const baseName = `${pluginManager.resolveName({
-    name,
-    pluginKey: plugin.key,
-    type: 'file',
-  })}.ts` as const
-  const resolvedPath = pluginManager.resolvePath({
-    baseName,
-    pluginKey: plugin.key,
-  })
-
-  if (!resolvedPath) {
-    return null
-  }
-
-  return (
-    <File
-      baseName={baseName}
-      path={resolvedPath}
-      meta={{
-        pluginKey: plugin.key,
-      }}
-    >
-      <Schema.Imports isTypeOnly={isTypeOnly} />
-      {children}
-    </File>
-  )
-}
-
-type SchemaImportsProps = {
-  isTypeOnly?: boolean
-}
-
-Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
-  const { tree } = useSchema()
-  const { path: root } = useFile()
-
-  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
-
-  return (
-    <>
-      {refs
-        ?.map((item, i) => {
-          if (!item.args.path) {
-            return undefined
-          }
-
-          return <File.Import key={i} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={isTypeOnly} />
-        })
-        .filter(Boolean)}
-    </>
-  )
-}
 Schema.Context = SchemaContext

package/src/generator.tsx

@@ -6,6 +6,7 @@ import { App, createRoot } from '@kubb/react'
 import type { KubbNode } from '@kubb/react/types'
 import type { OperationGenerator } from './OperationGenerator.ts'
 import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.ts'
+import type { Schema } from './SchemaMapper.ts'
 import type { OperationsByMethod } from './types.ts'
 
 type OperationsProps<TOptions extends PluginFactoryOptions> = {
@@ -23,16 +24,19 @@ type OperationProps<TOptions extends PluginFactoryOptions> = {
 
 type SchemaProps<TOptions extends PluginFactoryOptions> = {
   instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
-  name: string
-  schema: SchemaObject
+  schema: {
+    name: string
+    tree: Array<Schema>
+    value: SchemaObject
+  }
   options: TOptions['resolvedOptions']
 }
 
 export type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
   name: string
-  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
-  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
-  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
+  operations?: (this: GeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
+  operation?: (this: GeneratorOptions<TOptions>, props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
+  schema?: (this: GeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
 }
 
 export type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>
@@ -43,9 +47,9 @@ export function createGenerator<TOptions extends PluginFactoryOptions>(parseOpti
 
 export type ReactGeneratorOptions<TOptions extends PluginFactoryOptions> = {
   name: string
-  Operations?: (props: OperationsProps<TOptions>) => KubbNode
-  Operation?: (props: OperationProps<TOptions>) => KubbNode
-  Schema?: (props: SchemaProps<TOptions>) => KubbNode
+  Operations?: (this: ReactGeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => KubbNode
+  Operation?: (this: ReactGeneratorOptions<TOptions>, props: OperationProps<TOptions>) => KubbNode
+  Schema?: (this: ReactGeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => KubbNode
   /**
    * Combine all react nodes and only render ones(to string or render)
    */
@@ -65,10 +69,12 @@ export function createReactGenerator<TOptions extends PluginFactoryOptions>(pars
         logger: pluginManager.logger,
       })
 
+      const Component = parseOptions.Operations.bind(this)
+
       root.render(
         <App pluginManager={pluginManager} plugin={plugin} mode={mode}>
           <Oas oas={oas} operations={operations} generator={instance}>
-            <parseOptions.Operations operations={operations} instance={instance} operationsByMethod={operationsByMethod} options={options} />
+            <Component operations={operations} instance={instance} operationsByMethod={operationsByMethod} options={options} />
           </Oas>
         </App>,
       )
@@ -85,11 +91,13 @@ export function createReactGenerator<TOptions extends PluginFactoryOptions>(pars
         logger: pluginManager.logger,
       })
 
+      const Component = parseOptions.Operation.bind(this)
+
       root.render(
         <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
           <Oas oas={oas} operations={[operation]} generator={instance}>
             <Oas.Operation operation={operation}>
-              <parseOptions.Operation operation={operation} options={options} instance={instance} />
+              <Component operation={operation} options={options} instance={instance} />
             </Oas.Operation>
           </Oas>
         </App>,
@@ -97,7 +105,7 @@ export function createReactGenerator<TOptions extends PluginFactoryOptions>(pars
 
       return root.files
     },
-    async schema({ instance, schema, name, options }) {
+    async schema({ instance, schema, options }) {
       if (!parseOptions.Schema) {
         return []
       }
@@ -107,13 +115,13 @@ export function createReactGenerator<TOptions extends PluginFactoryOptions>(pars
         logger: pluginManager.logger,
       })
 
-      const tree = instance.parse({ schema, name })
+      const Component = parseOptions.Schema.bind(this)
 
       root.render(
         <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
           <Oas oas={oas}>
-            <Oas.Schema name={name} value={schema} tree={tree}>
-              <parseOptions.Schema schema={schema} options={options} instance={instance} name={name} />
+            <Oas.Schema name={schema.name} value={schema.value} tree={schema.tree}>
+              <Component schema={schema} options={options} instance={instance} />
             </Oas.Schema>
           </Oas>
         </App>,

package/src/generators/jsonGenerator.ts

@@ -4,10 +4,10 @@ import type { PluginOas } from '../types.ts'
 
 export const jsonGenerator = createGenerator<PluginOas>({
   name: 'plugin-oas',
-  async schema({ schema, name, instance }) {
+  async schema({ schema, instance }) {
     const { pluginManager, plugin } = instance.context
     const file = pluginManager.getFile({
-      name: camelCase(name),
+      name: camelCase(schema.name),
       extName: '.json',
       mode: 'split',
       pluginKey: plugin.key,
@@ -18,10 +18,10 @@ export const jsonGenerator = createGenerator<PluginOas>({
         ...file,
         sources: [
           {
-            name: camelCase(name),
+            name: camelCase(schema.name),
             isExportable: false,
             isIndexable: false,
-            value: JSON.stringify(schema),
+            value: JSON.stringify(schema.value),
           },
         ],
       },

package/src/hooks/index.ts

@@ -1,5 +1,7 @@
 export { useOas } from './useOas.ts'
 export { useOperation } from './useOperation.ts'
 export { useOperationManager } from './useOperationManager.ts'
+export type { SchemaNames } from './useOperationManager.ts'
 export { useOperations } from './useOperations.ts'
 export { useSchema } from './useSchema.ts'
+export { useSchemaManager } from './useSchemaManager.ts'

package/src/hooks/useOperationManager.ts

@@ -13,7 +13,7 @@ type FileMeta = FileMetaBase & {
   tag?: string
 }
 
-type SchemaNames = {
+export type SchemaNames = {
   request: string | undefined
   parameters: {
     path: string | undefined
@@ -25,14 +25,41 @@ type SchemaNames = {
 }
 
 type UseOperationManagerResult = {
-  getName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
-  getFile: (operation: OperationType, params?: { pluginKey?: Plugin['key']; extName?: KubbFile.Extname }) => KubbFile.File<FileMeta>
-  groupSchemasByName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => SchemaNames
-  getSchemas: (
+  getName: (
+    operation: OperationType,
+    params: {
+      prefix?: string
+      suffix?: string
+      pluginKey?: Plugin['key']
+      type: ResolveNameParams['type']
+    },
+  ) => string
+  getSchemaName: (
     operation: Operation,
-    params?: { pluginKey?: Plugin['key']; type?: ResolveNameParams['type'] },
-    forStatusCode?: string | number,
-  ) => OperationSchemas
+    key: keyof Omit<OperationSchemas, 'errors' | 'statusCodes'>,
+    params?: {
+      pluginKey?: Plugin['key']
+      type?: ResolveNameParams['type']
+    },
+  ) => string
+  getFile: (
+    operation: OperationType,
+    params?: {
+      prefix?: string
+      suffix?: string
+      pluginKey?: Plugin['key']
+      extName?: KubbFile.Extname
+      tag?: string
+    },
+  ) => KubbFile.File<FileMeta>
+  groupSchemasByName: (
+    operation: OperationType,
+    params: {
+      pluginKey?: Plugin['key']
+      type: ResolveNameParams['type']
+    },
+  ) => SchemaNames
+  getSchemas: (operation: Operation, params?: { pluginKey?: Plugin['key']; type?: ResolveNameParams['type'] }) => OperationSchemas
 }
 
 /**
@@ -42,24 +69,48 @@ export function useOperationManager(): UseOperationManagerResult {
   const { plugin, pluginManager } = useApp()
   const { generator } = useContext(Oas.Context)
 
-  if (!generator) {
-    throw new Error(`'generator' is not defined`)
-  }
-
-  const getName: UseOperationManagerResult['getName'] = (operation, { pluginKey = plugin.key, type }) => {
+  const getName: UseOperationManagerResult['getName'] = (operation, { prefix = '', suffix = '', pluginKey = plugin.key, type }) => {
     return pluginManager.resolveName({
-      name: operation.getOperationId(),
+      name: `${prefix} ${operation.getOperationId()} ${suffix}`,
       pluginKey,
       type,
     })
   }
 
-  const getFile: UseOperationManagerResult['getFile'] = (operation, { pluginKey = plugin.key, extName = '.ts' } = {}) => {
-    // needed for the `output.group`
-    const tag = operation.getTags().at(0)?.name
-    //TODO replace with group
-    const name = getName(operation, { type: 'file', pluginKey })
+  const getSchemas: UseOperationManagerResult['getSchemas'] = (operation, params) => {
+    if (!generator) {
+      throw new Error(`'generator' is not defined`)
+    }
 
+    return generator.getSchemas(operation, {
+      resolveName: (name) =>
+        pluginManager.resolveName({
+          name,
+          pluginKey: params?.pluginKey,
+          type: params?.type,
+        }),
+    })
+  }
+
+  const getSchemaName: UseOperationManagerResult['getSchemaName'] = (operation, key, { pluginKey = plugin.key, type } = {}) => {
+    const schemas = getSchemas(operation)
+
+    if (!schemas[key]?.name) {
+      throw new Error(`SchemaName not found for ${operation.getOperationId()}`)
+    }
+
+    return pluginManager.resolveName({
+      name: schemas[key]?.name,
+      pluginKey,
+      type,
+    })
+  }
+  //TODO replace tag with group
+  const getFile: UseOperationManagerResult['getFile'] = (
+    operation,
+    { prefix, suffix, pluginKey = plugin.key, tag = operation.getTags().at(0)?.name, extName = '.ts' } = {},
+  ) => {
+    const name = getName(operation, { type: 'file', pluginKey, prefix, suffix })
     const file = pluginManager.getFile({
       name,
       extName,
@@ -79,6 +130,10 @@ export function useOperationManager(): UseOperationManagerResult {
   }
 
   const groupSchemasByName: UseOperationManagerResult['groupSchemasByName'] = (operation, { pluginKey = plugin.key, type }) => {
+    if (!generator) {
+      throw new Error(`'generator' is not defined`)
+    }
+
     const schemas = generator.getSchemas(operation)
 
     const errors = (schemas.errors || []).reduce(
@@ -149,16 +204,8 @@ export function useOperationManager(): UseOperationManagerResult {
   return {
     getName,
     getFile,
-    getSchemas: (operation, params, forStatusCode) =>
-      generator.getSchemas(operation, {
-        forStatusCode,
-        resolveName: (name) =>
-          pluginManager.resolveName({
-            name,
-            pluginKey: params?.pluginKey,
-            type: params?.type,
-          }),
-      }),
+    getSchemas,
+    getSchemaName,
     groupSchemasByName,
   }
 }

package/src/hooks/useSchemaManager.ts

@@ -0,0 +1,76 @@
+import { File, useApp } from '@kubb/react'
+
+import type { FileMetaBase, Plugin, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+import type { Mode } from '@kubb/fs/types'
+import { type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
+
+type FileMeta = FileMetaBase & {
+  pluginKey: Plugin['key']
+  name: string
+  tag?: string
+}
+
+type UseSchemaManagerResult = {
+  getName: (name: string, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
+  getFile: (name: string, params?: { pluginKey?: Plugin['key']; mode?: Mode; extName?: KubbFile.Extname; tag?: string }) => KubbFile.File<FileMeta>
+  getImports: (tree: Array<Schema>) => Array<KubbFile.Import>
+}
+
+/**
+ * `useSchemaManager` will return some helper functions that can be used to get the schema file, get the schema name.
+ */
+export function useSchemaManager(): UseSchemaManagerResult {
+  const { mode, plugin, pluginManager, fileManager } = useApp()
+
+  const getName: UseSchemaManagerResult['getName'] = (name, { pluginKey = plugin.key, type }) => {
+    return pluginManager.resolveName({
+      name,
+      pluginKey,
+      type,
+    })
+  }
+  //TODO replace tag with group
+  const getFile: UseSchemaManagerResult['getFile'] = (name, { mode = 'split', pluginKey = plugin.key, extName = '.ts', tag } = {}) => {
+    const resolvedName = mode === 'single' ? '' : getName(name, { type: 'file', pluginKey })
+
+    const file = pluginManager.getFile({
+      name: resolvedName,
+      extName,
+      pluginKey,
+      options: { type: 'file', pluginKey, tag },
+    })
+
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name: resolvedName,
+        pluginKey,
+      },
+    }
+  }
+
+  const getImports: UseSchemaManagerResult['getImports'] = (tree) => {
+    const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
+
+    return refs
+      ?.map((item, i) => {
+        if (!item.args.path) {
+          return undefined
+        }
+
+        return {
+          name: [item.args.name],
+          path: item.args.path,
+        }
+      })
+      .filter(Boolean)
+  }
+
+  return {
+    getName,
+    getFile,
+    getImports,
+  }
+}

package/src/utils/getParams.ts

@@ -1,10 +1,10 @@
 import { isParameterObject } from '@kubb/oas'
 
+import { camelCase } from '@kubb/core/transformers'
 import type { FunctionParamsAST } from '@kubb/core/utils'
 import type { OasTypes } from '@kubb/oas'
 import type { Params } from '@kubb/react/types'
 import type { OperationSchema } from '../types.ts'
-import { camelCase } from '@kubb/core/transformers'
 /**
  *
  * @deprecated