@kubb/ast 5.0.0-beta.57 → 5.0.0-beta.58

package/src/index.ts

@@ -1,62 +1,28 @@
 export { httpMethods, schemaTypes } from './constants.ts'
 export { applyDedupe, buildDedupePlan } from './dedupe.ts'
 export { defineSchemaDialect } from './dialect.ts'
-export { createFile, update } from './factory.ts'
+// Node constructors, also published as the `@kubb/ast/factory` subpath, mirroring `ts.factory.createX`.
+export * as factory from './factory.ts'
 export { isHttpOperationNode, narrowSchema } from './guards.ts'
 export { defineNode } from './node.ts'
 export type { NodeDef } from './node.ts'
 export { syncOptionality } from './node.ts'
-export {
-  arrowFunctionDef,
-  breakDef,
-  constDef,
-  createArrowFunction,
-  createBreak,
-  createConst,
-  createFunction,
-  createJsx,
-  createText,
-  createType,
-  functionDef,
-  jsxDef,
-  textDef,
-  typeDef,
-} from './nodes/code.ts'
+export { arrowFunctionDef, breakDef, constDef, functionDef, jsxDef, textDef, typeDef } from './nodes/code.ts'
 export { contentDef } from './nodes/content.ts'
-export { createExport, createImport, createSource, exportDef, fileDef, importDef, sourceDef } from './nodes/file.ts'
-export {
-  createFunctionParameter,
-  createFunctionParameters,
-  createIndexedAccessType,
-  createObjectBindingPattern,
-  createTypeLiteral,
-  functionParameterDef,
-  functionParametersDef,
-  indexedAccessTypeDef,
-  objectBindingPatternDef,
-  typeLiteralDef,
-} from './nodes/function.ts'
-export { createInput, createStreamInput, inputDef } from './nodes/input.ts'
-export { createOperation, operationDef } from './nodes/operation.ts'
-export { createOutput, outputDef } from './nodes/output.ts'
-export { createParameter, parameterDef } from './nodes/parameter.ts'
-export { createProperty, propertyDef } from './nodes/property.ts'
+export { exportDef, fileDef, importDef, sourceDef } from './nodes/file.ts'
+export { functionParameterDef, functionParametersDef, indexedAccessTypeDef, objectBindingPatternDef, typeLiteralDef } from './nodes/function.ts'
+export { inputDef } from './nodes/input.ts'
+export { operationDef } from './nodes/operation.ts'
+export { outputDef } from './nodes/output.ts'
+export { parameterDef } from './nodes/parameter.ts'
+export { propertyDef } from './nodes/property.ts'
 export { requestBodyDef } from './nodes/requestBody.ts'
