@kubb/plugin-oas 4.33.5 → 4.35.0

package/src/SchemaGenerator.ts

@@ -1,12 +1,14 @@
-import { type AsyncEventEmitter, getUniqueName, pascalCase, stringify } from '@internals/utils'
-import type { FileMetaBase, KubbEvents, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
+import { getUniqueName, pascalCase, stringify } from '@internals/utils'
+import type { AsyncEventEmitter, FileMetaBase, KubbEvents, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { contentType, Oas, OasTypes, OpenAPIV3, SchemaObject } from '@kubb/oas'
 import { isDiscriminator, isNullable, isReference, KUBB_INLINE_REF_PREFIX } from '@kubb/oas'
 import type { Fabric } from '@kubb/react-fabric'
 import pLimit from 'p-limit'
 import { isDeepEqual, isNumber, uniqueWith } from 'remeda'
-import type { Generator } from './generators/types.ts'
+import type { CoreGenerator } from './generators/createGenerator.ts'
+import type { ReactGenerator } from './generators/createReactGenerator.ts'
+import type { Generator, Version } from './generators/types.ts'
 import { isKeyword, type Schema, type SchemaKeywordMapper, schemaKeywords } from './SchemaMapper.ts'
 import type { OperationSchema, Override, Refs } from './types.ts'
 import { getSchemaFactory } from './utils/getSchemaFactory.ts'
@@ -1335,7 +1337,7 @@ export class SchemaGenerator<
     return [{ keyword: emptyType }, ...baseItems]
   }
 
-  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions, Version>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
     // Initialize the name mapping if not already done
@@ -1358,7 +1360,10 @@ export class SchemaGenerator<
     return this.#doBuild(schemas, generators)
   }
 
