@kubb/ast 5.0.0-beta.2 → 5.0.0-beta.20

package/src/visitor.ts

@@ -265,39 +265,47 @@ export type CollectOptions<T> = CollectVisitor<T> & {
  * // returns parameters, requestBody schema (if present), and responses
  * ```
  */
-function getChildren(node: Node, recurse: boolean): Array<Node> {
-  switch (node.kind) {
-    case 'Input':
-      return [...node.schemas, ...node.operations]
-    case 'Output':
-      return []
-    case 'Operation':
-      return [...node.parameters, ...(node.requestBody?.content?.flatMap((c) => (c.schema ? [c.schema] : [])) ?? []), ...node.responses]
-    case 'Schema': {
-      const children: Array<Node> = []
+function* getChildren(node: Node, recurse: boolean): Generator<Node, void, undefined> {
+  if (node.kind === 'Input') {
+    yield* node.schemas
+    yield* node.operations
 
-      if (!recurse) return []
+    return
+  }
+  if (node.kind === 'Output') return
+  if (node.kind === 'Operation') {
+    yield* node.parameters
+    if (node.requestBody?.content) {
+      for (const c of node.requestBody.content) {
+        if (c.schema) yield c.schema
+      }
+    }
+    yield* node.responses
 
-      if ('properties' in node && node.properties.length > 0) children.push(...node.properties)
-      if ('items' in node && node.items) children.push(...node.items)
-      if ('members' in node && node.members) children.push(...node.members)
-      if ('additionalProperties' in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties)
+    return
+  }
+  if (node.kind === 'Schema') {
+    if (!recurse) return
+    if ('properties' in node && node.properties.length > 0) yield* node.properties
+    if ('items' in node && node.items) yield* node.items
+    if ('members' in node && node.members) yield* node.members
+    if ('additionalProperties' in node && node.additionalProperties && node.additionalProperties !== true) yield node.additionalProperties
+
+    return
+  }
+  if (node.kind === 'Property') {
+    yield node.schema
 
-      return children
-    }
-    case 'Property':
-      return [node.schema]
-    case 'Parameter':
-      return [node.schema]
-    case 'Response':
-      return node.schema ? [node.schema] : []
-    case 'FunctionParameter':
-    case 'ParameterGroup':
-    case 'FunctionParameters':
-    case 'Type':
-      return []
-    default:
-      return []
+    return
+  }
+  if (node.kind === 'Parameter') {
+    yield node.schema
+
+    return
+  }
+  if (node.kind === 'Response') {
+    if (node.schema) yield node.schema
+    return
   }
 }
 
@@ -337,11 +345,7 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
       await limit(() => visitor.output?.(node, { parent: parent as ParentOf<OutputNode> }))
       break
     case 'Operation':
-      await limit(() =>
-        visitor.operation?.(node, {
-          parent: parent as ParentOf<OperationNode>,
-        }),
-      )
+      await limit(() => visitor.operation?.(node, { parent: parent as ParentOf<OperationNode> }))
       break
     case 'Schema':
       await limit(() => visitor.schema?.(node, { parent: parent as ParentOf<SchemaNode> }))
@@ -350,19 +354,11 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
       await limit(() => visitor.property?.(node, { parent: parent as ParentOf<PropertyNode> }))
       break
     case 'Parameter':
-      await limit(() =>
-        visitor.parameter?.(node, {
-          parent: parent as ParentOf<ParameterNode>,
-        }),
-      )
+      await limit(() => visitor.parameter?.(node, { parent: parent as ParentOf<ParameterNode> }))
       break
     case 'Response':
       await limit(() => visitor.response?.(node, { parent: parent as ParentOf<ResponseNode> }))
       break
-    case 'FunctionParameter':
-    case 'ParameterGroup':
-    case 'FunctionParameters':
-      break
   }
 
   const children = getChildren(node, recurse)
@@ -404,120 +400,89 @@ export function transform(node: Node, options: TransformOptions): Node {
   const { depth, parent, ...visitor } = options
   const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep
 
-  switch (node.kind) {
-    case 'Input': {
-      let input = node
-      const replaced = visitor.input?.(input, {
-        parent: parent as ParentOf<InputNode>,
-      })
-      if (replaced) input = replaced
+  if (node.kind === 'Input') {
+    const input = visitor.input?.(node, { parent: parent as ParentOf<InputNode> }) ?? node
 
-      return {
-        ...input,
-        schemas: input.schemas.map((s) => transform(s, { ...options, parent: input })),
-        operations: input.operations.map((op) => transform(op, { ...options, parent: input })),
-      }
+    return {
+      ...input,
+      schemas: input.schemas.map((s) => transform(s, { ...options, parent: input })),
+      operations: input.operations.map((op) => transform(op, { ...options, parent: input })),
     }
-    case 'Output': {
-      let output = node
-      const replaced = visitor.output?.(output, {
-        parent: parent as ParentOf<OutputNode>,
-      })
-      if (replaced) output = replaced
+  }
 
-      return output
-    }
-    case 'Operation': {
-      let op = node
-      const replaced = visitor.operation?.(op, {
-        parent: parent as ParentOf<OperationNode>,
-      })
-      if (replaced) op = replaced
-
-      return {
-        ...op,
-        parameters: op.parameters.map((p) => transform(p, { ...options, parent: op })),
-        requestBody: op.requestBody
-          ? {
-              ...op.requestBody,
-              content: op.requestBody.content?.map((c) => ({
-                ...c,
-                schema: c.schema ? transform(c.schema, { ...options, parent: op }) : undefined,
-              })),
-            }
-          : undefined,
-        responses: op.responses.map((r) => transform(r, { ...options, parent: op })),
-      }
-    }
-    case 'Schema': {
-      let schema = node
-      const replaced = visitor.schema?.(schema, {
-        parent: parent as ParentOf<SchemaNode>,
-      })
-      if (replaced) schema = replaced
-
-      const childOptions = { ...options, parent: schema }
-
-      return {
-        ...schema,
-        ...('properties' in schema && recurse
-          ? {
-              properties: schema.properties.map((p) => transform(p, childOptions)),
-            }
-          : {}),
-        ...('items' in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {}),
-        ...('members' in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {}),
-        ...('additionalProperties' in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true
-          ? {
-              additionalProperties: transform(schema.additionalProperties, childOptions),
-            }
-          : {}),
-      } as SchemaNode
-    }
-    case 'Property': {
-      let prop = node
-      const replaced = visitor.property?.(prop, {
-        parent: parent as ParentOf<PropertyNode>,
-      })
-      if (replaced) prop = replaced
+  if (node.kind === 'Output') {
+    return visitor.output?.(node, { parent: parent as ParentOf<OutputNode> }) ?? node
+  }
 
-      return createProperty({
-        ...prop,
-        schema: transform(prop.schema, { ...options, parent: prop }),
-      })
+  if (node.kind === 'Operation') {
+    const op = visitor.operation?.(node, { parent: parent as ParentOf<OperationNode> }) ?? node
+
+    return {
+      ...op,
+      parameters: op.parameters.map((p) => transform(p, { ...options, parent: op })),
+      requestBody: op.requestBody
+        ? {
+            ...op.requestBody,
+            content: op.requestBody.content?.map((c) => ({
+              ...c,
+              schema: c.schema ? transform(c.schema, { ...options, parent: op }) : undefined,
+            })),
+          }
+        : undefined,
+      responses: op.responses.map((r) => transform(r, { ...options, parent: op })),
     }
-    case 'Parameter': {
-      let param = node
-      const replaced = visitor.parameter?.(param, {
-        parent: parent as ParentOf<ParameterNode>,
-      })
-      if (replaced) param = replaced
+  }
 
-      return createParameter({
-        ...param,
-        schema: transform(param.schema, { ...options, parent: param }),
-      })
-    }
-    case 'Response': {
-      let response = node
-      const replaced = visitor.response?.(response, {
-        parent: parent as ParentOf<ResponseNode>,
-      })
-      if (replaced) response = replaced
+  if (node.kind === 'Schema') {
+    const schema = visitor.schema?.(node, { parent: parent as ParentOf<SchemaNode> }) ?? node
+
+    const childOptions = { ...options, parent: schema }
+
+    return {
+      ...schema,
+      ...('properties' in schema && recurse
+        ? {
+            properties: schema.properties.map((p) => transform(p, childOptions)),
+          }
+        : {}),
+      ...('items' in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {}),
+      ...('members' in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {}),
+      ...('additionalProperties' in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true
+        ? {
+            additionalProperties: transform(schema.additionalProperties, childOptions),
+          }
+        : {}),
+    } as SchemaNode
+  }
 
-      return {
-        ...response,
-        schema: transform(response.schema, { ...options, parent: response }),
-      }
+  if (node.kind === 'Property') {
+    const prop = visitor.property?.(node, { parent: parent as ParentOf<PropertyNode> }) ?? node
+
+    return createProperty({
+      ...prop,
+      schema: transform(prop.schema, { ...options, parent: prop }),
+    })
+  }
+
+  if (node.kind === 'Parameter') {
+    const param = visitor.parameter?.(node, { parent: parent as ParentOf<ParameterNode> }) ?? node
+
+    return createParameter({
+      ...param,
+      schema: transform(param.schema, { ...options, parent: param }),
+    })
+  }
+
+  if (node.kind === 'Response') {
+    const response = visitor.response?.(node, { parent: parent as ParentOf<ResponseNode> }) ?? node
+
+    return {
+      ...response,
+      schema: transform(response.schema, { ...options, parent: response }),
     }
-    case 'FunctionParameter':
-    case 'ParameterGroup':
-    case 'FunctionParameters':
-    case 'Type':
-      return node
-    default:
-      return node
   }
+
+  return node
 }
 /**
  * Runs a depth-first synchronous collection pass.
@@ -539,10 +504,9 @@ export function transform(node: Node, options: TransformOptions): Node {
  * const values = collect(root, { depth: 'shallow', root: () => 'root' })
  * ```
  */
-export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
+export function* collectLazy<T>(node: Node, options: CollectOptions<T>): Generator<T, void, undefined> {
   const { depth, parent, ...visitor } = options
   const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep
-  const results: Array<T> = []
 
   let v: T | undefined
   switch (node.kind) {
@@ -553,40 +517,28 @@ export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
       v = visitor.output?.(node, { parent: parent as ParentOf<OutputNode> })
       break
     case 'Operation':
-      v = visitor.operation?.(node, {
-        parent: parent as ParentOf<OperationNode>,
-      })
+      v = visitor.operation?.(node, { parent: parent as ParentOf<OperationNode> })
       break
     case 'Schema':
       v = visitor.schema?.(node, { parent: parent as ParentOf<SchemaNode> })
       break
     case 'Property':
-      v = visitor.property?.(node, {
-        parent: parent as ParentOf<PropertyNode>,
-      })
+      v = visitor.property?.(node, { parent: parent as ParentOf<PropertyNode> })
       break
     case 'Parameter':
-      v = visitor.parameter?.(node, {
-        parent: parent as ParentOf<ParameterNode>,
-      })
+      v = visitor.parameter?.(node, { parent: parent as ParentOf<ParameterNode> })
       break
     case 'Response':
-      v = visitor.response?.(node, {
-        parent: parent as ParentOf<ResponseNode>,
-      })
-      break
-    case 'FunctionParameter':
-    case 'ParameterGroup':
-    case 'FunctionParameters':
+      v = visitor.response?.(node, { parent: parent as ParentOf<ResponseNode> })
       break
   }
-  if (v !== undefined) results.push(v)
+  if (v !== undefined) yield v
 
   for (const child of getChildren(node, recurse)) {
-    for (const item of collect(child, { ...options, parent: node })) {
-      results.push(item)
-    }
+    yield* collectLazy(child, { ...options, parent: node })
   }
+}
 
-  return results
+export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
+  return Array.from(collectLazy(node, options))
 }