@kubb/plugin-oas 2.18.3 → 2.18.5

package/src/SchemaGenerator.ts

@@ -1,4 +1,4 @@
-import { Generator } from '@kubb/core'
+import { type FileMetaBase, Generator } from '@kubb/core'
 import transformers, { pascalCase } from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
 
@@ -8,12 +8,16 @@ import { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 import { getSchemaFactory } from './utils/getSchemaFactory.ts'
 import { getSchemas } from './utils/getSchemas.ts'
 
-import type { KubbFile, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
+import type { Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+
 import type { Oas, OpenAPIV3, SchemaObject, contentType } from '@kubb/oas'
 import type { Schema, SchemaKeywordMapper } from './SchemaMapper.ts'
 import type { OperationSchema, Override, Refs } from './types.ts'
 
-export type SchemaMethodResult<TFileMeta extends KubbFile.FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
+export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
+
+export type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
 
 type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   oas: Oas
@@ -62,7 +66,7 @@ type SchemaProps = {
 export abstract class SchemaGenerator<
   TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
-  TFileMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase,
+  TFileMeta extends FileMetaBase = FileMetaBase,
 > extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
   // Collect the types of all referenced schemas, so we can export them later
   refs: Refs = {}
@@ -75,7 +79,7 @@ export abstract class SchemaGenerator<
    * Delegates to getBaseTypeFromSchema internally and
    * optionally adds a union with null.
    */
-  buildSchemas(props: SchemaProps): Schema[] {
+  parse(props: SchemaProps): Schema[] {
     const options = this.#getOptions(props)
 
     const defaultSchemas = this.#parseSchemaObject(props)
@@ -84,18 +88,18 @@ export abstract class SchemaGenerator<
     return uniqueWith<Schema>(schemas, isDeepEqual)
   }
 
-  deepSearch<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][] {
-    return SchemaGenerator.deepSearch<T>(schemas, keyword)
+  deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][] {
+    return SchemaGenerator.deepSearch<T>(tree, keyword)
   }
 
-  find<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
-    return SchemaGenerator.find<T>(schemas, keyword)
+  find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
+    return SchemaGenerator.find<T>(tree, keyword)
   }
 
-  static deepSearch<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][] {
+  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][] {
     const foundItems: SchemaKeywordMapper[T][] = []
 
-    schemas?.forEach((schema) => {
+    tree?.forEach((schema) => {
       if (schema.keyword === keyword) {
         foundItems.push(schema as SchemaKeywordMapper[T])
       }
@@ -148,10 +152,10 @@ export abstract class SchemaGenerator<
     return foundItems
   }
 
-  static findInObject<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
+  static findInObject<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
     let foundItem: SchemaKeywordMapper[T] | undefined = undefined
 
-    schemas?.forEach((schema) => {
+    tree?.forEach((schema) => {
       if (!foundItem && schema.keyword === keyword) {
         foundItem = schema as SchemaKeywordMapper[T]
       }
@@ -176,10 +180,10 @@ export abstract class SchemaGenerator<
     return foundItem
   }
 
-  static find<T extends keyof SchemaKeywordMapper>(schemas: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
+  static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
     let foundItem: SchemaKeywordMapper[T] | undefined = undefined
 
-    schemas?.forEach((schema) => {
+    tree?.forEach((schema) => {
       if (!foundItem && schema.keyword === keyword) {
         foundItem = schema as SchemaKeywordMapper[T]
       }
@@ -275,7 +279,7 @@ export abstract class SchemaGenerator<
         const isRequired = Array.isArray(required) ? required?.includes(propertyName) : !!required
         const nullable = propertySchema.nullable ?? propertySchema['x-nullable'] ?? false
 
-        validationFunctions.push(...this.buildSchemas({ schema: propertySchema, name: propertyName, parentName: name }))
+        validationFunctions.push(...this.parse({ schema: propertySchema, name: propertyName, parentName: name }))
 
         validationFunctions.push({
           keyword: schemaKeywords.name,
@@ -299,7 +303,7 @@ export abstract class SchemaGenerator<
       additionalPropertiesSchemas =
         additionalProperties === true
           ? [{ keyword: this.#getUnknownReturn({ schema, name }) }]
-          : this.buildSchemas({ schema: additionalProperties as SchemaObject, parentName: name })
+          : this.parse({ schema: additionalProperties as SchemaObject, parentName: name })
     }
 
     return [
@@ -462,7 +466,7 @@ export abstract class SchemaGenerator<
         keyword: schemaKeywords.union,
         args: schema.oneOf
           .map((item) => {
-            return item && this.buildSchemas({ schema: item as SchemaObject, name, parentName })[0]
+            return item && this.parse({ schema: item as SchemaObject, name, parentName })[0]
           })
           .filter(Boolean)
           .filter((item) => {
@@ -470,7 +474,7 @@ export abstract class SchemaGenerator<
           }),
       }
       if (schemaWithoutOneOf.properties) {
-        return [...this.buildSchemas({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems]
+        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems]
       }
 
       return [union, ...baseItems]
@@ -484,7 +488,7 @@ export abstract class SchemaGenerator<
         keyword: schemaKeywords.union,
         args: schema.anyOf
           .map((item) => {
-            return item && this.buildSchemas({ schema: item as SchemaObject, name, parentName })[0]
+            return item && this.parse({ schema: item as SchemaObject, name, parentName })[0]
           })
           .filter(Boolean)
           .filter((item) => {
@@ -504,7 +508,7 @@ export abstract class SchemaGenerator<
           }),
       }
       if (schemaWithoutAnyOf.properties) {
-        return [...this.buildSchemas({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems]
+        return [...this.parse({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems]
       }
 
       return [union, ...baseItems]
@@ -517,7 +521,7 @@ export abstract class SchemaGenerator<
         keyword: schemaKeywords.and,
         args: schema.allOf
           .map((item) => {
-            return item && this.buildSchemas({ schema: item as SchemaObject, name, parentName })[0]
+            return item && this.parse({ schema: item as SchemaObject, name, parentName })[0]
           })
           .filter(Boolean)
           .filter((item) => {
@@ -529,7 +533,7 @@ export abstract class SchemaGenerator<
         return [
           {
             ...and,
-            args: [...(and.args || []), ...this.buildSchemas({ schema: schemaWithoutAllOf, name, parentName })],
+            args: [...(and.args || []), ...this.parse({ schema: schemaWithoutAllOf, name, parentName })],
           },
           ...baseItems,
         ]
@@ -629,7 +633,7 @@ export abstract class SchemaGenerator<
           keyword: schemaKeywords.tuple,
           args: prefixItems
             .map((item) => {
-              return this.buildSchemas({ schema: item, name, parentName })[0]
+              return this.parse({ schema: item, name, parentName })[0]
             })
             .filter(Boolean),
         },
@@ -746,7 +750,7 @@ export abstract class SchemaGenerator<
     if ('items' in schema || schema.type === ('array' as 'string')) {
       const min = schema.minimum ?? schema.minLength ?? schema.minItems ?? undefined
       const max = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? undefined
-      const items = this.buildSchemas({ schema: 'items' in schema ? (schema.items as SchemaObject) : [], name, parentName })
+      const items = this.parse({ schema: 'items' in schema ? (schema.items as SchemaObject) : [], name, parentName })
 
       return [
         {
@@ -771,7 +775,7 @@ export abstract class SchemaGenerator<
         const [type] = schema.type as Array<OpenAPIV3.NonArraySchemaObjectType>
 
         return [
-          ...this.buildSchemas({
+          ...this.parse({
             schema: {
               ...schema,
               type,
@@ -815,13 +819,4 @@ export abstract class SchemaGenerator<
    * Schema
    */
   abstract schema(name: string, object: SchemaObject): SchemaMethodResult<TFileMeta>
-  /**
-   * Returns the source, in the future it will return a React component
-   */
-  abstract getSource<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>(name: string, schemas: Schema[], options?: TOptions): string[]
-
-  /**
-   * @deprecated only used for testing
-   */
-  abstract buildSource(name: string, object: SchemaObject | undefined, options?: SchemaGeneratorBuildOptions): string[]
 }

package/src/SchemaMapper.ts

@@ -1,4 +1,4 @@
-import type { KubbFile } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
 
 export type SchemaKeywordMapper = {
   object: {

package/src/components/Schema.tsx

@@ -1,39 +1,36 @@
-import { Parser, File, createContext, useApp, useFile } from '@kubb/react'
+import { File, Parser, createContext, useApp, useFile } from '@kubb/react'
 
 import { schemaKeywords } from '../SchemaMapper.ts'
 import { useSchema } from '../hooks/useSchema.ts'
 
-import type { KubbFile } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
 import type { SchemaObject } from '@kubb/oas'
 import type { KubbNode } from '@kubb/react'
 import type { ReactNode } from 'react'
-import type { SchemaGenerator, SchemaGeneratorBuildOptions } from '../SchemaGenerator.ts'
+import { SchemaGenerator } from '../SchemaGenerator.ts'
 import type { Schema as SchemaType } from '../SchemaMapper.ts'
 import type { PluginOas } from '../types.ts'
 
 export type SchemaContextProps = {
   name: string
-  object?: SchemaObject
-  generator?: SchemaGenerator
-  schemas: SchemaType[]
+  schema?: SchemaObject
+  tree: Array<SchemaType>
 }
 
 type Props = {
   name: string
-  object?: SchemaObject
-  generator: SchemaGenerator<any, any, any>
+  value?: SchemaObject
+  tree?: Array<SchemaType>
   children?: KubbNode
 }
 
 const SchemaContext = createContext<SchemaContextProps>({
   name: 'unknown',
-  schemas: [],
+  tree: [],
 })
 
-export function Schema({ name, object, generator, children }: Props): KubbNode {
-  const schemas = generator.buildSchemas({ schema: object, name })
-
-  return <SchemaContext.Provider value={{ name, schemas, object, generator }}>{children}</SchemaContext.Provider>
+export function Schema({ name, value, tree = [], children }: Props): KubbNode {
+  return <SchemaContext.Provider value={{ name, schema: value, tree }}>{children}</SchemaContext.Provider>
 }
 
 type FileProps = {
@@ -66,9 +63,6 @@ Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode
             pluginKey: plugin.key,
           }}
         >
-          <File.Source>
-            <Schema.Source />
-          </File.Source>
           {children}
         </File>
       </Parser>
@@ -99,9 +93,6 @@ Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode
         }}
       >
         <Schema.Imports isTypeOnly={isTypeOnly} />
-        <File.Source>
-          <Schema.Source />
-        </File.Source>
         {children}
       </File>
     </Parser>
@@ -113,10 +104,10 @@ type SchemaImportsProps = {
 }
 
 Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
-  const { generator, schemas } = useSchema()
+  const { tree } = useSchema()
   const { path: root } = useFile()
 
-  const refs = generator.deepSearch(schemas, schemaKeywords.ref)
+  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
 
   return (
     <>
@@ -132,25 +123,4 @@ Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
     </>
   )
 }
-
-type SchemaSourceProps<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions> = {
-  extraSchemas?: SchemaType[]
-  options?: TOptions
-}
-
-Schema.Source = <TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>({
-  options,
-  extraSchemas = [],
-}: SchemaSourceProps<TOptions>): ReactNode => {
-  const { name, generator, schemas } = useSchema()
-
-  const source = generator.getSource(name, [...schemas, ...extraSchemas], options as SchemaGeneratorBuildOptions)
-
-  return (
-    <>
-      {source}
-      <br />
-    </>
-  )
-}
 Schema.Context = SchemaContext

package/src/hooks/useOperationManager.ts

@@ -2,11 +2,12 @@ import { useApp, useContext } from '@kubb/react'
 
 import { Oas } from '../components/Oas.tsx'
 
-import type { KubbFile, Plugin, ResolveNameParams } from '@kubb/core'
+import type { FileMetaBase, Plugin, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
 import type { Operation, Operation as OperationType } from '@kubb/oas'
 import type { OperationSchemas } from '../types.ts'
 
-type FileMeta = KubbFile.FileMetaBase & {
+type FileMeta = FileMetaBase & {
   pluginKey: Plugin['key']
   name: string
   tag?: string

package/src/hooks/useSchema.ts

@@ -3,11 +3,8 @@ import { useContext } from '@kubb/react'
 import { Schema } from '../components/Schema.tsx'
 
 import type { SchemaContextProps } from '../components/Schema.tsx'
-import type { SchemaGenerator } from '../SchemaGenerator.ts'
 
-type UseSchemaResult = Omit<SchemaContextProps, 'generator'> & {
-  generator: SchemaGenerator
-}
+type UseSchemaResult = SchemaContextProps
 
 /**
  * `useSchema` will return the current `schema properties`
@@ -15,9 +12,5 @@ type UseSchemaResult = Omit<SchemaContextProps, 'generator'> & {
 export function useSchema(): UseSchemaResult {
   const props = useContext(Schema.Context)
 
-  if (!props.generator) {
-    throw new Error('Generator is not defined')
-  }
-
   return props as UseSchemaResult
 }

package/src/index.ts

@@ -7,6 +7,7 @@ export type {
 export { OperationGenerator } from './OperationGenerator.ts'
 export { pluginOas, pluginOasName } from './plugin.ts'
 export type {
+  GetSchemaGeneratorOptions,
   SchemaGeneratorBuildOptions,
   SchemaGeneratorOptions,
 } from './SchemaGenerator.ts'

package/src/plugin.ts

@@ -77,12 +77,12 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
     resolveName(name, type) {
       return camelCase(name, { isFile: type === 'file' })
     },
-    async writeFile(source, writePath) {
-      if (!writePath.endsWith('.json') || !source) {
+    async writeFile(path, source) {
+      if (!path.endsWith('.json') || !source) {
         return
       }
 
-      return this.fileManager.write(source, writePath, { sanity: false })
+      return this.fileManager.write(path, source, { sanity: false })
     },
     async buildStart() {
       if (!output) {

package/src/types.ts

@@ -1,5 +1,7 @@
 import type { Plugin } from '@kubb/core'
-import type { KubbFile, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+
 import type { HttpMethod, Oas, Operation, SchemaObject, contentType } from '@kubb/oas'
 import type { FormatOptions } from '@kubb/oas/parser'
 import type { GetSchemasProps } from './utils/getSchemas.ts'

package/src/utils/getGroupedByTagFiles.ts

@@ -1,16 +1,17 @@
 import { resolve } from 'node:path'
 
 import { FileManager } from '@kubb/core'
-import { getRelativePath } from '@kubb/core/fs'
 import transformers from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
+import { getRelativePath } from '@kubb/fs'
 
-import type { KubbFile, Plugin } from '@kubb/core'
+import type { Plugin } from '@kubb/core'
 import type { Logger } from '@kubb/core/logger'
+import type * as KubbFile from '@kubb/fs/types'
 
 type Options = {
   logger: Logger
-  files: KubbFile.File[]
+  files: Array<KubbFile.File<FileMeta>>
   plugin: Plugin
   template: string
   exportAs: string

package/dist/chunk-2MJ2CQMI.js

@@ -1,61 +0,0 @@
-import {
-  init_esm_shims
-} from "./chunk-LQ6IAWRX.js";
-
-// src/SchemaMapper.ts
-init_esm_shims();
-var schemaKeywords = {
-  any: "any",
-  strict: "strict",
-  unknown: "unknown",
-  number: "number",
-  integer: "integer",
-  string: "string",
-  boolean: "boolean",
-  undefined: "undefined",
-  nullable: "nullable",
-  null: "null",
-  nullish: "nullish",
-  array: "array",
-  tuple: "tuple",
-  enum: "enum",
-  union: "union",
-  datetime: "datetime",
-  date: "date",
-  email: "email",
-  uuid: "uuid",
-  url: "url",
-  /* intersection */
-  default: "default",
-  const: "const",
-  and: "and",
-  describe: "describe",
-  min: "min",
-  max: "max",
-  optional: "optional",
-  readOnly: "readOnly",
-  // custom ones
-  object: "object",
-  ref: "ref",
-  matches: "matches",
-  firstName: "firstName",
-  lastName: "lastName",
-  password: "password",
-  phone: "phone",
-  blob: "blob",
-  deprecated: "deprecated",
-  example: "example",
-  schema: "schema",
-  catchall: "catchall",
-  time: "time",
-  name: "name"
-};
-function isKeyword(meta, keyword) {
-  return meta.keyword === keyword;
-}
-
-export {
-  schemaKeywords,
-  isKeyword
-};
-//# sourceMappingURL=chunk-2MJ2CQMI.js.map

package/dist/chunk-2MJ2CQMI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/SchemaMapper.ts"],"sourcesContent":["import type { KubbFile } from '@kubb/core'\n\nexport type SchemaKeywordMapper = {\n  object: {\n    keyword: 'object'\n    args: {\n      properties: { [x: string]: Schema[] }\n      additionalProperties: Schema[]\n      strict?: boolean\n    }\n  }\n  strict: { keyword: 'strict' }\n  url: { keyword: 'url' }\n  readOnly: { keyword: 'readOnly' }\n  uuid: { keyword: 'uuid' }\n  email: { keyword: 'email' }\n  firstName: { keyword: 'firstName' }\n  lastName: { keyword: 'lastName' }\n  phone: { keyword: 'phone' }\n  password: { keyword: 'password' }\n  date: { keyword: 'date'; args: { type?: 'date' | 'string' } }\n  time: { keyword: 'time'; args: { type?: 'date' | 'string' } }\n  datetime: { keyword: 'datetime'; args: { offset?: boolean; local?: boolean } }\n  tuple: { keyword: 'tuple'; args: Schema[] }\n  array: {\n    keyword: 'array'\n    args: { items: Schema[]; min?: number; max?: number }\n  }\n  enum: {\n    keyword: 'enum'\n    args: {\n      name: string\n      typeName: string\n      asConst: boolean\n      items: Array<{\n        name: string | number\n        format: 'string' | 'number'\n        value?: string | number\n      }>\n    }\n  }\n  and: { keyword: 'and'; args: Schema[] }\n  const: {\n    keyword: 'const'\n    args: {\n      name: string | number\n      format: 'string' | 'number'\n      value?: string | number\n    }\n  }\n  union: { keyword: 'union'; args: Schema[] }\n  ref: {\n    keyword: 'ref'\n    args: { name: string; path: KubbFile.OptionalPath; isTypeOnly?: boolean }\n  }\n  matches: { keyword: 'matches'; args?: string }\n  boolean: { keyword: 'boolean' }\n  default: { keyword: 'default'; args: string | number | boolean }\n  string: { keyword: 'string' }\n  integer: { keyword: 'integer' }\n  number: { keyword: 'number' }\n  max: { keyword: 'max'; args: number }\n  min: { keyword: 'min'; args: number }\n  describe: { keyword: 'describe'; args: string }\n  example: { keyword: 'example'; args: string }\n  deprecated: { keyword: 'deprecated' }\n  optional: { keyword: 'optional' }\n  undefined: { keyword: 'undefined' }\n  nullish: { keyword: 'nullish' }\n  nullable: { keyword: 'nullable' }\n  null: { keyword: 'null' }\n  any: { keyword: 'any' }\n  unknown: { keyword: 'unknown' }\n  blob: { keyword: 'blob' }\n  schema: { keyword: 'schema'; args: { type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object'; format?: string } }\n  name: { keyword: 'name'; args: string }\n  catchall: { keyword: 'catchall' }\n}\n\nexport const schemaKeywords = {\n  any: 'any',\n  strict: 'strict',\n  unknown: 'unknown',\n  number: 'number',\n  integer: 'integer',\n  string: 'string',\n  boolean: 'boolean',\n  undefined: 'undefined',\n  nullable: 'nullable',\n  null: 'null',\n  nullish: 'nullish',\n  array: 'array',\n  tuple: 'tuple',\n  enum: 'enum',\n  union: 'union',\n  datetime: 'datetime',\n  date: 'date',\n  email: 'email',\n  uuid: 'uuid',\n  url: 'url',\n  /* intersection */\n  default: 'default',\n  const: 'const',\n  and: 'and',\n  describe: 'describe',\n  min: 'min',\n  max: 'max',\n  optional: 'optional',\n  readOnly: 'readOnly',\n\n  // custom ones\n  object: 'object',\n  ref: 'ref',\n  matches: 'matches',\n  firstName: 'firstName',\n  lastName: 'lastName',\n  password: 'password',\n  phone: 'phone',\n  blob: 'blob',\n  deprecated: 'deprecated',\n  example: 'example',\n  schema: 'schema',\n  catchall: 'catchall',\n  time: 'time',\n  name: 'name',\n} satisfies {\n  [K in keyof SchemaKeywordMapper]: SchemaKeywordMapper[K]['keyword']\n}\n\nexport type SchemaKeyword = keyof SchemaKeywordMapper\n\nexport type SchemaMapper<T = string | null | undefined> = {\n  [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined\n}\n\nexport type SchemaKeywordBase<T> = {\n  keyword: SchemaKeyword\n  args: T\n}\n\nexport type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]\n\nexport function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]> {\n  return meta.keyword === keyword\n}\n"],"mappings":";;;;;AAAA;AA+EO,IAAM,iBAAiB;AAAA,EAC5B,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,WAAW;AAAA,EACX,UAAU;AAAA,EACV,MAAM;AAAA,EACN,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AAAA,EACP,UAAU;AAAA,EACV,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA;AAAA,EAEL,SAAS;AAAA,EACT,OAAO;AAAA,EACP,KAAK;AAAA,EACL,UAAU;AAAA,EACV,KAAK;AAAA,EACL,KAAK;AAAA,EACL,UAAU;AAAA,EACV,UAAU;AAAA;AAAA,EAGV,QAAQ;AAAA,EACR,KAAK;AAAA,EACL,SAAS;AAAA,EACT,WAAW;AAAA,EACX,UAAU;AAAA,EACV,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,MAAM;AAAA,EACN,MAAM;AACR;AAiBO,SAAS,UAAiE,MAAS,SAAwD;AAChJ,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/dist/chunk-3RCQ2LNT.js

@@ -1,81 +0,0 @@
-import {
-  init_esm_shims
-} from "./chunk-LQ6IAWRX.js";
-
-// src/utils/getSchemas.ts
-init_esm_shims();
-function getSchemas({ oas, contentType, includes = ["schemas", "requestBodies", "responses"] }) {
-  const components = oas.getDefinition().components;
-  let schemas = {};
-  if (includes.includes("schemas")) {
-    schemas = {
-      ...schemas,
-      ...components?.schemas || {}
-    };
-  }
-  const requestBodies = components?.requestBodies || {};
-  if (includes.includes("responses")) {
-    const responses = components?.responses || {};
-    Object.entries(responses).forEach(([name, response]) => {
-      if (response.content && !schemas[name]) {
-        const firstContentType = Object.keys(response.content)[0] || "application/json";
-        schemas[name] = response.content?.[contentType || firstContentType]?.schema;
-      }
-    });
-  }
-  if (includes.includes("requestBodies")) {
-    Object.entries(requestBodies).forEach(([name, request]) => {
-      if (request.content && !schemas[name]) {
-        const firstContentType = Object.keys(request.content)[0] || "application/json";
-        schemas[name] = request.content?.[contentType || firstContentType]?.schema;
-      }
-    });
-  }
-  return schemas;
-}
-
-// src/utils/parseFromConfig.ts
-init_esm_shims();
-import { resolve } from "path";
-import { URLPath } from "@kubb/core/utils";
-import { parse } from "@kubb/oas/parser";
-import yaml from "@stoplight/yaml";
-function parseFromConfig(config, options = {}) {
-  if ("data" in config.input) {
-    if (typeof config.input.data === "object") {
-      const api2 = JSON.parse(JSON.stringify(config.input.data));
-      return parse(api2, options);
-    }
-    try {
-      const api2 = yaml.parse(config.input.data);
-      return parse(api2, options);
-    } catch (e) {
-    }
-    const api = JSON.parse(JSON.stringify(config.input.data));
-    return parse(api, options);
-  }
-  if (new URLPath(config.input.path).isURL) {
-    return parse(config.input.path, options);
-  }
-  return parse(resolve(config.root, config.input.path), options);
-}
-
-// src/utils/getSchemaFactory.ts
-init_esm_shims();
-import { isOpenApiV3_1Document } from "@kubb/oas";
-function getSchemaFactory(oas) {
-  return (schema) => {
-    const version = isOpenApiV3_1Document(oas.api) ? "3.1" : "3.0";
-    return {
-      schema,
-      version
-    };
-  };
-}
-
-export {
-  getSchemas,
-  parseFromConfig,
-  getSchemaFactory
-};
-//# sourceMappingURL=chunk-3RCQ2LNT.js.map

package/dist/chunk-3RCQ2LNT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/getSchemas.ts","../src/utils/parseFromConfig.ts","../src/utils/getSchemaFactory.ts"],"sourcesContent":["import type { Oas, OasTypes, contentType } from '@kubb/oas'\n\ntype Mode = 'schemas' | 'responses' | 'requestBodies'\n\nexport type GetSchemasProps = {\n  oas: Oas\n  contentType?: contentType\n  includes?: Mode[]\n}\n\nexport function getSchemas({ oas, contentType, includes = ['schemas', 'requestBodies', 'responses'] }: GetSchemasProps): Record<string, OasTypes.SchemaObject> {\n  const components = oas.getDefinition().components\n\n  let schemas: Record<string, OasTypes.SchemaObject> = {}\n\n  if (includes.includes('schemas')) {\n    schemas = {\n      ...schemas,\n      ...((components?.schemas as Record<string, OasTypes.SchemaObject>) || {}),\n    }\n  }\n\n  const requestBodies = components?.requestBodies || {}\n  if (includes.includes('responses')) {\n    const responses = components?.responses || {}\n\n    Object.entries(responses).forEach(([name, response]: [string, OasTypes.ResponseObject]) => {\n      if (response.content && !schemas[name]) {\n        const firstContentType = Object.keys(response.content)[0] || 'application/json'\n        schemas[name] = response.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  if (includes.includes('requestBodies')) {\n    Object.entries(requestBodies).forEach(([name, request]: [string, OasTypes.RequestBodyObject]) => {\n      if (request.content && !schemas[name]) {\n        const firstContentType = Object.keys(request.content)[0] || 'application/json'\n        schemas[name] = request.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject\n      }\n    })\n  }\n\n  return schemas\n}\n","import { resolve } from 'node:path'\n\nimport { URLPath } from '@kubb/core/utils'\n\nimport { type FormatOptions, parse } from '@kubb/oas/parser'\n\nimport type { Config } from '@kubb/core'\nimport type { Oas, OasTypes } from '@kubb/oas'\nimport yaml from '@stoplight/yaml'\n\nexport function parseFromConfig(config: Config, options: FormatOptions = {}): Promise<Oas> {\n  if ('data' in config.input) {\n    if (typeof config.input.data === 'object') {\n      const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n      return parse(api, options)\n    }\n\n    try {\n      const api: string = yaml.parse(config.input.data as string) as string\n\n      return parse(api, options)\n    } catch (e) {\n      /* empty */\n    }\n\n    const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument\n\n    return parse(api, options)\n  }\n\n  if (new URLPath(config.input.path).isURL) {\n    return parse(config.input.path, options)\n  }\n\n  return parse(resolve(config.root, config.input.path), options)\n}\n","import { isOpenApiV3_1Document } from '@kubb/oas'\n\nimport type { Oas, OpenAPIV3, OpenAPIV3_1, SchemaObject } from '@kubb/oas'\n\n/**\n * Make it possible to narrow down the schema based on a specific version(3 or 3.1)\n */\ntype SchemaResult<TWithRef extends boolean = false> =\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject : OpenAPIV3.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.0'\n    }\n  | {\n      schema?: (TWithRef extends true ? OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject : OpenAPIV3_1.SchemaObject) & {\n        nullable?: boolean\n        'x-nullable'?: boolean\n      }\n      version: '3.1'\n    }\n\nexport function getSchemaFactory<TWithRef extends boolean = false>(oas: Oas): (schema?: SchemaObject) => SchemaResult<TWithRef> {\n  return (schema?: SchemaObject) => {\n    const version = isOpenApiV3_1Document(oas.api) ? '3.1' : '3.0'\n\n    return {\n      schema,\n      version,\n    } as SchemaResult<TWithRef>\n  }\n}\n"],"mappings":";;;;;AAAA;AAUO,SAAS,WAAW,EAAE,KAAK,aAAa,WAAW,CAAC,WAAW,iBAAiB,WAAW,EAAE,GAA2D;AAC7J,QAAM,aAAa,IAAI,cAAc,EAAE;AAEvC,MAAI,UAAiD,CAAC;AAEtD,MAAI,SAAS,SAAS,SAAS,GAAG;AAChC,cAAU;AAAA,MACR,GAAG;AAAA,MACH,GAAK,YAAY,WAAqD,CAAC;AAAA,IACzE;AAAA,EACF;AAEA,QAAM,gBAAgB,YAAY,iBAAiB,CAAC;AACpD,MAAI,SAAS,SAAS,WAAW,GAAG;AAClC,UAAM,YAAY,YAAY,aAAa,CAAC;AAE5C,WAAO,QAAQ,SAAS,EAAE,QAAQ,CAAC,CAAC,MAAM,QAAQ,MAAyC;AACzF,UAAI,SAAS,WAAW,CAAC,QAAQ,IAAI,GAAG;AACtC,cAAM,mBAAmB,OAAO,KAAK,SAAS,OAAO,EAAE,CAAC,KAAK;AAC7D,gBAAQ,IAAI,IAAI,SAAS,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACvE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,MAAI,SAAS,SAAS,eAAe,GAAG;AACtC,WAAO,QAAQ,aAAa,EAAE,QAAQ,CAAC,CAAC,MAAM,OAAO,MAA4C;AAC/F,UAAI,QAAQ,WAAW,CAAC,QAAQ,IAAI,GAAG;AACrC,cAAM,mBAAmB,OAAO,KAAK,QAAQ,OAAO,EAAE,CAAC,KAAK;AAC5D,gBAAQ,IAAI,IAAI,QAAQ,UAAU,eAAe,gBAAgB,GAAG;AAAA,MACtE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;AC5CA;AAAA,SAAS,eAAe;AAExB,SAAS,eAAe;AAExB,SAA6B,aAAa;AAI1C,OAAO,UAAU;AAEV,SAAS,gBAAgB,QAAgB,UAAyB,CAAC,GAAiB;AACzF,MAAI,UAAU,OAAO,OAAO;AAC1B,QAAI,OAAO,OAAO,MAAM,SAAS,UAAU;AACzC,YAAMA,OAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAC9E,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B;AAEA,QAAI;AACF,YAAMA,OAAc,KAAK,MAAM,OAAO,MAAM,IAAc;AAE1D,aAAO,MAAMA,MAAK,OAAO;AAAA,IAC3B,SAAS,GAAG;AAAA,IAEZ;AAEA,UAAM,MAA4B,KAAK,MAAM,KAAK,UAAU,OAAO,MAAM,IAAI,CAAC;AAE9E,WAAO,MAAM,KAAK,OAAO;AAAA,EAC3B;AAEA,MAAI,IAAI,QAAQ,OAAO,MAAM,IAAI,EAAE,OAAO;AACxC,WAAO,MAAM,OAAO,MAAM,MAAM,OAAO;AAAA,EACzC;AAEA,SAAO,MAAM,QAAQ,OAAO,MAAM,OAAO,MAAM,IAAI,GAAG,OAAO;AAC/D;;;ACnCA;AAAA,SAAS,6BAA6B;AAuB/B,SAAS,iBAAmD,KAA6D;AAC9H,SAAO,CAAC,WAA0B;AAChC,UAAM,UAAU,sBAAsB,IAAI,GAAG,IAAI,QAAQ;AAEzD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":["api"]}

package/dist/chunk-55NUFNT6.cjs

@@ -1,68 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// ../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js
-var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js"() {
-    "use strict";
-  }
-});
-
-
-
-
-
-
-
-
-
-exports.__commonJS = __commonJS; exports.__toESM = __toESM; exports.__privateGet = __privateGet; exports.__privateAdd = __privateAdd; exports.__privateSet = __privateSet; exports.__privateMethod = __privateMethod; exports.init_cjs_shims = init_cjs_shims;
-//# sourceMappingURL=chunk-55NUFNT6.cjs.map

package/dist/chunk-55NUFNT6.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.3_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._m3ved7kneisj6uq6vsf2lw6r5q/node_modules/tsup/assets/cjs_shims.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["// Shim globals in cjs bundle\n// There's a weird bug that esbuild will always inject importMetaUrl\n// if we export it as `const importMetaUrl = ... __filename ...`\n// But using a function will not cause this issue\n\nconst getImportMetaUrl = () =>\n  typeof document === 'undefined'\n    ? new URL('file:' + __filename).href\n    : (document.currentScript && document.currentScript.src) ||\n      new URL('main.js', document.baseURI).href\n\nexport const importMetaUrl = /* @__PURE__ */ getImportMetaUrl()\n"]}