@kubb/plugin-oas 2.18.4 → 2.18.6

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-4OLWDMEK.cjs

@@ -1,61 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkBDNSPC5Zcjs = require('./chunk-BDNSPC5Z.cjs');
-
-// src/SchemaMapper.ts
-_chunkBDNSPC5Zcjs.init_cjs_shims.call(void 0, );
-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;
-}
-
-
-
-
-exports.schemaKeywords = schemaKeywords; exports.isKeyword = isKeyword;
-//# sourceMappingURL=chunk-4OLWDMEK.cjs.map

package/dist/chunk-4OLWDMEK.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/SchemaMapper.ts"],"names":[],"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","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"]}

package/dist/chunk-BDNSPC5Z.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../node_modules/.pnpm/tsup@8.0.2_@microsoft+api-extractor@7.43.4_@types+node@20.12.11__postcss@8.4.38_ts-node@10.9._vnyhfq7fulozpuwbvh64t7gkvm/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"]}

package/dist/chunk-BIJSTJCQ.js

@@ -1,61 +0,0 @@
-import {
-  init_esm_shims
-} from "./chunk-UMYKVV7G.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-BIJSTJCQ.js.map

package/dist/chunk-BIJSTJCQ.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-I2JOGJIB.cjs

@@ -1,81 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _chunkBDNSPC5Zcjs = require('./chunk-BDNSPC5Z.cjs');
-
-// src/utils/getSchemas.ts
-_chunkBDNSPC5Zcjs.init_cjs_shims.call(void 0, );
-function getSchemas({ oas, contentType, includes = ["schemas", "requestBodies", "responses"] }) {
-  const components = oas.getDefinition().components;
-  let schemas = {};
-  if (includes.includes("schemas")) {
-    schemas = {
-      ...schemas,
-      ..._optionalChain([components, 'optionalAccess', _ => _.schemas]) || {}
-    };
-  }
-  const requestBodies = _optionalChain([components, 'optionalAccess', _2 => _2.requestBodies]) || {};
-  if (includes.includes("responses")) {
-    const responses = _optionalChain([components, 'optionalAccess', _3 => _3.responses]) || {};
-    Object.entries(responses).forEach(([name, response]) => {
-      if (response.content && !schemas[name]) {
-        const firstContentType = Object.keys(response.content)[0] || "application/json";
-        schemas[name] = _optionalChain([response, 'access', _4 => _4.content, 'optionalAccess', _5 => _5[contentType || firstContentType], 'optionalAccess', _6 => _6.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] = _optionalChain([request, 'access', _7 => _7.content, 'optionalAccess', _8 => _8[contentType || firstContentType], 'optionalAccess', _9 => _9.schema]);
-      }
-    });
-  }
-  return schemas;
-}
-
-// src/utils/parseFromConfig.ts
-_chunkBDNSPC5Zcjs.init_cjs_shims.call(void 0, );
-var _path = require('path');
-var _utils = require('@kubb/core/utils');
-var _parser = require('@kubb/oas/parser');
-var _yaml = require('@stoplight/yaml'); var _yaml2 = _interopRequireDefault(_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 _parser.parse.call(void 0, api2, options);
-    }
-    try {
-      const api2 = _yaml2.default.parse(config.input.data);
-      return _parser.parse.call(void 0, api2, options);
-    } catch (e) {
-    }
-    const api = JSON.parse(JSON.stringify(config.input.data));
-    return _parser.parse.call(void 0, api, options);
-  }
-  if (new (0, _utils.URLPath)(config.input.path).isURL) {
-    return _parser.parse.call(void 0, config.input.path, options);
-  }
-  return _parser.parse.call(void 0, _path.resolve.call(void 0, config.root, config.input.path), options);
-}
-
-// src/utils/getSchemaFactory.ts
-_chunkBDNSPC5Zcjs.init_cjs_shims.call(void 0, );
-var _oas = require('@kubb/oas');
-function getSchemaFactory(oas) {
-  return (schema) => {
-    const version = _oas.isOpenApiV3_1Document.call(void 0, oas.api) ? "3.1" : "3.0";
-    return {
-      schema,
-      version
-    };
-  };
-}
-
-
-
-
-
-exports.getSchemas = getSchemas; exports.parseFromConfig = parseFromConfig; exports.getSchemaFactory = getSchemaFactory;
-//# sourceMappingURL=chunk-I2JOGJIB.cjs.map