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

package/src/utils/strings.ts

@@ -0,0 +1,139 @@
+/**
+ * Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+ * Returns the string unchanged when no balanced quote pair is found.
+ *
+ * @example
+ * ```ts
+ * trimQuotes('"hello"') // 'hello'
+ * trimQuotes('hello')   // 'hello'
+ * ```
+ */
+export function trimQuotes(text: string): string {
+  if (text.length >= 2) {
+    const first = text[0]
+    const last = text[text.length - 1]
+    if ((first === '"' && last === '"') || (first === "'" && last === "'") || (first === '`' && last === '`')) {
+      return text.slice(1, -1)
+    }
+  }
+  return text
+}
+
+/**
+ * Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+ *
+ * Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+ * code matches the repo style without a formatter.
+ *
+ * @example
+ * ```ts
+ * stringify('hello')   // "'hello'"
+ * stringify('"hello"') // "'hello'"
+ * ```
+ */
+export function stringify(value: string | number | boolean | undefined): string {
+  if (value === undefined || value === null) return "''"
+  const json = JSON.stringify(trimQuotes(value.toString()))
+  const inner = json.slice(1, -1).replace(/\\"/g, '"').replace(/'/g, "\\'")
+  return `'${inner}'`
+}
+
+/**
+ * Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+ * and the Unicode line terminators U+2028 and U+2029.
+ *
+ * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+ *
+ * @example
+ * ```ts
+ * jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+ * ```
+ */
+export function jsStringEscape(input: unknown): string {
+  return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+    switch (character) {
+      case '"':
+      case "'":
+      case '\\':
+        return `\\${character}`
+      case '\n':
+        return '\\n'
+      case '\r':
+        return '\\r'
+      case '\u2028':
+        return '\\u2028'
+      case '\u2029':
+        return '\\u2029'
+      default:
+        return ''
+    }
+  })
+}
+
+/**
+ * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+ * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+ * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+ *
+ * @example
+ * ```ts
+ * toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+ * toRegExpString('^(?im)foo', null) // '/^foo/im'
+ * ```
+ */
+export function toRegExpString(text: string, func: string | null = 'RegExp'): string {
+  const raw = trimQuotes(text)
+
+  const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i)
+  const replacementTarget = match?.[1] ?? ''
+  const matchedFlags = match?.[2]
+  const cleaned = raw
+    .replace(/^\\?\//, '')
+    .replace(/\\?\/$/, '')
+    .replace(replacementTarget, '')
+
+  const { source, flags } = new RegExp(cleaned, matchedFlags)
+
+  if (func === null) return `/${source}/${flags}`
+
+  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`
+}
+
+/**
+ * Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested
+ * objects recurse with fixed indentation, so the result drops straight into an object literal
+ * without re-parsing.
+ *
+ * @example
+ * ```ts
+ * stringifyObject({ foo: 'bar', nested: { a: 1 } })
+ * // 'foo: bar,\nnested: {\n        a: 1\n      }'
+ * ```
+ */
+export function stringifyObject(value: Record<string, unknown>): string {
+  const items = Object.entries(value)
+    .map(([key, val]) => {
+      if (val !== null && typeof val === 'object') {
+        return `${key}: {\n        ${stringifyObject(val as Record<string, unknown>)}\n      }`
+      }
+      return `${key}: ${val}`
+    })
+    .filter(Boolean)
+  return items.join(',\n')
+}
+
+/**
+ * Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+ * `accessor`. Returns `null` for an empty path.
+ *
+ * @example
+ * ```ts
+ * getNestedAccessor('pagination.next.id', 'lastPage')
+ * // "lastPage?.['pagination']?.['next']?.['id']"
+ * ```
+ */
+export function getNestedAccessor(param: string | Array<string>, accessor: string): string | null {
+  const parts = Array.isArray(param) ? param : param.split('.')
+  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) return null
+  return `${accessor}?.['${`${parts.join("']?.['")}']`}`
+}

package/src/visitor.ts

@@ -1,10 +1,11 @@
 import type { VisitorDepth } from './constants.ts'
 import { visitorDepths, WALK_CONCURRENCY } from './constants.ts'
