@kubb/adapter-oas 5.0.0-beta.25 → 5.0.0-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-beta.25",
+  "version": "5.0.0-beta.26",
   "description": "OpenAPI and Swagger adapter for Kubb. Parses and validates OAS 2.0/3.x specifications into a @kubb/ast RootNode for downstream code generation plugins.",
   "keywords": [
     "adapter",
@@ -43,11 +43,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@redocly/openapi-core": "^2.30.6",
+    "@redocly/openapi-core": "^2.31.2",
     "oas": "^32.1.18",
     "oas-normalize": "^16.0.4",
     "swagger2openapi": "^7.0.8",
-    "@kubb/core": "5.0.0-beta.25"
+    "@kubb/core": "5.0.0-beta.26"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -153,8 +153,8 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
     async parse(source) {
       const streamNode = await createStream(source)
 
-      const collect = async <T>(iter: AsyncIterable<T>): Promise<T[]> => {
-        const out: T[] = []
+      const collect = async <T>(iter: AsyncIterable<T>): Promise<Array<T>> => {
+        const out: Array<T> = []
         for await (const item of iter) out.push(item)
         return out
       }

package/src/discriminator.ts

@@ -14,7 +14,7 @@ export type DiscriminatorTarget = {
  * small pre-parsed subset of schemas (only the discriminator parents) rather than on all
  * schemas at once.
  */
-export function buildDiscriminatorChildMap(schemas: ast.SchemaNode[]): Map<string, DiscriminatorTarget> {
+export function buildDiscriminatorChildMap(schemas: Array<ast.SchemaNode>): Map<string, DiscriminatorTarget> {
   const childMap = new Map<string, DiscriminatorTarget>()
 
   for (const schema of schemas) {

package/src/parser.ts

@@ -770,7 +770,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     }
 
     if (Array.isArray(schema.type) && schema.type.length > 1) {
-      const nonNullTypes = schema.type.filter((t) => t !== 'null') as string[]
+      const nonNullTypes = schema.type.filter((t) => t !== 'null') as Array<string>
       const arrayNullable = schema.type.includes('null') || nullable || undefined
 
       if (nonNullTypes.length > 1) {
@@ -871,10 +871,10 @@ export function createSchemaParser(ctx: OasParserContext) {
    * Collects property names whose schema has a truthy boolean flag (`readOnly` or `writeOnly`).
    * `$ref` entries are skipped since their flags live on the dereferenced target.
    */
-  function collectPropertyKeysByFlag(schema: SchemaObject | null, flag: 'readOnly' | 'writeOnly'): string[] | null {
+  function collectPropertyKeysByFlag(schema: SchemaObject | null, flag: 'readOnly' | 'writeOnly'): Array<string> | null {
     if (!schema?.properties) return null
 
-    const keys: string[] = []
+    const keys: Array<string> = []
     for (const key in schema.properties) {
       const prop = schema.properties[key]
       if (prop && !isReference(prop) && (prop as Record<string, unknown>)[flag]) {

package/src/resolvers.ts

@@ -86,7 +86,7 @@ export type OperationsOptions = {
  * ```
  */
 export function getParameters(document: Document, operation: Operation): Array<ParameterObject> {
-  const resolveParams = (params: unknown[]): Array<ParameterObject> =>
+  const resolveParams = (params: Array<unknown>): Array<ParameterObject> =>
     params.map((p) => dereferenceWithRef(document, p)).filter((p): p is ParameterObject => !!p && typeof p === 'object' && 'in' in p && 'name' in p)
 
   const operationParams = resolveParams(operation.schema?.parameters || [])
@@ -108,7 +108,7 @@ export function getParameters(document: Document, operation: Operation): Array<P
   return Array.from(paramMap.values())
 }
 
-function getResponseBody(responseBody: boolean | ResponseObject, contentType?: string): MediaTypeObject | false | [string, MediaTypeObject, ...string[]] {
+function getResponseBody(responseBody: boolean | ResponseObject, contentType?: string): MediaTypeObject | false | [string, MediaTypeObject, ...Array<string>] {
   if (!responseBody) return false
   if (isReference(responseBody)) return false
 
@@ -260,7 +260,7 @@ function hasStructuralKeywords(fragment: SchemaObject): boolean {
 export function flattenSchema(schema: SchemaObject | null): SchemaObject | null {
   if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null
 
-  const allOfFragments = schema.allOf as SchemaObject[]
+  const allOfFragments = schema.allOf as Array<SchemaObject>
   if (allOfFragments.some((item) => isRef(item))) return schema
   if (allOfFragments.some(hasStructuralKeywords)) return schema
 
@@ -339,13 +339,13 @@ function* collectRefs(schema: unknown): Generator<string, void, undefined> {
  * ```
  */
 export function sortSchemas(schemas: Record<string, SchemaObject>): Record<string, SchemaObject> {
-  const deps = new Map<string, string[]>()
+  const deps = new Map<string, Array<string>>()
 
   for (const [name, schema] of Object.entries(schemas)) {
     deps.set(name, [...new Set(collectRefs(schema))])
   }
 
-  const sorted: string[] = []
+  const sorted: Array<string> = []
   const visited = new Set<string>()
 
   function visit(name: string, stack: Set<string>) {
@@ -402,7 +402,7 @@ function resolveSchemaRef(document: Document, schema: SchemaObject): SchemaObjec
 export function getSchemas(document: Document, { contentType }: GetSchemasOptions): GetSchemasResult {
   const components = document.components
 
-  const candidates: SchemaWithMetadata[] = [
+  const candidates: Array<SchemaWithMetadata> = [
     ...Object.entries((components?.schemas as Record<string, SchemaObject>) ?? {}).map(([name, schema]) => ({
       schema: resolveSchemaRef(document, schema),
       source: 'schemas' as const,
@@ -424,7 +424,7 @@ export function getSchemas(document: Document, { contentType }: GetSchemasOption
     ),
   ]
 
-  const normalizedNames = new Map<string, SchemaWithMetadata[]>()
+  const normalizedNames = new Map<string, Array<SchemaWithMetadata>>()
   for (const item of candidates) {
     const key = pascalCase(item.originalName)
     const bucket = normalizedNames.get(key) ?? []
@@ -529,7 +529,7 @@ export function buildSchemaNode(schema: SchemaObject, name: string | null | unde
  * // ['application/json', 'multipart/form-data']
  * ```
  */
-export function getRequestBodyContentTypes(document: Document, operation: Operation): string[] {
+export function getRequestBodyContentTypes(document: Document, operation: Operation): Array<string> {
   if (operation.schema.requestBody) {
     operation.schema.requestBody = dereferenceWithRef(document, operation.schema.requestBody)
   }

package/src/stream.ts

@@ -8,8 +8,8 @@ import type { AdapterOas, Document, SchemaObject } from './types.ts'
 
 export type PreScanResult = {
   refAliasMap: Map<string, ast.SchemaNode>
-  enumNames: string[]
-  circularNames: string[]
+  enumNames: Array<string>
+  circularNames: Array<string>
   discriminatorChildMap: Map<string, DiscriminatorTarget> | null
 }
 
@@ -74,10 +74,10 @@ export function preScan({
   parserOptions: ast.ParserOptions
   discriminator: AdapterOas['options']['discriminator']
 }): PreScanResult {
-  const allNodes: ast.SchemaNode[] = []
+  const allNodes: Array<ast.SchemaNode> = []
   const refAliasMap = new Map<string, ast.SchemaNode>()
-  const enumNames: string[] = []
-  const discriminatorParentNodes: ast.SchemaNode[] = []
+  const enumNames: Array<string> = []
+  const discriminatorParentNodes: Array<ast.SchemaNode> = []
 
   for (const [name, schema] of Object.entries(schemas)) {
     const node = parseSchema({ schema, name }, parserOptions)