-  async #doBuild(schemas: Record<string, OasTypes.SchemaObject>, generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async #doBuild(
+    schemas: Record<string, OasTypes.SchemaObject>,
+    generators: Array<Generator<TPluginOptions, Version>>,
+  ): Promise<Array<KubbFile.File<TFileMeta>>> {
     const schemaEntries = Object.entries(schemas)
 
     const generatorLimit = pLimit(GENERATOR_CONCURRENCY)
@@ -1366,13 +1371,20 @@ export class SchemaGenerator<
 
     const writeTasks = generators.map((generator) =>
       generatorLimit(async () => {
+        if (generator.version === '2') {
+          return []
+        }
+
+        // After the v2 guard above, all generators here are v1
+        const v1Generator = generator as ReactGenerator<TPluginOptions, '1'> | CoreGenerator<TPluginOptions, '1'>
+
         const schemaTasks = schemaEntries.map(([name, schemaObject]) =>
           schemaLimit(async () => {
             const options = this.#getOptions(name)
 
             const tree = this.parse({ schema: schemaObject as SchemaObject, name, parentName: null, rootName: name })
 
-            if (generator.type === 'react') {
+            if (v1Generator.type === 'react') {
               await buildSchema(
                 {
                   name,
@@ -1382,7 +1394,7 @@ export class SchemaGenerator<
                 {
                   config: this.context.pluginManager.config,
                   fabric: this.context.fabric,
-                  Component: generator.Schema,
+                  Component: v1Generator.Schema,
                   generator: this,
                   plugin: {
                     ...this.context.plugin,
@@ -1397,7 +1409,7 @@ export class SchemaGenerator<
               return []
             }
 
-            const result = await generator.schema?.({
+            const result = await v1Generator.schema?.({
               config: this.context.pluginManager.config,
               generator: this,
               schema: {

package/src/generators/createGenerator.ts

@@ -1,25 +1,30 @@
 import type { PluginFactoryOptions } from '@kubb/core'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import type { OperationProps, OperationsProps, SchemaProps } from './types.ts'
+import type { OperationProps, OperationsProps, SchemaProps, Version } from './types.ts'
 
-type UserGenerator<TOptions extends PluginFactoryOptions> = {
+type UserGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
   name: string
-  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
-  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
-  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
+  version?: TVersion
+  operations?: (props: OperationsProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  operation?: (props: OperationProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  schema?: (props: SchemaProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
 }
 
-export type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+export type CoreGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
   name: string
   type: 'core'
-  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
-  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
-  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
+  version: TVersion
+  operations: (props: OperationsProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  operation: (props: OperationProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  schema: (props: SchemaProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
 }
 
-export function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): CoreGenerator<TOptions> {
+export function createGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'>(
+  generator: UserGenerator<TOptions, TVersion>,
+): CoreGenerator<TOptions, TVersion> {
   return {
     type: 'core',
+    version: (generator.version ?? '1') as TVersion,
     async operations() {
       return []
     },

package/src/generators/createReactGenerator.ts

@@ -1,20 +1,22 @@
 import type { PluginFactoryOptions } from '@kubb/core'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { OperationProps, OperationsProps, SchemaProps } from './types.ts'
+import type { OperationProps, OperationsProps, SchemaProps, Version } from './types.ts'
 
-type UserGenerator<TOptions extends PluginFactoryOptions> = {
+type UserGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
   name: string
-  Operations?: (props: OperationsProps<TOptions>) => FabricReactNode
-  Operation?: (props: OperationProps<TOptions>) => FabricReactNode
-  Schema?: (props: SchemaProps<TOptions>) => FabricReactNode
+  version?: TVersion
+  Operations?: (props: OperationsProps<TOptions, TVersion>) => FabricReactNode
+  Operation?: (props: OperationProps<TOptions, TVersion>) => FabricReactNode
+  Schema?: (props: SchemaProps<TOptions, TVersion>) => FabricReactNode
 }
 
-export type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+export type ReactGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
   name: string
   type: 'react'
-  Operations: (props: OperationsProps<TOptions>) => FabricReactNode
-  Operation: (props: OperationProps<TOptions>) => FabricReactNode
-  Schema: (props: SchemaProps<TOptions>) => FabricReactNode
+  version: TVersion
+  Operations: (props: OperationsProps<TOptions, TVersion>) => FabricReactNode
+  Operation: (props: OperationProps<TOptions, TVersion>) => FabricReactNode
+  Schema: (props: SchemaProps<TOptions, TVersion>) => FabricReactNode
 }
 
 /****
@@ -24,9 +26,12 @@ export type ReactGenerator<TOptions extends PluginFactoryOptions> = {
  *
  * @returns A generator object with async methods for operations, operation, and schema file generation.
  */
-export function createReactGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): ReactGenerator<TOptions> {
+export function createReactGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'>(
+  generator: UserGenerator<TOptions, TVersion>,
+): ReactGenerator<TOptions, TVersion> {
   return {
     type: 'react',
+    version: (generator.version ?? '1') as TVersion,
     Operations() {
       return null
     },

package/src/generators/types.ts

@@ -1,3 +1,4 @@
+import type { OperationNode, SchemaNode } from '@kubb/ast/types'
 import type { Config, Plugin, PluginFactoryOptions } from '@kubb/core'
 import type { Operation, SchemaObject } from '@kubb/oas'
 import type { OperationGenerator } from '../OperationGenerator.ts'
@@ -6,21 +7,43 @@ import type { Schema } from '../SchemaMapper.ts'
 import type { CoreGenerator } from './createGenerator.ts'
 import type { ReactGenerator } from './createReactGenerator.ts'
 
-export type OperationsProps<TOptions extends PluginFactoryOptions> = {
+export type Version = '1' | '2'
+
+export type OperationsV1Props<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
   operations: Array<Operation>
 }
 
-export type OperationProps<TOptions extends PluginFactoryOptions> = {
+export type OperationsV2Props<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  plugin: Plugin<TOptions>
+  nodes: Array<OperationNode>
+}
+
+export type OperationV1Props<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
   operation: Operation
 }
 
-export type SchemaProps<TOptions extends PluginFactoryOptions> = {
+export type OperationV2Props<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  plugin: Plugin<TOptions>
+  node: OperationNode
+}
+
+export type OperationsProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
+  ? OperationsV2Props<TOptions>
+  : OperationsV1Props<TOptions>
+
+export type OperationProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
+  ? OperationV2Props<TOptions>
+  : OperationV1Props<TOptions>
+
+export type SchemaV1Props<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
   plugin: Plugin<TOptions>
@@ -31,4 +54,16 @@ export type SchemaProps<TOptions extends PluginFactoryOptions> = {
   }
 }
 
-export type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>
+export type SchemaV2Props<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  plugin: Plugin<TOptions>
+  node: SchemaNode
+}
+
+export type SchemaProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
+  ? SchemaV2Props<TOptions>
+  : SchemaV1Props<TOptions>
+
+export type Generator<TOptions extends PluginFactoryOptions, TVersion extends Version = Version> =
+  | CoreGenerator<TOptions, TVersion>
+  | ReactGenerator<TOptions, TVersion>

package/src/hooks/index.ts

@@ -1,4 +1,5 @@
 export { useOas } from './useOas.ts'
 export type { SchemaNames } from './useOperationManager.ts'
 export { useOperationManager } from './useOperationManager.ts'
+export { useRootNode } from './useRootNode.ts'
 export { useSchemaManager } from './useSchemaManager.ts'

package/src/hooks/useRootNode.ts

@@ -0,0 +1,25 @@
+import type { RootNode } from '@kubb/ast/types'
+import { useApp } from '@kubb/react-fabric'
+
+/**
+ * Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
+ *
+ * Use this hook inside generator components when you want to consume the
+ * format-agnostic AST directly instead of going through `useOas()`.
+ *
+ * Returns `undefined` when no adapter was configured (legacy OAS-only mode).
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const rootNode = useRootNode()
+ *   if (!rootNode) return null
+ *   return <>{rootNode.schemas.map(s => <Schema key={s.name} node={s} />)}</>
+ * }
+ * ```
+ */
+export function useRootNode(): RootNode | undefined {
+  const { meta } = useApp<{ pluginManager?: { rootNode?: RootNode } }>()
+
+  return meta.pluginManager?.rootNode
+}

package/src/index.ts

@@ -40,4 +40,4 @@ export const createReactGenerator = _createReactGenerator
 /**
  * @deprecated use `import { Generator } from '@kubb/plugin-oas/generators'`
  */
-export type Generator<TOptions extends PluginFactoryOptions> = _Generator<TOptions>
+export type Generator<TOptions extends PluginFactoryOptions, TVersion extends import('./generators/types.ts').Version = '1'> = _Generator<TOptions, TVersion>

package/src/plugin.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
-import type { AsyncEventEmitter } from '@internals/utils'
 import { camelCase } from '@internals/utils'
+import type { AsyncEventEmitter } from '@kubb/core'
 import { type Config, definePlugin, type Group, getMode, type KubbEvents } from '@kubb/core'
 import type { Oas } from '@kubb/oas'
 import { parseFromConfig, resolveServerUrl } from '@kubb/oas'

package/src/utils.tsx

@@ -1,3 +1,4 @@
+import type { OperationNode, SchemaNode } from '@kubb/ast/types'
 import type { Config, Plugin, PluginFactoryOptions } from '@kubb/core'
 import type { Operation, SchemaObject } from '@kubb/oas'
 import { App, createReactFabric, type Fabric } from '@kubb/react-fabric'
@@ -6,92 +7,187 @@ import type { OperationGenerator } from './OperationGenerator.ts'
 import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.ts'
 import type { Schema } from './SchemaMapper.ts'
 
-type BuildOperationsOptions<TOptions extends PluginFactoryOptions> = {
+type BuildOperationsBaseOptions<TOptions extends PluginFactoryOptions> = {
   config: Config
   fabric: Fabric
-  Component: ReactGenerator<any>['Operations']
-  generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
 }
 
+type BuildOperationsV1Options<TOptions extends PluginFactoryOptions> = BuildOperationsBaseOptions<TOptions> & {
+  version?: '1'
+  Component: ReactGenerator<any, '1'>['Operations']
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+}
+
+type BuildOperationsV2Options<TOptions extends PluginFactoryOptions> = BuildOperationsBaseOptions<TOptions> & {
+  version: '2'
+  Component: ReactGenerator<any, '2'>['Operations']
+}
+
+function isBuildOperationsV1Options<TOptions extends PluginFactoryOptions>(
+  options: BuildOperationsV1Options<TOptions> | BuildOperationsV2Options<TOptions>,
+): options is BuildOperationsV1Options<TOptions> {
+  return (options.version ?? '1') === '1'
+}
+
 export async function buildOperations<TOptions extends PluginFactoryOptions>(
   operations: Array<Operation>,
-  { config, fabric, plugin, generator, Component }: BuildOperationsOptions<TOptions>,
+  options: BuildOperationsV1Options<TOptions>,
+): Promise<void>
+export async function buildOperations<TOptions extends PluginFactoryOptions>(
+  nodes: Array<OperationNode>,
+  options: BuildOperationsV2Options<TOptions>,
+): Promise<void>
+export async function buildOperations<TOptions extends PluginFactoryOptions>(
+  operationsOrNodes: Array<Operation> | Array<OperationNode>,
+  options: BuildOperationsV1Options<TOptions> | BuildOperationsV2Options<TOptions>,
 ): Promise<void> {
-  if (!Component) {
+  const { config, fabric, plugin } = options
+
+  if (!options.Component) {
     return undefined
   }
 
-  const { pluginManager, oas, mode } = generator.context
-
   const fabricChild = createReactFabric()
-  await fabricChild.render(
-    <App meta={{ pluginManager, plugin, mode, oas }}>
-      <Component config={config} operations={operations} generator={generator} plugin={plugin} />
-    </App>,
-  )
+
+  if (isBuildOperationsV1Options(options)) {
+    const { generator, Component } = options
+    const { pluginManager, oas, mode } = generator.context
+
+    await fabricChild.render(
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} operations={operationsOrNodes as Array<Operation>} generator={generator} plugin={plugin} />
+      </App>,
+    )
+  } else {
+    const { Component } = options
+    await fabricChild.render(
+      <App meta={{ plugin }}>
+        <Component config={config} nodes={operationsOrNodes as Array<OperationNode>} plugin={plugin} />
+      </App>,
+    )
+  }
 
   await fabric.context.fileManager.upsert(...fabricChild.files)
   fabricChild.unmount()
 }
 
-type BuildOperationOptions<TOptions extends PluginFactoryOptions> = {
+type BuildOperationBaseOptions<TOptions extends PluginFactoryOptions> = {
   config: Config
   fabric: Fabric
-  Component: ReactGenerator<any>['Operation']
-  generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
 }
 
+type BuildOperationV1Options<TOptions extends PluginFactoryOptions> = BuildOperationBaseOptions<TOptions> & {
+  version?: '1'
+  Component: ReactGenerator<any, '1'>['Operation']
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+}
+
+type BuildOperationV2Options<TOptions extends PluginFactoryOptions> = BuildOperationBaseOptions<TOptions> & {
+  version: '2'
+  Component: ReactGenerator<any, '2'>['Operation']
+}
+
+function isBuildOperationV1Options<TOptions extends PluginFactoryOptions>(
+  options: BuildOperationV1Options<TOptions> | BuildOperationV2Options<TOptions>,
+): options is BuildOperationV1Options<TOptions> {
+  return (options.version ?? '1') === '1'
+}
+
+export async function buildOperation<TOptions extends PluginFactoryOptions>(operation: Operation, options: BuildOperationV1Options<TOptions>): Promise<void>
+export async function buildOperation<TOptions extends PluginFactoryOptions>(node: OperationNode, options: BuildOperationV2Options<TOptions>): Promise<void>
 export async function buildOperation<TOptions extends PluginFactoryOptions>(
-  operation: Operation,
-  { config, fabric, plugin, generator, Component }: BuildOperationOptions<TOptions>,
+  operationOrNode: Operation | OperationNode,
+  options: BuildOperationV1Options<TOptions> | BuildOperationV2Options<TOptions>,
 ): Promise<void> {
-  if (!Component) {
+  const { config, fabric, plugin } = options
+
+  if (!options.Component) {
     return undefined
   }
 
-  const { pluginManager, oas, mode } = generator.context
-
   const fabricChild = createReactFabric()
-  await fabricChild.render(
-    <App meta={{ pluginManager, plugin, mode, oas }}>
-      <Component config={config} operation={operation} plugin={plugin} generator={generator} />
-    </App>,
-  )
+
+  if (isBuildOperationV1Options(options)) {
+    const { generator, Component } = options
+    const { pluginManager, oas, mode } = generator.context
+
+    await fabricChild.render(
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} operation={operationOrNode as Operation} plugin={plugin} generator={generator} />
+      </App>,
+    )
+  } else {
+    const { Component } = options
+    await fabricChild.render(
+      <App meta={{ plugin }}>
+        <Component config={config} node={operationOrNode as OperationNode} plugin={plugin} />
+      </App>,
+    )
+  }
 
   await fabric.context.fileManager.upsert(...fabricChild.files)
   fabricChild.unmount()
 }
 
-type BuildSchemaOptions<TOptions extends PluginFactoryOptions> = {
+type BuildSchemaBaseOptions<TOptions extends PluginFactoryOptions> = {
   config: Config
   fabric: Fabric
-  Component: ReactGenerator<any>['Schema']
-  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
   plugin: Plugin<TOptions>
 }
 
+type BuildSchemaV1Options<TOptions extends PluginFactoryOptions> = BuildSchemaBaseOptions<TOptions> & {
+  version?: '1'
+  Component: ReactGenerator<any, '1'>['Schema']
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
+}
+
+type BuildSchemaV2Options<TOptions extends PluginFactoryOptions> = BuildSchemaBaseOptions<TOptions> & {
+  version: '2'
+  Component: ReactGenerator<any, '2'>['Schema']
+}
+
+function isBuildSchemaV1Options<TOptions extends PluginFactoryOptions>(
+  options: BuildSchemaV1Options<TOptions> | BuildSchemaV2Options<TOptions>,
+): options is BuildSchemaV1Options<TOptions> {
+  return (options.version ?? '1') === '1'
+}
+
+export async function buildSchema<TOptions extends PluginFactoryOptions>(
+  schema: { name: string; tree: Array<Schema>; value: SchemaObject },
+  options: BuildSchemaV1Options<TOptions>,
+): Promise<void>
+export async function buildSchema<TOptions extends PluginFactoryOptions>(schema: SchemaNode, options: BuildSchemaV2Options<TOptions>): Promise<void>
 export async function buildSchema<TOptions extends PluginFactoryOptions>(
-  schema: {
-    name: string
-    tree: Array<Schema>
-    value: SchemaObject
-  },
-  { config, fabric, plugin, Component, generator }: BuildSchemaOptions<TOptions>,
+  schema: { name: string; tree: Array<Schema>; value: SchemaObject } | SchemaNode,
+  options: BuildSchemaV1Options<TOptions> | BuildSchemaV2Options<TOptions>,
 ): Promise<void> {
-  if (!Component) {
+  const { config, fabric, plugin } = options
+
+  if (!options.Component) {
     return undefined
   }
 
-  const { pluginManager, oas, mode } = generator.context
-
   const fabricChild = createReactFabric()
-  await fabricChild.render(
-    <App meta={{ pluginManager, plugin, mode, oas }}>
-      <Component config={config} schema={schema} plugin={plugin} generator={generator} />
-    </App>,
-  )
+
+  if (isBuildSchemaV1Options(options)) {
+    const { generator, Component } = options
+    const { pluginManager, oas, mode } = generator.context
+
+    await fabricChild.render(
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} schema={schema as { name: string; tree: Array<Schema>; value: SchemaObject }} plugin={plugin} generator={generator} />
+      </App>,
+    )
+  } else {
+    const { Component } = options
+    await fabricChild.render(
+      <App meta={{ plugin }}>
+        <Component config={config} node={schema as SchemaNode} plugin={plugin} />
+      </App>,
+    )
+  }
 
   await fabric.context.fileManager.upsert(...fabricChild.files)
   fabricChild.unmount()

package/dist/generators-CBlzDhTh.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"generators-CBlzDhTh.cjs","names":["camelCase","getBanner","getFooter"],"sources":["../src/generators/createGenerator.ts","../src/generators/createReactGenerator.ts","../src/generators/jsonGenerator.ts"],"sourcesContent":["import type { PluginFactoryOptions } from '@kubb/core'\nimport type { KubbFile } from '@kubb/fabric-core/types'\nimport type { OperationProps, OperationsProps, SchemaProps } from './types.ts'\n\ntype UserGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>\n  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>\n  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>\n}\n\nexport type CoreGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  type: 'core'\n  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>\n  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>\n  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>\n}\n\nexport function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): CoreGenerator<TOptions> {\n  return {\n    type: 'core',\n    async operations() {\n      return []\n    },\n    async operation() {\n      return []\n    },\n    async schema() {\n      return []\n    },\n    ...generator,\n  }\n}\n","import type { PluginFactoryOptions } from '@kubb/core'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\nimport type { OperationProps, OperationsProps, SchemaProps } from './types.ts'\n\ntype UserGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  Operations?: (props: OperationsProps<TOptions>) => FabricReactNode\n  Operation?: (props: OperationProps<TOptions>) => FabricReactNode\n  Schema?: (props: SchemaProps<TOptions>) => FabricReactNode\n}\n\nexport type ReactGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  type: 'react'\n  Operations: (props: OperationsProps<TOptions>) => FabricReactNode\n  Operation: (props: OperationProps<TOptions>) => FabricReactNode\n  Schema: (props: SchemaProps<TOptions>) => FabricReactNode\n}\n\n/****\n * Creates a generator that uses React component functions to generate files for OpenAPI operations and schemas.\n *\n * The returned generator exposes async methods for generating files from operations, a single operation, or a schema, using the corresponding React components if provided. If a component is not defined, the method returns an empty array.\n *\n * @returns A generator object with async methods for operations, operation, and schema file generation.\n */\nexport function createReactGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): ReactGenerator<TOptions> {\n  return {\n    type: 'react',\n    Operations() {\n      return null\n    },\n    Operation() {\n      return null\n    },\n    Schema() {\n      return null\n    },\n    ...generator,\n  }\n}\n","import { camelCase } from '@internals/utils'\nimport type { PluginOas } from '../types.ts'\nimport { getBanner } from '../utils/getBanner.ts'\nimport { getFooter } from '../utils/getFooter.ts'\nimport { createGenerator } from './createGenerator.ts'\n\nexport const jsonGenerator = createGenerator<PluginOas>({\n  name: 'plugin-oas',\n  async schema({ schema, generator }) {\n    const { pluginManager, plugin } = generator.context\n    const file = pluginManager.getFile({\n      name: camelCase(schema.name),\n      extname: '.json',\n      mode: 'split',\n      pluginKey: plugin.key,\n    })\n\n    return [\n      {\n        ...file,\n        sources: [\n          {\n            name: camelCase(schema.name),\n            isExportable: false,\n            isIndexable: false,\n            value: JSON.stringify(schema.value),\n          },\n        ],\n        banner: getBanner({\n          oas: generator.context.oas,\n          output: plugin.options.output,\n          config: pluginManager.config,\n        }),\n        format: getFooter({ oas: generator.context.oas, output: plugin.options.output }),\n      },\n    ]\n  },\n})\n"],"mappings":";;;AAmBA,SAAgB,gBAAuD,WAA6D;AAClI,QAAO;EACL,MAAM;EACN,MAAM,aAAa;AACjB,UAAO,EAAE;;EAEX,MAAM,YAAY;AAChB,UAAO,EAAE;;EAEX,MAAM,SAAS;AACb,UAAO,EAAE;;EAEX,GAAG;EACJ;;;;;;;;;;;ACNH,SAAgB,qBAA4D,WAA8D;AACxI,QAAO;EACL,MAAM;EACN,aAAa;AACX,UAAO;;EAET,YAAY;AACV,UAAO;;EAET,SAAS;AACP,UAAO;;EAET,GAAG;EACJ;;;;ACjCH,MAAa,gBAAgB,gBAA2B;CACtD,MAAM;CACN,MAAM,OAAO,EAAE,QAAQ,aAAa;EAClC,MAAM,EAAE,eAAe,WAAW,UAAU;AAQ5C,SAAO,CACL;GACE,GATS,cAAc,QAAQ;IACjC,MAAMA,kBAAAA,UAAU,OAAO,KAAK;IAC5B,SAAS;IACT,MAAM;IACN,WAAW,OAAO;IACnB,CAAC;GAKE,SAAS,CACP;IACE,MAAMA,kBAAAA,UAAU,OAAO,KAAK;IAC5B,cAAc;IACd,aAAa;IACb,OAAO,KAAK,UAAU,OAAO,MAAM;IACpC,CACF;GACD,QAAQC,kBAAAA,UAAU;IAChB,KAAK,UAAU,QAAQ;IACvB,QAAQ,OAAO,QAAQ;IACvB,QAAQ,cAAc;IACvB,CAAC;GACF,QAAQC,kBAAAA,UAAU;IAAE,KAAK,UAAU,QAAQ;IAAK,QAAQ,OAAO,QAAQ;IAAQ,CAAC;GACjF,CACF;;CAEJ,CAAC"}

package/dist/generators-DRPPf38p.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generators-DRPPf38p.js","names":[],"sources":["../src/generators/createGenerator.ts","../src/generators/createReactGenerator.ts","../src/generators/jsonGenerator.ts"],"sourcesContent":["import type { PluginFactoryOptions } from '@kubb/core'\nimport type { KubbFile } from '@kubb/fabric-core/types'\nimport type { OperationProps, OperationsProps, SchemaProps } from './types.ts'\n\ntype UserGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>\n  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>\n  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>\n}\n\nexport type CoreGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  type: 'core'\n  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>\n  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>\n  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>\n}\n\nexport function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): CoreGenerator<TOptions> {\n  return {\n    type: 'core',\n    async operations() {\n      return []\n    },\n    async operation() {\n      return []\n    },\n    async schema() {\n      return []\n    },\n    ...generator,\n  }\n}\n","import type { PluginFactoryOptions } from '@kubb/core'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\nimport type { OperationProps, OperationsProps, SchemaProps } from './types.ts'\n\ntype UserGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  Operations?: (props: OperationsProps<TOptions>) => FabricReactNode\n  Operation?: (props: OperationProps<TOptions>) => FabricReactNode\n  Schema?: (props: SchemaProps<TOptions>) => FabricReactNode\n}\n\nexport type ReactGenerator<TOptions extends PluginFactoryOptions> = {\n  name: string\n  type: 'react'\n  Operations: (props: OperationsProps<TOptions>) => FabricReactNode\n  Operation: (props: OperationProps<TOptions>) => FabricReactNode\n  Schema: (props: SchemaProps<TOptions>) => FabricReactNode\n}\n\n/****\n * Creates a generator that uses React component functions to generate files for OpenAPI operations and schemas.\n *\n * The returned generator exposes async methods for generating files from operations, a single operation, or a schema, using the corresponding React components if provided. If a component is not defined, the method returns an empty array.\n *\n * @returns A generator object with async methods for operations, operation, and schema file generation.\n */\nexport function createReactGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): ReactGenerator<TOptions> {\n  return {\n    type: 'react',\n    Operations() {\n      return null\n    },\n    Operation() {\n      return null\n    },\n    Schema() {\n      return null\n    },\n    ...generator,\n  }\n}\n","import { camelCase } from '@internals/utils'\nimport type { PluginOas } from '../types.ts'\nimport { getBanner } from '../utils/getBanner.ts'\nimport { getFooter } from '../utils/getFooter.ts'\nimport { createGenerator } from './createGenerator.ts'\n\nexport const jsonGenerator = createGenerator<PluginOas>({\n  name: 'plugin-oas',\n  async schema({ schema, generator }) {\n    const { pluginManager, plugin } = generator.context\n    const file = pluginManager.getFile({\n      name: camelCase(schema.name),\n      extname: '.json',\n      mode: 'split',\n      pluginKey: plugin.key,\n    })\n\n    return [\n      {\n        ...file,\n        sources: [\n          {\n            name: camelCase(schema.name),\n            isExportable: false,\n            isIndexable: false,\n            value: JSON.stringify(schema.value),\n          },\n        ],\n        banner: getBanner({\n          oas: generator.context.oas,\n          output: plugin.options.output,\n          config: pluginManager.config,\n        }),\n        format: getFooter({ oas: generator.context.oas, output: plugin.options.output }),\n      },\n    ]\n  },\n})\n"],"mappings":";;;AAmBA,SAAgB,gBAAuD,WAA6D;AAClI,QAAO;EACL,MAAM;EACN,MAAM,aAAa;AACjB,UAAO,EAAE;;EAEX,MAAM,YAAY;AAChB,UAAO,EAAE;;EAEX,MAAM,SAAS;AACb,UAAO,EAAE;;EAEX,GAAG;EACJ;;;;;;;;;;;ACNH,SAAgB,qBAA4D,WAA8D;AACxI,QAAO;EACL,MAAM;EACN,aAAa;AACX,UAAO;;EAET,YAAY;AACV,UAAO;;EAET,SAAS;AACP,UAAO;;EAET,GAAG;EACJ;;;;ACjCH,MAAa,gBAAgB,gBAA2B;CACtD,MAAM;CACN,MAAM,OAAO,EAAE,QAAQ,aAAa;EAClC,MAAM,EAAE,eAAe,WAAW,UAAU;AAQ5C,SAAO,CACL;GACE,GATS,cAAc,QAAQ;IACjC,MAAM,UAAU,OAAO,KAAK;IAC5B,SAAS;IACT,MAAM;IACN,WAAW,OAAO;IACnB,CAAC;GAKE,SAAS,CACP;IACE,MAAM,UAAU,OAAO,KAAK;IAC5B,cAAc;IACd,aAAa;IACb,OAAO,KAAK,UAAU,OAAO,MAAM;IACpC,CACF;GACD,QAAQ,UAAU;IAChB,KAAK,UAAU,QAAQ;IACvB,QAAQ,OAAO,QAAQ;IACvB,QAAQ,cAAc;IACvB,CAAC;GACF,QAAQ,UAAU;IAAE,KAAK,UAAU,QAAQ;IAAK,QAAQ,OAAO,QAAQ;IAAQ,CAAC;GACjF,CACF;;CAEJ,CAAC"}