@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/src/utils/schemaTraversal.ts

@@ -0,0 +1,86 @@
+import type { ArraySchemaNode, IntersectionSchemaNode, ObjectSchemaNode, PropertyNode, SchemaNode, UnionSchemaNode } from '../nodes/index.ts'
+import { objectKey } from './codegen.ts'
+
+/**
+ * Converts a child schema to printer output. Plugins instantiate it with their own output type:
+ * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's
+ * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.
+ */
+export type SchemaTransform<TOutput> = (schema: SchemaNode) => TOutput
+
+/**
+ * A union or intersection member, or an array or tuple item, paired with its transformed output.
+ */
+export type MappedSchema<TOutput> = {
+  /**
+   * The original child schema, kept so the printer can read its metadata for leaf formatting.
+   */
+  schema: SchemaNode
+  /**
+   * The child schema after being run through the transform.
+   */
+  output: TOutput
+}
+
+/**
+ * An object property paired with its transformed output.
+ */
+export type MappedProperty<TOutput> = {
+  /**
+   * The property name as written on the schema, before any identifier quoting.
+   */
+  name: string
+  /**
+   * The original property node, kept so the printer can read `required`, `schema`, and metadata.
+   */
+  property: PropertyNode
+  /**
+   * The property schema after being run through the transform.
+   */
+  output: TOutput
+}
+
+/**
+ * Maps each property of an object schema to its transformed output. Pairs every result with the
+ * original property so the printer keeps full control over modifiers, getters, and key syntax.
+ *
+ * @example
+ * ```ts
+ * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+ * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+ * ```
+ */
+export function mapSchemaProperties<TOutput>(node: ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>> {
+  return node.properties.map((property) => ({ name: property.name, property, output: transform(property.schema) }))
+}
+
+/**
+ * Maps each member of a union or intersection schema to its transformed output, pairing every
+ * result with the original member.
+ */
+export function mapSchemaMembers<TOutput>(node: UnionSchemaNode | IntersectionSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {
+  return (node.members ?? []).map((schema) => ({ schema, output: transform(schema) }))
+}
+
+/**
+ * Maps each item of an array or tuple schema to its transformed output, pairing every result with
+ * the original item.
+ */
+export function mapSchemaItems<TOutput>(node: ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {
+  return (node.items ?? []).map((schema) => ({ schema, output: transform(schema) }))
+}
+
+/**
+ * Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+ * is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+ * of a recursive schema until first access.
+ *
+ * @example
+ * ```ts
+ * lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+ * // "get parent() { return z.lazy(() => Pet) }"
+ * ```
+ */
+export function lazyGetter({ name, body }: { name: string; body: string }): string {
+  return `get ${objectKey(name)}() { return ${body} }`
+}

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("']?.['")}']`}`
+}