@kubb/ast 5.0.0-beta.62 → 5.0.0-beta.64

package/src/registry.ts

@@ -1,75 +0,0 @@
-import type { NodeDef } from './defineNode.ts'
-import { arrowFunctionDef, breakDef, constDef, functionDef, jsxDef, textDef, typeDef } from './nodes/code.ts'
-import { contentDef } from './nodes/content.ts'
-import { exportDef, fileDef, importDef, sourceDef } from './nodes/file.ts'
-import { functionParameterDef, functionParametersDef, indexedAccessTypeDef, objectBindingPatternDef, typeLiteralDef } from './nodes/function.ts'
-import { inputDef } from './nodes/input.ts'
-import { operationDef } from './nodes/operation.ts'
-import { outputDef } from './nodes/output.ts'
-import { parameterDef } from './nodes/parameter.ts'
-import { propertyDef } from './nodes/property.ts'
-import { requestBodyDef } from './nodes/requestBody.ts'
-import { responseDef } from './nodes/response.ts'
-import { schemaDef } from './nodes/schema.ts'
-
-// Surface every def from one place so the package barrel re-exports them with `export * from './registry.ts'`.
-// Adding a node means adding its `defineNode` to a `nodes/*.ts` file and listing it in `nodeDefs` below, nothing else.
-export {
-  arrowFunctionDef,
-  breakDef,
-  constDef,
-  contentDef,
-  exportDef,
-  fileDef,
-  functionDef,
-  functionParameterDef,
-  functionParametersDef,
-  importDef,
-  indexedAccessTypeDef,
-  inputDef,
-  jsxDef,
-  objectBindingPatternDef,
-  operationDef,
-  outputDef,
-  parameterDef,
-  propertyDef,
-  requestBodyDef,
-  responseDef,
-  schemaDef,
-  sourceDef,
-  textDef,
-  typeDef,
-  typeLiteralDef,
-}
-
-/**
- * Every node definition. Adding a node means adding its `defineNode` to one
- * `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
- */
-export const nodeDefs = [
-  inputDef,
-  outputDef,
-  operationDef,
-  requestBodyDef,
-  contentDef,
-  responseDef,
-  schemaDef,
-  propertyDef,
-  parameterDef,
-  functionParameterDef,
-  functionParametersDef,
-  typeLiteralDef,
-  indexedAccessTypeDef,
-  objectBindingPatternDef,
-  constDef,
-  typeDef,
-  functionDef,
-  arrowFunctionDef,
-  textDef,
-  breakDef,
-  jsxDef,
-  importDef,
-  exportDef,
-  sourceDef,
-  fileDef,
-] satisfies ReadonlyArray<NodeDef>

package/src/signature.ts

