@kubb/ast 0.0.0-canary-20260313170904

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026 Stijn Van Hulle
+
+This repository contains software under two licenses:
+
+1. Most of the code in this repository is licensed under the
+   MIT License — see licenses/LICENSE-MIT for the full license text.
+
+2. The following components are licensed under the
+   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
+   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+
+   - packages/agent (published as @kubb/agent)
+
+Each package's own LICENSE file or package.json specifies its applicable license.

package/README.md

@@ -0,0 +1,138 @@
+<div align="center">
+  <h1>@kubb/ast</h1>
+  <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
+    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+  </a>
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Coverage][coverage-src]][coverage-href]
+[![License][license-src]][license-href]
+[![Sponsors][sponsors-src]][sponsors-href]
+
+<h4>
+<a href="https://kubb.dev/" target="_blank">Documentation</a>
+<span> · </span>
+<a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
+<span> · </span>
+<a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
+</h4>
+</div>
+
+Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, factory functions, and type guards used across codegen plugins.
+
+## Imports
+
+| Path | Contents |
+|---|---|
+| `@kubb/ast` | Runtime: factory functions, guards, visitor, ref helpers, constants |
+| `@kubb/ast/types` | Types only: all node interfaces, type aliases, visitor types |
+
+## Node tree
+
+```
+RootNode
+├── schemas: SchemaNode[]
+└── operations: OperationNode[]
+    ├── parameters: ParameterNode[]   → SchemaNode
+    ├── requestBody?: SchemaNode
+    └── responses: ResponseNode[]     → SchemaNode?
+
+SchemaNode (discriminated union)
+  object        → properties: PropertyNode[] → SchemaNode
+  array | tuple → items: SchemaNode[]
+  union | intersection → members: SchemaNode[]
+  enum | ref | string | number | integer | bigint
+  boolean | null | any | unknown | void
+  date | datetime | time | uuid | email | url | blob
+```
+
+## Usage
+
+### Factory
+
+```ts
+import { createRoot, createOperation, createSchema, createProperty } from '@kubb/ast'
+
+const root = createRoot({
+  schemas: [
+    createSchema({
+      name: 'Pet',
+      type: 'object',
+      properties: [
+        createProperty({ name: 'id', schema: createSchema({ type: 'integer' }), required: true }),
+        createProperty({ name: 'name', schema: createSchema({ type: 'string' }), required: true }),
+      ],
+    }),
+  ],
+})
+```
+
+### Visitor
+
+```ts
+import { walk, transform, collect } from '@kubb/ast'
+
+// Side effects
+await walk(root, {
+  schema(node) { console.log(node.type) },
+})
+
+// Immutable transformation
+const updated = transform(root, {
+  schema(node) { return { ...node, description: 'generated' } },
+})
+
+// Extraction
+const types = collect<string>(root, {
+  schema(node) { return node.type },
+})
+```
+
+### Guards
+
+```ts
+import { isSchemaNode, narrowSchema } from '@kubb/ast'
+import type { Node } from '@kubb/ast/types'
+
+function process(node: Node) {
+  if (isSchemaNode(node)) {
+    const obj = narrowSchema(node, 'object')
+    obj?.properties?.forEach(p => console.log(p.name))
+  }
+}
+```
+
+### Refs
+
+```ts
+import { buildRefMap, resolveRef } from '@kubb/ast'
+
+const refMap = buildRefMap(root)
+const pet = resolveRef(refMap, 'Pet')
+```
+
+## Supporting Kubb
+
+Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+
+- [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+
+<p align="center">
+  <a href="https://github.com/sponsors/stijnvanhulle">
+    <img src="https://raw.githubusercontent.com/stijnvanhulle/sponsors/main/sponsors.svg" alt="My sponsors" />
+  </a>
+</p>
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@kubb/ast?flat&colorA=18181B&colorB=f58517
+[npm-version-href]: https://npmjs.com/package/@kubb/ast
+[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/ast?flat&colorA=18181B&colorB=f58517
+[npm-downloads-href]: https://npmjs.com/package/@kubb/ast
+[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
+[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
+[coverage-href]: https://www.npmjs.com/package/@kubb/ast
+[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
+[sponsors-href]: https://github.com/sponsors/stijnvanhulle/

package/dist/chunk--u3MIqq1.js

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

package/dist/index.cjs

@@ -0,0 +1,366 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+Object.defineProperty;
+//#endregion
+//#region src/constants.ts
+const visitorDepths = {
+	shallow: "shallow",
+	deep: "deep"
+};
+const nodeKinds = {
+	root: "Root",
+	operation: "Operation",
+	schema: "Schema",
+	property: "Property",
+	parameter: "Parameter",
+	response: "Response"
+};
+const schemaTypes = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	object: "object",
+	array: "array",
+	tuple: "tuple",
+	union: "union",
+	intersection: "intersection",
+	enum: "enum",
+	ref: "ref",
+	date: "date",
+	datetime: "datetime",
+	time: "time",
+	uuid: "uuid",
+	email: "email",
+	url: "url",
+	blob: "blob"
+};
+const httpMethods = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE",
+	head: "HEAD",
+	options: "OPTIONS",
+	trace: "TRACE"
+};
+const mediaTypes = {
+	applicationJson: "application/json",
+	applicationXml: "application/xml",
+	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
+	applicationOctetStream: "application/octet-stream",
+	applicationPdf: "application/pdf",
+	applicationZip: "application/zip",
+	applicationGraphql: "application/graphql",
+	multipartFormData: "multipart/form-data",
+	textPlain: "text/plain",
+	textHtml: "text/html",
+	textCsv: "text/csv",
+	textXml: "text/xml",
+	imagePng: "image/png",
+	imageJpeg: "image/jpeg",
+	imageGif: "image/gif",
+	imageWebp: "image/webp",
+	imageSvgXml: "image/svg+xml",
+	audioMpeg: "audio/mpeg",
+	videoMp4: "video/mp4"
+};
+//#endregion
+//#region src/factory.ts
+/**
+* Creates a `RootNode`.
+*/
+function createRoot(overrides = {}) {
+	return {
+		schemas: [],
+		operations: [],
+		...overrides,
+		kind: "Root"
+	};
+}
+/**
+* Creates an `OperationNode`.
+*/
+function createOperation(props) {
+	return {
+		tags: [],
+		parameters: [],
+		responses: [],
+		...props,
+		kind: "Operation"
+	};
+}
+/**
+* Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+*/
+function createSchema(props) {
+	return {
+		...props,
+		kind: "Schema"
+	};
+}
+/**
+* Creates a `PropertyNode`. `required` defaults to `false`.
+*/
+function createProperty(props) {
+	return {
+		required: false,
+		...props,
+		kind: "Property"
+	};
+}
+/**
+* Creates a `ParameterNode`. `required` defaults to `false`.
+*/
+function createParameter(props) {
+	return {
+		required: false,
+		...props,
+		kind: "Parameter"
+	};
+}
+/**
+* Creates a `ResponseNode`.
+*/
+function createResponse(props) {
+	return {
+		...props,
+		kind: "Response"
+	};
+}
+//#endregion
+//#region src/guards.ts
+/**
+* Narrows a `SchemaNode` to the specific variant matching `type`.
+*/
+function narrowSchema(node, type) {
+	return node?.type === type ? node : void 0;
+}
+function isKind(kind) {
+	return (node) => node.kind === kind;
+}
+/**
+* Type guard for `RootNode`.
+*/
+const isRootNode = isKind("Root");
+/**
+* Type guard for `OperationNode`.
+*/
+const isOperationNode = isKind("Operation");
+/**
+* Type guard for `SchemaNode`.
+*/
+const isSchemaNode = isKind("Schema");
+/**
+* Type guard for `PropertyNode`.
+*/
+const isPropertyNode = isKind("Property");
+/**
+* Type guard for `ParameterNode`.
+*/
+const isParameterNode = isKind("Parameter");
+/**
+* Type guard for `ResponseNode`.
+*/
+const isResponseNode = isKind("Response");
+//#endregion
+//#region src/refs.ts
+/**
+* Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
+*/
+function buildRefMap(root) {
+	const map = /* @__PURE__ */ new Map();
+	for (const schema of root.schemas) if (schema.name) map.set(schema.name, schema);
+	return map;
+}
+/**
+* Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
+*/
+function resolveRef(refMap, ref) {
+	return refMap.get(ref);
+}
+/**
+* Converts a `RefMap` to a plain object.
+*/
+function refMapToObject(refMap) {
+	return Object.fromEntries(refMap);
+}
+//#endregion
+//#region src/visitor.ts
+/**
+* Traversable children of `node`, respecting `recurse` for schema nodes.
+*/
+function getChildren(node, recurse) {
+	switch (node.kind) {
+		case "Root": return [...node.schemas, ...node.operations];
+		case "Operation": return [
+			...node.parameters,
+			...node.requestBody ? [node.requestBody] : [],
+			...node.responses
+		];
+		case "Schema": {
+			const children = [];
+			if (!recurse) return [];
+			if ("properties" in node && node.properties) children.push(...node.properties);
+			if ("items" in node && node.items) children.push(...node.items);
+			if ("members" in node && node.members) children.push(...node.members);
+			return children;
+		}
+		case "Property": return [node.schema];
+		case "Parameter": return [node.schema];
+		case "Response": return node.schema ? [node.schema] : [];
+	}
+}
+/**
+* Depth-first traversal for side effects. Visitor return values are ignored.
+*/
+async function walk(node, visitor, options = {}) {
+	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+	switch (node.kind) {
+		case "Root":
+			await visitor.root?.(node);
+			break;
+		case "Operation":
+			await visitor.operation?.(node);
+			break;
+		case "Schema":
+			await visitor.schema?.(node);
+			break;
+		case "Property":
+			await visitor.property?.(node);
+			break;
+		case "Parameter":
+			await visitor.parameter?.(node);
+			break;
+		case "Response":
+			await visitor.response?.(node);
+			break;
+	}
+	for (const child of getChildren(node, recurse)) await walk(child, visitor, options);
+}
+function transform(node, visitor, options = {}) {
+	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+	switch (node.kind) {
+		case "Root": {
+			let root = node;
+			const replaced = visitor.root?.(root);
+			if (replaced) root = replaced;
+			return {
+				...root,
+				schemas: root.schemas.map((s) => transform(s, visitor, options)),
+				operations: root.operations.map((op) => transform(op, visitor, options))
+			};
+		}
+		case "Operation": {
+			let op = node;
+			const replaced = visitor.operation?.(op);
+			if (replaced) op = replaced;
+			return {
+				...op,
+				parameters: op.parameters.map((p) => transform(p, visitor, options)),
+				requestBody: op.requestBody ? transform(op.requestBody, visitor, options) : void 0,
+				responses: op.responses.map((r) => transform(r, visitor, options))
+			};
+		}
+		case "Schema": {
+			let schema = node;
+			const replaced = visitor.schema?.(schema);
+			if (replaced) schema = replaced;
+			return {
+				...schema,
+				..."properties" in schema && recurse ? { properties: schema.properties?.map((p) => transform(p, visitor, options)) } : {},
+				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {},
+				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {}
+			};
+		}
+		case "Property": {
+			let prop = node;
+			const replaced = visitor.property?.(prop);
+			if (replaced) prop = replaced;
+			return {
+				...prop,
+				schema: transform(prop.schema, visitor, options)
+			};
+		}
+		case "Parameter": {
+			let param = node;
+			const replaced = visitor.parameter?.(param);
+			if (replaced) param = replaced;
+			return {
+				...param,
+				schema: transform(param.schema, visitor, options)
+			};
+		}
+		case "Response": {
+			let response = node;
+			const replaced = visitor.response?.(response);
+			if (replaced) response = replaced;
+			return {
+				...response,
+				schema: response.schema ? transform(response.schema, visitor, options) : void 0
+			};
+		}
+	}
+}
+/**
+* Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
+*/
+function collect(node, visitor, options = {}) {
+	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const results = [];
+	let v;
+	switch (node.kind) {
+		case "Root":
+			v = visitor.root?.(node);
+			break;
+		case "Operation":
+			v = visitor.operation?.(node);
+			break;
+		case "Schema":
+			v = visitor.schema?.(node);
+			break;
+		case "Property":
+			v = visitor.property?.(node);
+			break;
+		case "Parameter":
+			v = visitor.parameter?.(node);
+			break;
+		case "Response":
+			v = visitor.response?.(node);
+			break;
+	}
+	if (v !== void 0) results.push(v);
+	for (const child of getChildren(node, recurse)) for (const item of collect(child, visitor, options)) results.push(item);
+	return results;
+}
+//#endregion
+exports.buildRefMap = buildRefMap;
+exports.collect = collect;
+exports.createOperation = createOperation;
+exports.createParameter = createParameter;
+exports.createProperty = createProperty;
+exports.createResponse = createResponse;
+exports.createRoot = createRoot;
+exports.createSchema = createSchema;
+exports.httpMethods = httpMethods;
+exports.isOperationNode = isOperationNode;
+exports.isParameterNode = isParameterNode;
+exports.isPropertyNode = isPropertyNode;
+exports.isResponseNode = isResponseNode;
+exports.isRootNode = isRootNode;
+exports.isSchemaNode = isSchemaNode;
+exports.mediaTypes = mediaTypes;
+exports.narrowSchema = narrowSchema;
+exports.nodeKinds = nodeKinds;
+exports.refMapToObject = refMapToObject;
+exports.resolveRef = resolveRef;
+exports.schemaTypes = schemaTypes;
+exports.transform = transform;
+exports.walk = walk;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/constants.ts","../src/factory.ts","../src/guards.ts","../src/refs.ts","../src/visitor.ts"],"sourcesContent":["import type { NodeKind } from './nodes/base.ts'\nimport type { MediaType } from './nodes/http.ts'\nimport type { HttpMethod } from './nodes/operation.ts'\nimport type { ParameterLocation } from './nodes/parameter.ts'\nimport type { SchemaType } from './nodes/schema.ts'\n\n/**\n * Depth for schema traversal in visitor functions.\n */\nexport type VisitorDepth = 'shallow' | 'deep'\n\nexport const visitorDepths = {\n  shallow: 'shallow',\n  deep: 'deep',\n} as const satisfies Record<VisitorDepth, VisitorDepth>\n\nexport const nodeKinds = {\n  root: 'Root',\n  operation: 'Operation',\n  schema: 'Schema',\n  property: 'Property',\n  parameter: 'Parameter',\n  response: 'Response',\n} as const satisfies Record<Lowercase<NodeKind>, NodeKind>\n\nexport const schemaTypes = {\n  string: 'string',\n  /**\n   * Floating-point number (`float`, `double`).\n   */\n  number: 'number',\n  /**\n   * Whole number (`int32`). Use `bigint` for `int64`.\n   */\n  integer: 'integer',\n  /**\n   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.\n   */\n  bigint: 'bigint',\n  boolean: 'boolean',\n  null: 'null',\n  any: 'any',\n  unknown: 'unknown',\n  void: 'void',\n  object: 'object',\n  array: 'array',\n  tuple: 'tuple',\n  union: 'union',\n  intersection: 'intersection',\n  enum: 'enum',\n  ref: 'ref',\n  date: 'date',\n  datetime: 'datetime',\n  time: 'time',\n  uuid: 'uuid',\n  email: 'email',\n  url: 'url',\n  blob: 'blob',\n} as const satisfies Record<SchemaType, SchemaType>\n\nexport const httpMethods = {\n  get: 'GET',\n  post: 'POST',\n  put: 'PUT',\n  patch: 'PATCH',\n  delete: 'DELETE',\n  head: 'HEAD',\n  options: 'OPTIONS',\n  trace: 'TRACE',\n} as const satisfies Record<Lowercase<HttpMethod>, HttpMethod>\n\nexport const parameterLocations = {\n  path: 'path',\n  query: 'query',\n  header: 'header',\n  cookie: 'cookie',\n} as const satisfies Record<ParameterLocation, ParameterLocation>\n\n/**\n * Fallback status code string for API spec responses.\n */\nexport const DEFAULT_STATUS_CODE = 'default' as const\n\nexport const mediaTypes = {\n  applicationJson: 'application/json',\n  applicationXml: 'application/xml',\n  applicationFormUrlEncoded: 'application/x-www-form-urlencoded',\n  applicationOctetStream: 'application/octet-stream',\n  applicationPdf: 'application/pdf',\n  applicationZip: 'application/zip',\n  applicationGraphql: 'application/graphql',\n  multipartFormData: 'multipart/form-data',\n  textPlain: 'text/plain',\n  textHtml: 'text/html',\n  textCsv: 'text/csv',\n  textXml: 'text/xml',\n  imagePng: 'image/png',\n  imageJpeg: 'image/jpeg',\n  imageGif: 'image/gif',\n  imageWebp: 'image/webp',\n  imageSvgXml: 'image/svg+xml',\n  audioMpeg: 'audio/mpeg',\n  videoMp4: 'video/mp4',\n} as const satisfies Record<string, MediaType>\n","import type { OperationNode, ParameterNode, PropertyNode, ResponseNode, RootNode, SchemaNode } from './nodes/index.ts'\n\n/**\n * Distributive variant of `Omit` that preserves union members.\n */\nexport type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never\n\n/**\n * Creates a `RootNode`.\n */\nexport function createRoot(overrides: Partial<Omit<RootNode, 'kind'>> = {}): RootNode {\n  return {\n    schemas: [],\n    operations: [],\n    ...overrides,\n    kind: 'Root',\n  }\n}\n\n/**\n * Creates an `OperationNode`.\n */\nexport function createOperation(\n  props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>,\n): OperationNode {\n  return {\n    tags: [],\n    parameters: [],\n    responses: [],\n    ...props,\n    kind: 'Operation',\n  }\n}\n\n/**\n * Creates a `SchemaNode`, narrowed to the variant of `props.type`.\n */\nexport function createSchema<T extends DistributiveOmit<SchemaNode, 'kind'>>(props: T): T & { kind: 'Schema' } {\n  return { ...props, kind: 'Schema' } as T & { kind: 'Schema' }\n}\n\n/**\n * Creates a `PropertyNode`. `required` defaults to `false`.\n */\nexport function createProperty(props: Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>): PropertyNode {\n  return {\n    required: false,\n    ...props,\n    kind: 'Property',\n  }\n}\n\n/**\n * Creates a `ParameterNode`. `required` defaults to `false`.\n */\nexport function createParameter(\n  props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>,\n): ParameterNode {\n  return {\n    required: false,\n    ...props,\n    kind: 'Parameter',\n  }\n}\n\n/**\n * Creates a `ResponseNode`.\n */\nexport function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode'>>): ResponseNode {\n  return {\n    ...props,\n    kind: 'Response',\n  }\n}\n","import type { Node, NodeKind, OperationNode, ParameterNode, PropertyNode, ResponseNode, RootNode, SchemaNode, SchemaNodeByType } from './nodes/index.ts'\n\n/**\n * Narrows a `SchemaNode` to the specific variant matching `type`.\n */\nexport function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined {\n  return node?.type === type ? (node as SchemaNodeByType[T]) : undefined\n}\n\nfunction isKind<T extends Node>(kind: NodeKind) {\n  return (node: Node): node is T => node.kind === kind\n}\n\n/**\n * Type guard for `RootNode`.\n */\nexport const isRootNode = isKind<RootNode>('Root')\n\n/**\n * Type guard for `OperationNode`.\n */\nexport const isOperationNode = isKind<OperationNode>('Operation')\n\n/**\n * Type guard for `SchemaNode`.\n */\nexport const isSchemaNode = isKind<SchemaNode>('Schema')\n\n/**\n * Type guard for `PropertyNode`.\n */\nexport const isPropertyNode = isKind<PropertyNode>('Property')\n\n/**\n * Type guard for `ParameterNode`.\n */\nexport const isParameterNode = isKind<ParameterNode>('Parameter')\n\n/**\n * Type guard for `ResponseNode`.\n */\nexport const isResponseNode = isKind<ResponseNode>('Response')\n","import type { RootNode } from './nodes/root.ts'\nimport type { SchemaNode } from './nodes/schema.ts'\n\n/**\n * Schema name to `SchemaNode` mapping.\n */\nexport type RefMap = Map<string, SchemaNode>\n\n/**\n * Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.\n */\nexport function buildRefMap(root: RootNode): RefMap {\n  const map: RefMap = new Map()\n\n  for (const schema of root.schemas) {\n    if (schema.name) {\n      map.set(schema.name, schema)\n    }\n  }\n  return map\n}\n\n/**\n * Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.\n */\nexport function resolveRef(refMap: RefMap, ref: string): SchemaNode | undefined {\n  return refMap.get(ref)\n}\n\n/**\n * Converts a `RefMap` to a plain object.\n */\nexport function refMapToObject(refMap: RefMap): Record<string, SchemaNode> {\n  return Object.fromEntries(refMap)\n}\n","import type { VisitorDepth } from './constants.ts'\nimport { visitorDepths } from './constants.ts'\nimport type { Node, OperationNode, ParameterNode, PropertyNode, ResponseNode, RootNode, SchemaNode } from './nodes/index.ts'\n\n/**\n * Shared options for `walk`, `transform`, and `collect`.\n */\nexport type VisitorOptions = {\n  depth?: VisitorDepth\n}\n\n/**\n * Synchronous visitor for `transform` and `walk`.\n */\nexport interface Visitor {\n  root?(node: RootNode): void | RootNode\n  operation?(node: OperationNode): void | OperationNode\n  schema?(node: SchemaNode): void | SchemaNode\n  property?(node: PropertyNode): void | PropertyNode\n  parameter?(node: ParameterNode): void | ParameterNode\n  response?(node: ResponseNode): void | ResponseNode\n}\n\ntype MaybePromise<T> = T | Promise<T>\n\n/**\n * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.\n */\nexport interface AsyncVisitor {\n  root?(node: RootNode): MaybePromise<void | RootNode>\n  operation?(node: OperationNode): MaybePromise<void | OperationNode>\n  schema?(node: SchemaNode): MaybePromise<void | SchemaNode>\n  property?(node: PropertyNode): MaybePromise<void | PropertyNode>\n  parameter?(node: ParameterNode): MaybePromise<void | ParameterNode>\n  response?(node: ResponseNode): MaybePromise<void | ResponseNode>\n}\n\n/**\n * Visitor for `collect`.\n */\nexport interface CollectVisitor<T> {\n  root?(node: RootNode): T | undefined\n  operation?(node: OperationNode): T | undefined\n  schema?(node: SchemaNode): T | undefined\n  property?(node: PropertyNode): T | undefined\n  parameter?(node: ParameterNode): T | undefined\n  response?(node: ResponseNode): T | undefined\n}\n\n/**\n * Traversable children of `node`, respecting `recurse` for schema nodes.\n */\nfunction getChildren(node: Node, recurse: boolean): Array<Node> {\n  switch (node.kind) {\n    case 'Root':\n      return [...node.schemas, ...node.operations]\n    case 'Operation':\n      return [...node.parameters, ...(node.requestBody ? [node.requestBody] : []), ...node.responses]\n    case 'Schema': {\n      const children: Array<Node> = []\n\n      if (!recurse) return []\n\n      if ('properties' in node && node.properties) children.push(...node.properties)\n      if ('items' in node && node.items) children.push(...node.items)\n      if ('members' in node && node.members) children.push(...node.members)\n\n      return children\n    }\n    case 'Property':\n      return [node.schema]\n    case 'Parameter':\n      return [node.schema]\n    case 'Response':\n      return node.schema ? [node.schema] : []\n  }\n}\n\n/**\n * Depth-first traversal for side effects. Visitor return values are ignored.\n */\nexport async function walk(node: Node, visitor: AsyncVisitor, options: VisitorOptions = {}): Promise<void> {\n  const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep\n\n  switch (node.kind) {\n    case 'Root':\n      await visitor.root?.(node)\n      break\n    case 'Operation':\n      await visitor.operation?.(node)\n      break\n    case 'Schema':\n      await visitor.schema?.(node)\n      break\n    case 'Property':\n      await visitor.property?.(node)\n      break\n    case 'Parameter':\n      await visitor.parameter?.(node)\n      break\n    case 'Response':\n      await visitor.response?.(node)\n      break\n  }\n\n  for (const child of getChildren(node, recurse)) {\n    await walk(child, visitor, options)\n  }\n}\n\n/**\n * Depth-first immutable transformation. Visitor return values replace nodes; `undefined` keeps the original.\n */\nexport function transform(node: RootNode, visitor: Visitor, options?: VisitorOptions): RootNode\nexport function transform(node: OperationNode, visitor: Visitor, options?: VisitorOptions): OperationNode\nexport function transform(node: SchemaNode, visitor: Visitor, options?: VisitorOptions): SchemaNode\nexport function transform(node: PropertyNode, visitor: Visitor, options?: VisitorOptions): PropertyNode\nexport function transform(node: ParameterNode, visitor: Visitor, options?: VisitorOptions): ParameterNode\nexport function transform(node: ResponseNode, visitor: Visitor, options?: VisitorOptions): ResponseNode\nexport function transform(node: Node, visitor: Visitor, options?: VisitorOptions): Node\nexport function transform(node: Node, visitor: Visitor, options: VisitorOptions = {}): Node {\n  const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep\n\n  switch (node.kind) {\n    case 'Root': {\n      let root = node\n      const replaced = visitor.root?.(root)\n      if (replaced) root = replaced\n\n      return {\n        ...root,\n        schemas: root.schemas.map((s) => transform(s, visitor, options)),\n        operations: root.operations.map((op) => transform(op, visitor, options)),\n      }\n    }\n    case 'Operation': {\n      let op = node\n      const replaced = visitor.operation?.(op)\n      if (replaced) op = replaced\n\n      return {\n        ...op,\n        parameters: op.parameters.map((p) => transform(p, visitor, options)),\n        requestBody: op.requestBody ? transform(op.requestBody, visitor, options) : undefined,\n        responses: op.responses.map((r) => transform(r, visitor, options)),\n      }\n    }\n    case 'Schema': {\n      let schema = node\n      const replaced = visitor.schema?.(schema)\n      if (replaced) schema = replaced\n\n      return {\n        ...schema,\n        ...('properties' in schema && recurse ? { properties: schema.properties?.map((p) => transform(p, visitor, options)) } : {}),\n        ...('items' in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {}),\n        ...('members' in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {}),\n      }\n    }\n    case 'Property': {\n      let prop = node\n      const replaced = visitor.property?.(prop)\n      if (replaced) prop = replaced\n\n      return {\n        ...prop,\n        schema: transform(prop.schema, visitor, options),\n      }\n    }\n    case 'Parameter': {\n      let param = node\n      const replaced = visitor.parameter?.(param)\n      if (replaced) param = replaced\n\n      return {\n        ...param,\n        schema: transform(param.schema, visitor, options),\n      }\n    }\n    case 'Response': {\n      let response = node\n      const replaced = visitor.response?.(response)\n      if (replaced) response = replaced\n\n      return {\n        ...response,\n        schema: response.schema ? transform(response.schema, visitor, options) : undefined,\n      }\n    }\n  }\n}\n\n/**\n * Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.\n */\nexport function collect<T>(node: Node, visitor: CollectVisitor<T>, options: VisitorOptions = {}): Array<T> {\n  const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep\n  const results: Array<T> = []\n\n  let v: T | undefined\n  switch (node.kind) {\n    case 'Root':\n      v = visitor.root?.(node)\n      break\n    case 'Operation':\n      v = visitor.operation?.(node)\n      break\n    case 'Schema':\n      v = visitor.schema?.(node)\n      break\n    case 'Property':\n      v = visitor.property?.(node)\n      break\n    case 'Parameter':\n      v = visitor.parameter?.(node)\n      break\n    case 'Response':\n      v = visitor.response?.(node)\n      break\n  }\n  if (v !== undefined) results.push(v)\n\n  for (const child of getChildren(node, recurse)) {\n    for (const item of collect(child, visitor, options)) {\n      results.push(item)\n    }\n  }\n\n  return results\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { $ as httpMethods, C as ResponseNode, H as SchemaNode, O as ParameterNode, S as OperationNode, U as SchemaNodeByType, Y as PropertyNode, _ as createRoot, a as collect, b as RootNode, d as resolveRef, et as mediaTypes, g as createResponse, h as createProperty, l as buildRefMap, m as createParameter, nt as schemaTypes, o as transform, p as createOperation, s as walk, tt as nodeKinds, u as refMapToObject, v as createSchema, y as Node } from "./visitor-D9_Eb8I1.js";
+
+//#region src/guards.d.ts
+/**
+ * Narrows a `SchemaNode` to the specific variant matching `type`.
+ */
+declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined;
+/**
+ * Type guard for `RootNode`.
+ */
+declare const isRootNode: (node: Node) => node is RootNode;
+/**
+ * Type guard for `OperationNode`.
+ */
+declare const isOperationNode: (node: Node) => node is OperationNode;
+/**
+ * Type guard for `SchemaNode`.
+ */
+declare const isSchemaNode: (node: Node) => node is SchemaNode;
+/**
+ * Type guard for `PropertyNode`.
+ */
+declare const isPropertyNode: (node: Node) => node is PropertyNode;
+/**
+ * Type guard for `ParameterNode`.
+ */
+declare const isParameterNode: (node: Node) => node is ParameterNode;
+/**
+ * Type guard for `ResponseNode`.
+ */
+declare const isResponseNode: (node: Node) => node is ResponseNode;
+//#endregion
+export { buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, httpMethods, isOperationNode, isParameterNode, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+//# sourceMappingURL=index.d.ts.map