-export { createResponse, responseDef } from './nodes/response.ts'
-export { createSchema, schemaDef } from './nodes/schema.ts'
+export { responseDef } from './nodes/response.ts'
+export { schemaDef } from './nodes/schema.ts'
 export { createPrinterFactory, definePrinter } from './printer.ts'
 export { signatureOf } from './signature.ts'
 export { mergeAdjacentObjectsLazy, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
 export type * from './types.ts'
-export {
-  caseParams,
-  collectUsedSchemaNames,
-  containsCircularRef,
-  createDiscriminantNode,
-  createOperationParams,
-  extractStringsFromNodes,
-  findCircularSchemas,
-  isStringType,
-  syncSchemaRef,
-} from './utils/ast.ts'
+// The node/AST helpers in ./utils/ast.ts live on the `@kubb/ast/utils` subpath, not the root barrel.
+export { extractStringsFromNodes } from './utils/extractStringsFromNodes.ts'
 export { collect, transform, walk } from './visitor.ts'

package/src/node.ts

@@ -23,7 +23,7 @@ export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omi
 /**
  * Builds a type guard that matches nodes of the given `kind`.
  */
-export function isKind<T extends BaseNode>(kind: NodeKind) {
+function isKind<T extends BaseNode>(kind: NodeKind) {
   return (node: unknown): node is T => (node as BaseNode).kind === kind
 }
 

package/src/nodes/base.ts

@@ -47,13 +47,3 @@ export type BaseNode = {
    */
   kind: NodeKind
 }
-
-/**
- * Minimal node type when only `kind` is needed.
- *
- * @example
- * ```ts
- * const node: Node = { kind: 'Operation' }
- * ```
- */
-export type Node = BaseNode

package/src/nodes/function.ts

@@ -174,9 +174,9 @@ export type FunctionParametersNode = BaseNode & {
 export type FunctionParamNode = FunctionParameterNode | FunctionParametersNode | TypeLiteralNode | IndexedAccessTypeNode | ObjectBindingPatternNode
 
 /**
- * Handler map keys, one per `FunctionParamNode` kind.
+ * Handler-map keys for the function-parameter printer, one per {@link FunctionParamNode} kind.
  */
-export type FunctionNodeType = 'functionParameter' | 'functionParameters' | 'typeLiteral' | 'indexedAccessType' | 'objectBindingPattern'
+export type FunctionParamKind = FunctionParamNode['kind']
 
 /**
  * Definition for the {@link TypeLiteralNode}.

package/src/nodes/index.ts

@@ -16,7 +16,7 @@ export type { ArrowFunctionNode, BreakNode, CodeNode, ConstNode, FunctionNode, J
 export type { ContentNode } from './content.ts'
 export type { ExportNode, FileNode, ImportNode, SourceNode } from './file.ts'
 export type {
-  FunctionNodeType,
+  FunctionParamKind,
   FunctionParameterNode,
   FunctionParametersNode,
   FunctionParamNode,

package/src/nodes/input.ts

@@ -114,26 +114,27 @@ export const inputDef = defineNode<InputNode, Partial<Omit<InputNode, 'kind'>>>(
 })
 
 /**
- * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+ * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+ * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
+ * eager variant with array `schemas`/`operations` and the defaulted `meta`.
  *
- * @example
+ * @example Eager
  * ```ts
  * const input = createInput()
  * // { kind: 'Input', schemas: [], operations: [] }
  * ```
- */
-export function createInput(overrides: Partial<Omit<InputNode, 'kind'>> = {}): InputNode {
-  return inputDef.create(overrides)
-}
-
-/**
- * Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
  *
- * @example
+ * @example Streaming
  * ```ts
- * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
  * ```
  */
-export function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputNode<true> {
-  return { kind: 'Input', schemas, operations, meta }
+export function createInput<Stream extends boolean = false>(options: Partial<Omit<InputNode<Stream>, 'kind'>> & { stream?: Stream } = {}): InputNode<Stream> {
+  const { stream, ...overrides } = options
+  // Streaming inputs carry AsyncIterable sources, so skip the array/meta defaults that
+  // inputDef.create applies for the eager variant.
+  if (stream) {
+    return { kind: 'Input', ...overrides } as InputNode<Stream>
+  }
+  return inputDef.create(overrides as Partial<Omit<InputNode, 'kind'>>) as InputNode<Stream>
 }

package/src/printer.ts

@@ -192,11 +192,11 @@ export function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOp
 
 /**
  * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
- **
+ *
  * @example
  * ```ts
- * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
- *   (node) => kindToHandlerKey[node.kind],
+ * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
+ *   (node) => node.kind,
  * )
  * ```
  */

package/src/types.ts

@@ -13,7 +13,7 @@ export type {
   ExportNode,
   FileNode,
   FunctionNode,
-  FunctionNodeType,
+  FunctionParamKind,
   FunctionParameterNode,
   FunctionParametersNode,
   FunctionParamNode,

package/src/utils/ast.ts

@@ -5,7 +5,6 @@ import { createFunctionParameter, createFunctionParameters, createIndexedAccessT
 import { createProperty } from '../nodes/property.ts'
 import { createSchema } from '../nodes/schema.ts'
 import type {
-  CodeNode,
   ExportNode,
   FunctionParameterNode,
   FunctionParametersNode,
@@ -18,7 +17,7 @@ import type {
   TypeLiteralNode,
 } from '../nodes/index.ts'
 import type { SchemaType } from '../nodes/schema.ts'
-import { extractRefName } from './index.ts'
+import { extractRefName, extractStringsFromNodes, resolveGroupType } from './index.ts'
 import { collect, collectLazy } from '../visitor.ts'
 
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
@@ -120,7 +119,7 @@ export function createDiscriminantNode({ propertyName, value }: { propertyName:
 /**
  * Named type for a group of parameters (query or header) emitted as a single typed parameter.
  */
-type ParamGroupType = {
+export type ParamGroupType = {
   /**
    * Type expression for the group, a plain group-name reference.
    */
@@ -383,7 +382,7 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
 /**
  * Shared arguments for building a query or header parameter group.
  */
-type BuildGroupArgs = {
+export type BuildGroupArgs = {
   name: string
   node: OperationNode
   params: Array<ParameterNode>
@@ -421,35 +420,6 @@ export function buildGroupParam(args: BuildGroupArgs): Array<FunctionParameterNo
   return buildGroupProperty(args).map((p) => createFunctionParameter(p))
 }
 
-/**
- * Derives a {@link ParamGroupType} for a query or header group from the resolver.
- *
- * Returns `null` when there is no resolver, no params, or the group name equals the
- * individual param name (so there is no real group to emit).
- */
-export function resolveGroupType({
-  node,
-  params,
-  group,
-  resolver,
-}: {
-  node: OperationNode
-  params: Array<ParameterNode>
-  group: 'query' | 'header'
-  resolver: OperationParamsResolver | undefined
-}): ParamGroupType | null {
-  if (!resolver || !params.length) {
-    return null
-  }
-  const firstParam = params[0]!
-  const groupMethod = group === 'query' ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName
-  const groupName = groupMethod.call(resolver, node, firstParam)
-  if (groupName === resolver.resolveParamName(node, firstParam)) {
-    return null
-  }
-  return { type: groupName, optional: params.every((p) => !p.required) }
-}
-
 /**
  * Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
  *
@@ -651,39 +621,6 @@ export function combineImports(imports: Array<ImportNode>, exports: Array<Export
   return result
 }
 
-/**
- * Extracts all string content from a `CodeNode` tree recursively.
- *
- * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
- * and nested node content. Used internally to build the full source string for import filtering.
- */
-export function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string {
-  if (!nodes?.length) return ''
-  return nodes
-    .map((node) => {
-      // Backward-compat: compiled plugins may still pass bare strings at runtime
-      if (typeof node === 'string') return node as string
-      if (node.kind === 'Text') return node.value
-      if (node.kind === 'Break') return ''
-      if (node.kind === 'Jsx') return node.value
-
-      const parts: Array<string> = []
-
-      if ('params' in node && node.params) parts.push(node.params)
-      if ('generics' in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(', ') : node.generics)
-      if ('returnType' in node && node.returnType) parts.push(node.returnType)
-      if ('type' in node && typeof node.type === 'string') parts.push(node.type)
-
-      const nested = extractStringsFromNodes(node.nodes)
-
-      if (nested) parts.push(nested)
-
-      return parts.join('\n')
-    })
-    .filter(Boolean)
-    .join('\n')
-}
-
 /**
  * Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
  *

package/src/utils/extractStringsFromNodes.ts

@@ -0,0 +1,34 @@
+import type { CodeNode } from '../nodes/code.ts'
+
+/**
+ * Extracts all string content from a `CodeNode` tree recursively.
+ *
+ * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+ * and nested node content. Used to build the full source string for import filtering.
+ */
+export function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string {
+  if (!nodes?.length) return ''
+  return nodes
+    .map((node) => {
+      // Backward-compat: compiled plugins may still pass bare strings at runtime
+      if (typeof node === 'string') return node as string
+      if (node.kind === 'Text') return node.value
+      if (node.kind === 'Break') return ''
+      if (node.kind === 'Jsx') return node.value
+
+      const parts: Array<string> = []
+
+      if ('params' in node && node.params) parts.push(node.params)
+      if ('generics' in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(', ') : node.generics)
+      if ('returnType' in node && node.returnType) parts.push(node.returnType)
+      if ('type' in node && typeof node.type === 'string') parts.push(node.type)
+
+      const nested = extractStringsFromNodes(node.nodes)
+
+      if (nested) parts.push(nested)
+
+      return parts.join('\n')
+    })
+    .filter(Boolean)
+    .join('\n')
+}

package/src/utils/index.ts

@@ -1,7 +1,22 @@
 import { isIdentifier, pascalCase, singleQuote } from '@internals/utils'
 import { INDENT } from '../constants.ts'
+import type { OperationNode, ParameterNode } from '../nodes/index.ts'
+import type { OperationParamsResolver, ParamGroupType } from './ast.ts'
 
 export { isValidVarName } from '@internals/utils'
+export { extractStringsFromNodes } from './extractStringsFromNodes.ts'
+export {
+  buildGroupParam,
+  buildTypeLiteral,
+  caseParams,
+  collectUsedSchemaNames,
+  containsCircularRef,
+  findCircularSchemas,
+  isStringType,
+  resolveParamType,
+  syncSchemaRef,
+} from './ast.ts'
+export type { BuildGroupArgs, ParamGroupType } from './ast.ts'
 
 /**
  * Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
@@ -295,3 +310,32 @@ export function findDiscriminator(mapping: Record<string, string> | undefined, r
   if (!mapping || !ref) return null
   return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null
 }
+
+/**
+ * Derives a {@link ParamGroupType} for a query or header group from the resolver.
+ *
+ * Returns `null` when there is no resolver, no params, or the group name equals the
+ * individual param name (so there is no real group to emit).
+ */
+export function resolveGroupType({
+  node,
+  params,
+  group,
+  resolver,
+}: {
+  node: OperationNode
+  params: Array<ParameterNode>
+  group: 'query' | 'header'
+  resolver: OperationParamsResolver | undefined
+}): ParamGroupType | null {
+  if (!resolver || !params.length) {
+    return null
+  }
+  const firstParam = params[0]!
+  const groupMethod = group === 'query' ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName
+  const groupName = groupMethod.call(resolver, node, firstParam)
+  if (groupName === resolver.resolveParamName(node, firstParam)) {
+    return null
+  }
+  return { type: groupName, optional: params.every((p) => !p.required) }
+}

package/dist/chunk-C0LytTxp.js

@@ -1,8 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-//#endregion
-export { __name as t };