@@ -1,207 +0,0 @@
-import { hash } from 'node:crypto'
-import type { SchemaNode } from './nodes/index.ts'
-import { extractRefName } from './utils/index.ts'
-
-/**
- * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
- */
-function flagsDescriptor(node: SchemaNode): string {
-  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`
-}
-
-function refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {
-  if (node.ref) return extractRefName(node.ref)
-  return node.name ?? ''
-}
-
-type ScalarField = { kind: 'scalar'; key: string; prefix: string }
-type BoolField = { kind: 'bool'; key: string; prefix: string }
-type ChildField = { kind: 'child'; key: string; prefix: string }
-type ChildrenField = { kind: 'children'; key: string; prefix: string }
-type ObjectPropsField = { kind: 'objectProps' }
-type AdditionalPropsField = { kind: 'additionalProps' }
-type PatternPropsField = { kind: 'patternProps' }
-type EnumValuesField = { kind: 'enumValues' }
-type RefTargetField = { kind: 'refTarget' }
-
-type ShapeField =
-  | ScalarField
-  | BoolField
-  | ChildField
-  | ChildrenField
-  | ObjectPropsField
-  | AdditionalPropsField
-  | PatternPropsField
-  | EnumValuesField
-  | RefTargetField
-
-const arrayTupleFields: ReadonlyArray<ShapeField> = [
-  { kind: 'children', key: 'items', prefix: 'i' },
-  { kind: 'child', key: 'rest', prefix: 'r' },
-  { kind: 'scalar', key: 'min', prefix: 'mn' },
-  { kind: 'scalar', key: 'max', prefix: 'mx' },
-  { kind: 'bool', key: 'unique', prefix: 'u' },
-]
-
-const numericFields: ReadonlyArray<ShapeField> = [
-  { kind: 'scalar', key: 'min', prefix: 'mn' },
-  { kind: 'scalar', key: 'max', prefix: 'mx' },
-  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },
-  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },
-  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },
-]
-
-const rangeFields: ReadonlyArray<ShapeField> = [
-  { kind: 'scalar', key: 'min', prefix: 'mn' },
-  { kind: 'scalar', key: 'max', prefix: 'mx' },
-]
-
-/**
- * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
- * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
- */
-const SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {
-  object: [
-    { kind: 'objectProps' },
-    { kind: 'additionalProps' },
-    { kind: 'patternProps' },
-    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },
-    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },
-  ],
-  array: arrayTupleFields,
-  tuple: arrayTupleFields,
-  union: [
-    { kind: 'scalar', key: 'strategy', prefix: 's' },
-    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },
-    { kind: 'children', key: 'members', prefix: 'm' },
-  ],
-  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],
-  enum: [{ kind: 'enumValues' }],
-  ref: [{ kind: 'refTarget' }],
-  string: [
-    { kind: 'scalar', key: 'min', prefix: 'mn' },
-    { kind: 'scalar', key: 'max', prefix: 'mx' },
-    { kind: 'scalar', key: 'pattern', prefix: 'pt' },
-  ],
-  number: numericFields,
-  integer: numericFields,
-  bigint: numericFields,
-  url: [
-    { kind: 'scalar', key: 'path', prefix: 'path' },
-    { kind: 'scalar', key: 'min', prefix: 'mn' },
-    { kind: 'scalar', key: 'max', prefix: 'mx' },
-  ],
-  uuid: rangeFields,
-  email: rangeFields,
-  datetime: [
-    { kind: 'bool', key: 'offset', prefix: 'o' },
-    { kind: 'bool', key: 'local', prefix: 'l' },
-  ],
-  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],
-  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],
-}
-
-function serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {
-  switch (field.kind) {
-    case 'scalar':
-      return `${field.prefix}:${record[field.key] ?? ''}`
-    case 'bool':
-      return `${field.prefix}:${record[field.key] ? 1 : 0}`
-    case 'child': {
-      const child = record[field.key] as SchemaNode | undefined
-      return `${field.prefix}:${child ? signatureOf(child) : ''}`
-    }
-    case 'children': {
-      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []
-      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`
-    }
-    case 'objectProps': {
-      const obj = node as Extract<SchemaNode, { type: 'object' }>
-      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')
-      return `p[${props}]`
-    }
-    case 'additionalProps': {
-      const obj = node as Extract<SchemaNode, { type: 'object' }>
-      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`
-      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`
-      return ''
-    }
-    case 'patternProps': {
-      const obj = node as Extract<SchemaNode, { type: 'object' }>
-      const pattern = obj.patternProperties
-        ? Object.keys(obj.patternProperties)
-            .sort()
-            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)
-            .join(',')
-        : ''
-      return `pp[${pattern}]`
-    }
-    case 'enumValues': {
-      const en = node as Extract<SchemaNode, { type: 'enum' }>
-      let values = ''
-      if (en.namedEnumValues?.length) {
-        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')
-      } else if (en.enumValues?.length) {
-        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')
-      }
-      return `v[${values}]`
-    }
-    case 'refTarget': {
-      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`
-    }
-  }
-}
-
-/**
- * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
- * constraints, and its children's signatures.
- */
-function describeShape(node: SchemaNode): string {
-  const flags = flagsDescriptor(node)
-  const fields = SHAPE_KEYS[node.type]
-  if (!fields) return `${node.type}|${flags}`
-
-  const record = node as unknown as Record<string, unknown>
-  const parts: Array<string> = [`${node.type}|${flags}`]
-  for (const field of fields) {
-    parts.push(serializeShapeField(field, node, record))
-  }
-  return parts.join('|')
-}
-
-/**
- * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so
- * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.
- * Reuse is safe because a signature depends only on content, and nodes are immutable once created.
- */
-const signatureCache = new WeakMap<SchemaNode, string>()
-
-/**
- * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
- * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
- * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
- * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
- * nodes compare by target name, which also terminates on circular shapes.
- *
- * @example Two enums with different descriptions share a signature
- * ```ts
- * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
- *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
- * ```
- */
-export function signatureOf(node: SchemaNode): string {
-  const cached = signatureCache.get(node)
-  if (cached !== undefined) return cached
-  const signature = hash('sha256', describeShape(node), 'hex')
-  signatureCache.set(node, signature)
-
-  return signature
-}
-
-/**
- * Returns `true` when two schema nodes are structurally identical under shape-only equality,
- * meaning they produce the same TypeScript type.
- */
-export function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {
-  return signatureOf(a) === signatureOf(b)
-}

package/src/types.ts

@@ -1,9 +0,0 @@
-export type { DedupeCanonical, DedupeLookups, DedupePlan } from './dedupe.ts'
-export type { Dialect, SchemaDialect } from './dialect.ts'
-export type { DistributiveOmit, NodeDef } from './defineNode.ts'
-export type { InferSchemaNode, ParserOptions } from './infer.ts'
-export type * from './nodes/index.ts'
-export type { ParentOf, Visitor, VisitorContext } from './visitor.ts'
-export type { Printer, PrinterFactoryOptions, PrinterPartial } from './definePrinter.ts'
-export type { OperationParamsResolver } from './utils/operationParams.ts'
-export type { Enforce, Macro } from './defineMacro.ts'

package/src/utils/codegen.ts

@@ -1,104 +0,0 @@
-import { isIdentifier, singleQuote } from '@internals/utils'
-import { INDENT } from '../constants.ts'
-
-/**
- * Builds a JSDoc comment block from an array of lines, returning `fallback` when there are no
- * comments so callers always get a usable string.
- *
- * @example
- * ```ts
- * buildJSDoc(['@type string', '@example hello'])
- * // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
- * ```
- */
-export function buildJSDoc(
-  comments: Array<string>,
-  options: {
-    /**
-     * String used to indent each comment line.
-     * @default '   * '
-     */
-    indent?: string
-    /**
-     * String appended after the closing tag.
-     * @default '\n  '
-     */
-    suffix?: string
-    /**
-     * Returned as-is when `comments` is empty.
-     * @default '  '
-     */
-    fallback?: string
-  } = {},
-): string {
-  const { indent = '   * ', suffix = '\n  ', fallback = '  ' } = options
-
-  if (comments.length === 0) return fallback
-
-  return `/**\n${comments.map((c) => `${indent}${c}`).join('\n')}\n   */${suffix}`
-}
-
-/**
- * Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
- */
-function indentLines(text: string): string {
-  if (!text) return ''
-  return text
-    .split('\n')
-    .map((line) => (line.trim() ? `${INDENT}${line}` : ''))
-    .join('\n')
-}
-
-/**
- * Renders an object key, quoting it with single quotes only when it is not a valid identifier.
- * Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
- *
- * @example
- * ```ts
- * objectKey('name')    // 'name'
- * objectKey('x-total') // "'x-total'"
- * ```
- */
-export function objectKey(name: string): string {
-  return isIdentifier(name) ? name : singleQuote(name)
-}
-
-/**
- * Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
- * level and closing the brace at column zero. Nested objects built the same way indent cumulatively,
- * so callers never re-parse the generated code. A trailing comma is added per entry to match the
- * formatter's multi-line style.
- *
- * @example
- * ```ts
- * buildObject(['id: z.number()', 'name: z.string()'])
- * // '{\n  id: z.number(),\n  name: z.string(),\n}'
- * ```
- */
-export function buildObject(entries: Array<string>): string {
-  if (entries.length === 0) return '{}'
-  const body = entries.map((entry) => `${indentLines(entry)},`).join('\n')
-
-  return `{\n${body}\n}`
-}
-
-/**
- * Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
- * one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
- * one level with a trailing comma and the closing bracket at column zero. Use it for `z.union([…])`,
- * `z.array([…])`, and similar member lists so objects inside them nest correctly.
- *
- * @example
- * ```ts
- * buildList(['z.string()', 'z.number()'])
- * // '[z.string(), z.number()]'
- * ```
- */
-export function buildList(items: Array<string>, brackets: [open: string, close: string] = ['[', ']']): string {
-  const [open, close] = brackets
-  if (items.length === 0) return `${open}${close}`
-  if (!items.some((item) => item.includes('\n'))) return `${open}${items.join(', ')}${close}`
-  const body = items.map((item) => `${indentLines(item)},`).join('\n')
-
-  return `${open}\n${body}\n${close}`
-}

package/src/utils/extractStringsFromNodes.ts

@@ -1,35 +0,0 @@
-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/fileMerge.ts

@@ -1,184 +0,0 @@
-/**
- * File-member merging. `combineImports`, `combineExports`, and `combineSources` deduplicate and sort
- * the import, export, and source entries of one file, and drop imports nothing references. This works
- * on a file's members, not on schema content.
- *
- * For collapsing duplicate schema shapes by structural signature, see `dedupe.ts`.
- */
-import type { ExportNode, ImportNode, SourceNode } from '../nodes/index.ts'
-import { extractStringsFromNodes } from './extractStringsFromNodes.ts'
-
-function sourceKey(source: SourceNode): string {
-  const nameKey = source.name ?? extractStringsFromNodes(source.nodes)
-  return `${nameKey}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`
-}
-
-function pathTypeKey(path: string, isTypeOnly: boolean | null | undefined): string {
-  return `${path}:${isTypeOnly ?? false}`
-}
-
-function exportKey(path: string, name: string | null | undefined, isTypeOnly: boolean | null | undefined, asAlias: boolean | null | undefined): string {
-  return `${path}:${name ?? ''}:${isTypeOnly ?? false}:${asAlias ?? ''}`
-}
-
-function importKey(path: string, name: string | null | undefined, isTypeOnly: boolean | null | undefined): string {
-  return `${path}:${name ?? ''}:${isTypeOnly ?? false}`
-}
-
-/**
- * Computes a multi-level sort key for exports and imports:
- * non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
- */
-function sortKey(node: { name?: string | Array<unknown> | null; isTypeOnly?: boolean | null; path: string }): string {
-  const isArray = Array.isArray(node.name) ? '1' : '0'
-  const typeOnly = node.isTypeOnly ? '0' : '1'
-  const hasName = node.name != null ? '1' : '0'
-  const name = Array.isArray(node.name) ? node.name.toSorted().join('\0') : (node.name ?? '')
-  return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`
-}
-
-/**
- * Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
- *
- * Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
- */
-export function combineSources(sources: Array<SourceNode>): Array<SourceNode> {
-  const seen = new Map<string, SourceNode>()
-  for (const source of sources) {
-    const key = sourceKey(source)
-    if (!seen.has(key)) seen.set(key, source)
-  }
-  return [...seen.values()]
-}
-
-/**
- * Merges `incoming` names into `existing`, preserving order and dropping duplicates.
- *
- * Shared by `combineExports` and `combineImports` for the same-path name-merge case.
- */
-function mergeNameArrays<TName>(existing: Array<TName>, incoming: Array<TName>): Array<TName> {
-  const merged = new Set(existing)
-  for (const name of incoming) merged.add(name)
-  return [...merged]
-}
-
-/**
- * Deduplicates and merges `ExportNode` objects by path and type.
- *
- * Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
- * Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
- */
-export function combineExports(exports: Array<ExportNode>): Array<ExportNode> {
-  const result: Array<ExportNode> = []
-  // Accumulates array-named exports keyed by `path:isTypeOnly` for name-merging
-  const namedByPath = new Map<string, ExportNode>()
-  // Deduplicates non-array exports by their exact identity
-  const seen = new Set<string>()
-
-  // Precompute sort keys once, avoids recomputing per comparison.
-  const keyed = exports.map((node) => ({ node, key: sortKey(node) }))
-  keyed.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))
-
-  for (const { node: curr } of keyed) {
-    const { name, path, isTypeOnly, asAlias } = curr
-
-    if (Array.isArray(name)) {
-      if (!name.length) continue
-
-      const key = pathTypeKey(path, isTypeOnly)
-      const existing = namedByPath.get(key)
-
-      if (existing && Array.isArray(existing.name)) {
-        existing.name = mergeNameArrays(existing.name, name)
-      } else {
-        const newItem: ExportNode = { ...curr, name: [...new Set(name)] }
-        result.push(newItem)
-        namedByPath.set(key, newItem)
-      }
-    } else {
-      const key = exportKey(path, name, isTypeOnly, asAlias)
-      if (!seen.has(key)) {
-        result.push(curr)
-        seen.add(key)
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Deduplicates and merges `ImportNode` objects, filtering out unused imports.
- *
- * Retains imports that are referenced in `source` or re-exported. Imports with the same path and
- * `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
- */
-export function combineImports(imports: Array<ImportNode>, exports: Array<ExportNode>, source?: string): Array<ImportNode> {
-  // Build a lookup of all exported names to retain imports that are re-exported
-  const exportedNames = new Set(exports.flatMap((e) => (Array.isArray(e.name) ? e.name : e.name ? [e.name] : [])))
-  const isUsed = (importName: string): boolean => !source || source.includes(importName) || exportedNames.has(importName)
-
-  // Memoize object import names so the same logical (propertyName, name) pair always
-  // reuses the same object reference. Set-based deduplication then works correctly.
-  const importNameMemo = new Map<string, { propertyName: string; name?: string }>()
-  const canonicalizeName = (n: string | { propertyName: string; name?: string }): string | { propertyName: string; name?: string } => {
-    if (typeof n === 'string') return n
-    const key = `${n.propertyName}:${n.name ?? ''}`
-    if (!importNameMemo.has(key)) importNameMemo.set(key, n)
-    return importNameMemo.get(key)!
-  }
-
-  // Paths that keep at least one used named import. A default import from such a path is retained
-  // even when its binding can't be found in `source` e.g. a generated `client` default import
-  // alongside `import type { Client } from <same path>`, where merged grouped output omits the body.
-  const pathsWithUsedNamedImport = new Set<string>()
-  for (const node of imports) {
-    if (!Array.isArray(node.name)) continue
-    if (node.name.some((item) => (typeof item === 'string' ? isUsed(item) : isUsed(item.name ?? item.propertyName)))) {
-      pathsWithUsedNamedImport.add(node.path)
-    }
-  }
-
-  const result: Array<ImportNode> = []
-  // Accumulates array-named imports keyed by `path:isTypeOnly` for name-merging
-  const namedByPath = new Map<string, ImportNode>()
-  // Deduplicates non-array imports by their exact identity
-  const seen = new Set<string>()
-
-  // Precompute sort keys once, avoids recomputing per comparison.
-  const keyed = imports.map((node) => ({ node, key: sortKey(node) }))
-  keyed.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))
-
-  for (const { node: curr } of keyed) {
-    if (curr.path === curr.root) continue
-
-    const { path, isTypeOnly } = curr
-    let { name } = curr
-
-    if (Array.isArray(name)) {
-      name = [...new Set(name.map(canonicalizeName))].filter((item) => (typeof item === 'string' ? isUsed(item) : isUsed(item.name ?? item.propertyName)))
-      if (!name.length) continue
-
-      const key = pathTypeKey(path, isTypeOnly)
-      const existing = namedByPath.get(key)
-
-      if (existing && Array.isArray(existing.name)) {
-        existing.name = mergeNameArrays(existing.name, name)
-      } else {
-        const newItem: ImportNode = { ...curr, name }
-        result.push(newItem)
-        namedByPath.set(key, newItem)
-      }
-    } else {
-      if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue
-
-      const key = importKey(path, name, isTypeOnly)
-      if (!seen.has(key)) {
-        result.push(curr)
-        seen.add(key)
-      }
-    }
-  }
-
-  return result
-}

package/src/utils/index.ts

@@ -1,11 +0,0 @@
-export { isValidVarName } from '@internals/utils'
-export { buildJSDoc, buildList, buildObject, objectKey } from './codegen.ts'
-export { extractStringsFromNodes } from './extractStringsFromNodes.ts'
-export { childName, enumPropName, extractRefName, isStringType, resolveGroupType, resolveRefName, syncSchemaRef } from './refs.ts'
-export { mergeAdjacentObjectsLazy } from './schemaMerge.ts'
-export { getNestedAccessor, jsStringEscape, stringify, stringifyObject, toRegExpString, trimQuotes } from './strings.ts'
-export { collectUsedSchemaNames, containsCircularRef, findCircularSchemas } from './schemaGraph.ts'
-export { lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties } from './schemaTraversal.ts'
-export type { MappedProperty, MappedSchema, SchemaTransform } from './schemaTraversal.ts'
-export { buildGroupParam, buildTypeLiteral, caseParams, createOperationParams, resolveParamType } from './operationParams.ts'
-export type { BuildGroupArgs, ParamGroupType } from './operationParams.ts'