@kubb/ast 5.0.0-beta.13 → 5.0.0-beta.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.13",
+  "version": "5.0.0-beta.15",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",

package/src/index.ts

@@ -28,7 +28,7 @@ export { isInputNode, isOperationNode, isOutputNode, isSchemaNode, narrowSchema
 export { createPrinterFactory, definePrinter } from './printer.ts'
 export { extractRefName } from './refs.ts'
 export { childName, collectImports, enumPropName, findDiscriminator } from './resolvers.ts'
-export { mergeAdjacentObjects, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
+export { mergeAdjacentObjects, mergeAdjacentObjectsLazy, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
 export type * from './types.ts'
 export {
   caseParams,
@@ -43,4 +43,4 @@ export {
   resolveRefName,
   syncSchemaRef,
 } from './utils.ts'
-export { collect, transform, walk } from './visitor.ts'
+export { collect, collectLazy, transform, walk } from './visitor.ts'

package/src/transformers.ts

@@ -73,25 +73,30 @@ export function setDiscriminatorEnum({
  * ])
  * ```
  */
-export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
-  return members.reduce<Array<SchemaNode>>((acc, member) => {
+export function* mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined> {
+  let acc: SchemaNode | undefined
+
+  for (const member of members) {
     const objectMember = narrowSchema(member, 'object')
-    if (objectMember && !objectMember.name) {
-      const previous = acc.at(-1)
-      const previousObject = previous ? narrowSchema(previous, 'object') : undefined
-
-      if (previousObject && !previousObject.name) {
-        acc[acc.length - 1] = createSchema({
-          ...previousObject,
-          properties: [...(previousObject.properties ?? []), ...(objectMember.properties ?? [])],
+    if (objectMember && !objectMember.name && acc !== undefined) {
+      const accObject = narrowSchema(acc, 'object')
+      if (accObject && !accObject.name) {
+        acc = createSchema({
+          ...accObject,
+          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],
         })
-        return acc
+        continue
       }
     }
+    if (acc !== undefined) yield acc
+    acc = member
+  }
 
-    acc.push(member)
-    return acc
-  }, [])
+  if (acc !== undefined) yield acc
+}
+
+export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
+  return [...mergeAdjacentObjectsLazy(members)]
 }
 
 /**

package/src/utils.ts

@@ -17,7 +17,7 @@ import type {
 } from './nodes/index.ts'
 import type { SchemaType } from './nodes/schema.ts'
 import { extractRefName } from './refs.ts'
-import { collect } from './visitor.ts'
+import { collect, collectLazy } from './visitor.ts'
 
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
 
@@ -775,18 +775,28 @@ export function resolveRefName(node: SchemaNode | undefined): string | undefined
  * }
  * ```
  */
-export function collectReferencedSchemaNames(node: SchemaNode | undefined, out: Set<string> = new Set()): Set<string> {
-  if (!node) return out
+const schemaRefCache = new WeakMap<SchemaNode, ReadonlySet<string>>()
+
+function collectSchemaRefs(node: SchemaNode): ReadonlySet<string> {
+  const cached = schemaRefCache.get(node)
+  if (cached) return cached
+
+  const refs = new Set<string>()
   collect<void>(node, {
     schema(child) {
       if (child.type === 'ref') {
         const name = resolveRefName(child)
-
-        if (name) out.add(name)
+        if (name) refs.add(name)
       }
-      return undefined
     },
   })
+  schemaRefCache.set(node, refs)
+  return refs
+}
+
+export function collectReferencedSchemaNames(node: SchemaNode | undefined, out: Set<string> = new Set()): Set<string> {
+  if (!node) return out
+  for (const name of collectSchemaRefs(node)) out.add(name)
   return out
 }
 
@@ -842,7 +852,7 @@ export function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>,
   }
 
   for (const op of operations) {
-    for (const schema of collect<SchemaNode>(op, { depth: 'shallow', schema: (node) => node })) {
+    for (const schema of collectLazy<SchemaNode>(op, { depth: 'shallow', schema: (node) => node })) {
       visitSchema(schema)
     }
   }
@@ -902,14 +912,15 @@ export function containsCircularRef(
 ): boolean {
   if (!node || circularSchemas.size === 0) return false
 
-  const matches = collect<true>(node, {
+  for (const _ of collectLazy<true>(node, {
     schema(child) {
       if (child.type !== 'ref') return undefined
       const name = resolveRefName(child)
-
       return name && name !== excludeName && circularSchemas.has(name) ? true : undefined
     },
-  })
+  })) {
+    return true
+  }
 
-  return matches.length > 0
+  return false
 }

package/src/visitor.ts

@@ -265,39 +265,40 @@ export type CollectOptions<T> = CollectVisitor<T> & {
  * // returns parameters, requestBody schema (if present), and responses
  * ```
  */
-function getChildren(node: Node, recurse: boolean): Array<Node> {
+function* getChildren(node: Node, recurse: boolean): Generator<Node, void, undefined> {
   switch (node.kind) {
     case 'Input':
-      return [...node.schemas, ...node.operations]
+      yield* node.schemas
+      yield* node.operations
+      break
     case 'Output':
-      return []
+      break
     case 'Operation':
-      return [...node.parameters, ...(node.requestBody?.content?.flatMap((c) => (c.schema ? [c.schema] : [])) ?? []), ...node.responses]
+      yield* node.parameters
+      if (node.requestBody?.content) {
+        for (const c of node.requestBody.content) {
+          if (c.schema) yield c.schema
+        }
+      }
+      yield* node.responses
+      break
     case 'Schema': {
-      const children: Array<Node> = []
-
-      if (!recurse) return []
-
-      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 children
+      if (!recurse) break
+      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
+      break
     }
     case 'Property':
-      return [node.schema]
+      yield node.schema
+      break
     case 'Parameter':
-      return [node.schema]
+      yield node.schema
+      break
     case 'Response':
-      return node.schema ? [node.schema] : []
-    case 'FunctionParameter':
-    case 'ParameterGroup':
-    case 'FunctionParameters':
-    case 'Type':
-      return []
-    default:
-      return []
+      if (node.schema) yield node.schema
+      break
   }
 }
 
@@ -539,10 +540,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) {
@@ -580,13 +580,13 @@ export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
     case 'FunctionParameters':
       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))
 }