-import { nodeRebuilders, VISITOR_KEY_BY_KIND, VISITOR_KEYS } from './registry.ts'
+import type { NodeDef } from './node.ts'
 import type {
   ContentNode,
   InputNode,
   Node,
+  NodeKind,
   OperationNode,
   OutputNode,
   ParameterNode,
@@ -13,6 +14,31 @@ import type {
   ResponseNode,
   SchemaNode,
 } from './nodes/index.ts'
+import { nodeDefs } from './registry.ts'
+
+/**
+ * Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
+ * Derived from each definition's `children`.
+ */
+const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => (def.children ? [[def.kind, def.children] as const] : []))) as Partial<
+  Record<NodeKind, ReadonlyArray<string>>
+>
+
+/**
+ * Maps a node kind to the matching visitor callback name. Derived from each
+ * definition's `visitorKey`.
+ */
+const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => (def.visitorKey ? [[def.kind, def.visitorKey] as const] : []))) as Partial<
+  Record<NodeKind, NonNullable<NodeDef['visitorKey']>>
+>
+
+/**
+ * Per-kind builders rerun after children are rebuilt. Derived from each
+ * definition's `rebuild` flag.
+ */
+const nodeRebuilders = Object.fromEntries(
+  nodeDefs.flatMap((def) => (def.rebuild ? [[def.kind, def.create as unknown as (node: Node) => Node] as const] : [])),
+) as Partial<Record<NodeKind, (node: Node) => Node>>
 
 /**
  * Creates a small async concurrency limiter.
@@ -76,8 +102,7 @@ type ParentNodeMap = [
 /**
  * Resolves the parent node type for a given AST node type.
  *
- * This is used by visitor context so `ctx.parent` is correctly typed
- * for each callback.
+ * Visitor context relies on this so `ctx.parent` is typed for each callback.
  *
  * @example
  * ```ts
@@ -133,8 +158,7 @@ export type VisitorContext<T extends Node = Node> = {
  * to leave it untouched.
  *
  * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
- * before printing.
+ * rewrites the AST before printing.
  *
  * @example Prefix every operationId
  * ```ts
@@ -165,7 +189,7 @@ export type Visitor = {
 }
 
 /**
- * Utility type for values that can be returned directly or asynchronously.
+ * A visitor callback result that may be sync or async.
  */
 type MaybePromise<T> = T | Promise<T>
 
@@ -229,7 +253,7 @@ type CollectVisitor<T> = {
  */
 export type TransformOptions = Visitor & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth
@@ -249,7 +273,7 @@ export type TransformOptions = Visitor & {
  */
 export type WalkOptions = AsyncVisitor & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth
@@ -270,7 +294,7 @@ export type WalkOptions = AsyncVisitor & {
  */
 export type CollectOptions<T> = CollectVisitor<T> & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth
@@ -318,9 +342,9 @@ function* getChildren(node: Node, recurse: boolean): Generator<Node, void, undef
 }
 
 /**
- * Invokes the visitor callback that matches `node.kind`, passing the traversal
- * context. Returns the callback's result (a replacement node, a collected
- * value, or `undefined` when no callback is registered for the kind).
+ * Runs the visitor callback that matches `node.kind` with the traversal
+ * context. The result is a replacement node, a collected value, or `undefined`
+ * when no callback is registered for the kind.
  *
  * Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
  * in one place. `TResult` is the caller's expected return: the same node type
@@ -369,7 +393,7 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
 
   // Visit siblings concurrently and let the shared `limit` cap how many callbacks
   // run at once. Awaiting each child sequentially here would serialize the whole
-  // traversal and make `concurrency` inert, every visitor callback would run one
+  // traversal and make `concurrency` inert. Every visitor callback would run one
   // at a time regardless of the limit.
   const children = Array.from(getChildren(node, recurse))
   if (children.length === 0) return
@@ -378,11 +402,11 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
 }
 
 /**
- * Synchronous depth-first transform. Each visitor callback gets a chance to
- * return a replacement node; `undefined` keeps the original.
+ * Synchronous depth-first transform. Each visitor callback can return a
+ * replacement node. Returning `undefined` keeps the original.
  *
- * The transform is immutable. The original tree is not mutated. A new tree
- * is returned. Use `depth: 'shallow'` to skip recursion into children.
+ * The original tree is never mutated, a new tree is returned. Pass
+ * `depth: 'shallow'` to skip recursion into children.
  *
  * @example Prefix every operationId
  * ```ts
@@ -489,8 +513,8 @@ export function* collectLazy<T>(node: Node, options: CollectOptions<T>): Generat
 }
 
 /**
- * Eager depth-first collection pass. Returns an array of every non-null value
- * the visitor callbacks return.
+ * Eager depth-first collection pass. Gathers every non-null value the visitor
+ * callbacks return into an array.
  *
  * @example Collect every operationId
  * ```ts

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 };