@kubb/ast 5.0.0-beta.53 → 5.0.0-beta.54

package/dist/{types-IHUK_alM.d.ts → types-BYujEIxF.d.ts}

@@ -2005,12 +2005,21 @@ type DedupePlan = {
    * Maps a structural signature to the canonical schema that represents it.
    */
   canonicalBySignature: Map<string, DedupeCanonical>;
+  /**
+   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
+   * references to the duplicate can be repointed at the first schema with the same content.
+   */
+  aliasNames: Map<string, DedupeCanonical>;
   /**
    * New top-level schema definitions created for inline shapes that had no existing
    * named component. Nested duplicates inside each definition are already collapsed.
    */
   hoisted: Array<SchemaNode>;
 };
+/**
+ * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
+ */
+type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
 /**
  * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
  * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
@@ -2041,25 +2050,29 @@ type BuildDedupePlanOptions = {
 /**
  * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
  * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again.
+ * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
+ * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
+ * the same content.
  *
  * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
  * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
- * const next = applyDedupe(operationNode, plan.canonicalBySignature)
+ * const next = applyDedupe(operationNode, plan)
  * ```
  */
-declare function applyDedupe(node: SchemaNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): OperationNode;
+declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
+declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
 /**
  * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
  *
  * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, that name becomes the canonical (so other top-level duplicates
- * and inline copies turn into references to it). Otherwise a new definition is hoisted using
- * `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+ * is a named top-level schema, the first one becomes the canonical (so other top-level
+ * duplicates and inline copies turn into references to it). Every other top-level name with
+ * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+ * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+ * per node with {@link applyDedupe}.
  *
  * @example
  * ```ts
@@ -3571,5 +3584,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { SchemaDialect as $, httpMethods as $t, createFunctionParameter as A, IntersectionSchemaNode as At, createProperty as B, TimeSchemaNode as Bt, UserFileNode as C, FileNode as Ct, createExport as D, DateSchemaNode as Dt, createConst as E, ArraySchemaNode as Et, createOperation as F, ScalarSchemaType as Ft, createText as G, CodeNode as Gt, createSchema as H, UrlSchemaNode as Ht, createOutput as I, SchemaNode as It, update as J, JSDocNode as Jt, createType as K, ConstNode as Kt, createParameter as L, SchemaNodeByType as Lt, createImport as M, ObjectSchemaNode as Mt, createInput as N, PrimitiveSchemaType as Nt, createFile as O, DatetimeSchemaNode as Ot, createJsx as P, RefSchemaNode as Pt, dispatch as Q, NodeKind as Qt, createParameterGroup as R, SchemaType as Rt, DistributiveOmit as S, ExportNode as St, createBreak as T, SourceNode as Tt, createSource as U, PropertyNode as Ut, createResponse as V, UnionSchemaNode as Vt, createStreamInput as W, ArrowFunctionNode as Wt, ParserOptions as X, TextNode as Xt, InferSchemaNode as Y, JsxNode as Yt, DispatchRule as Z, TypeNode as Zt, Printer as _, FunctionParamNode as _t, createDiscriminantNode as a, InputMeta as at, createPrinterFactory as b, ParameterGroupNode as bt, findCircularSchemas as c, OutputNode as ct, ParentOf as d, OperationNode as dt, schemaTypes as en, defineSchemaDialect as et, Visitor as f, ResponseNode as ft, walk as g, FunctionNodeType as gt, transform as h, ParameterNode as ht, containsCircularRef as i, Node as it, createFunctionParameters as j, NumberSchemaNode as jt, createFunction as k, EnumSchemaNode as kt, isStringType as l, HttpMethod as lt, collect as m, ParameterLocation as mt, caseParams as n, applyDedupe as nt, createOperationParams as o, InputNode as ot, VisitorContext as p, StatusCode as pt, syncOptionality as q, FunctionNode as qt, collectUsedSchemaNames as r, buildDedupePlan as rt, extractStringsFromNodes as s, InputStreamNode as st, OperationParamsResolver as t, DedupePlan as tt, syncSchemaRef as u, HttpOperationNode as ut, PrinterFactoryOptions as v, FunctionParameterNode as vt, createArrowFunction as w, ImportNode as wt, definePrinter as x, ParamsTypeNode as xt, PrinterPartial as y, FunctionParametersNode as yt, createParamsType as z, StringSchemaNode as zt };
-//# sourceMappingURL=types-IHUK_alM.d.ts.map
+export { SchemaDialect as $, TypeNode as $t, createFunctionParameter as A, DatetimeSchemaNode as At, createProperty as B, SchemaType as Bt, UserFileNode as C, ParamsTypeNode as Ct, createExport as D, SourceNode as Dt, createConst as E, ImportNode as Et, createOperation as F, PrimitiveSchemaType as Ft, createText as G, PropertyNode as Gt, createSchema as H, TimeSchemaNode as Ht, createOutput as I, RefSchemaNode as It, update as J, ConstNode as Jt, createType as K, ArrowFunctionNode as Kt, createParameter as L, ScalarSchemaType as Lt, createImport as M, IntersectionSchemaNode as Mt, createInput as N, NumberSchemaNode as Nt, createFile as O, ArraySchemaNode as Ot, createJsx as P, ObjectSchemaNode as Pt, dispatch as Q, TextNode as Qt, createParameterGroup as R, SchemaNode as Rt, DistributiveOmit as S, ParameterGroupNode as St, createBreak as T, FileNode as Tt, createSource as U, UnionSchemaNode as Ut, createResponse as V, StringSchemaNode as Vt, createStreamInput as W, UrlSchemaNode as Wt, ParserOptions as X, JSDocNode as Xt, InferSchemaNode as Y, FunctionNode as Yt, DispatchRule as Z, JsxNode as Zt, Printer as _, ParameterNode as _t, createDiscriminantNode as a, buildDedupePlan as at, createPrinterFactory as b, FunctionParameterNode as bt, findCircularSchemas as c, InputNode as ct, ParentOf as d, HttpMethod as dt, NodeKind as en, defineSchemaDialect as et, Visitor as f, HttpOperationNode as ft, walk as g, ParameterLocation as gt, transform as h, StatusCode as ht, containsCircularRef as i, applyDedupe as it, createFunctionParameters as j, EnumSchemaNode as jt, createFunction as k, DateSchemaNode as kt, isStringType as l, InputStreamNode as lt, collect as m, ResponseNode as mt, caseParams as n, schemaTypes as nn, DedupeLookups as nt, createOperationParams as o, Node as ot, VisitorContext as p, OperationNode as pt, syncOptionality as q, CodeNode as qt, collectUsedSchemaNames as r, DedupePlan as rt, extractStringsFromNodes as s, InputMeta as st, OperationParamsResolver as t, httpMethods as tn, DedupeCanonical as tt, syncSchemaRef as u, OutputNode as ut, PrinterFactoryOptions as v, FunctionNodeType as vt, createArrowFunction as w, ExportNode as wt, definePrinter as x, FunctionParametersNode as xt, PrinterPartial as y, FunctionParamNode as yt, createParamsType as z, SchemaNodeByType as zt };
+//# sourceMappingURL=types-BYujEIxF.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { $ as SchemaDialect, At as IntersectionSchemaNode, Bt as TimeSchemaNode, C as UserFileNode, Ct as FileNode, Dt as DateSchemaNode, Et as ArraySchemaNode, Ft as ScalarSchemaType, Gt as CodeNode, Ht as UrlSchemaNode, It as SchemaNode, Jt as JSDocNode, Kt as ConstNode, Lt as SchemaNodeByType, Mt as ObjectSchemaNode, Nt as PrimitiveSchemaType, Ot as DatetimeSchemaNode, Pt as RefSchemaNode, Qt as NodeKind, Rt as SchemaType, S as DistributiveOmit, St as ExportNode, Tt as SourceNode, Ut as PropertyNode, Vt as UnionSchemaNode, Wt as ArrowFunctionNode, X as ParserOptions, Xt as TextNode, Y as InferSchemaNode, Yt as JsxNode, Z as DispatchRule, Zt as TypeNode, _ as Printer, _t as FunctionParamNode, at as InputMeta, bt as ParameterGroupNode, ct as OutputNode, d as ParentOf, dt as OperationNode, f as Visitor, ft as ResponseNode, gt as FunctionNodeType, ht as ParameterNode, it as Node, jt as NumberSchemaNode, kt as EnumSchemaNode, lt as HttpMethod, mt as ParameterLocation, ot as InputNode, p as VisitorContext, pt as StatusCode, qt as FunctionNode, st as InputStreamNode, t as OperationParamsResolver, tt as DedupePlan, ut as HttpOperationNode, v as PrinterFactoryOptions, vt as FunctionParameterNode, wt as ImportNode, xt as ParamsTypeNode, y as PrinterPartial, yt as FunctionParametersNode, zt as StringSchemaNode } from "./types-IHUK_alM.js";
-export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupePlan, DispatchRule, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, InputStreamNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };
+import { $ as SchemaDialect, $t as TypeNode, At as DatetimeSchemaNode, Bt as SchemaType, C as UserFileNode, Ct as ParamsTypeNode, Dt as SourceNode, Et as ImportNode, Ft as PrimitiveSchemaType, Gt as PropertyNode, Ht as TimeSchemaNode, It as RefSchemaNode, Jt as ConstNode, Kt as ArrowFunctionNode, Lt as ScalarSchemaType, Mt as IntersectionSchemaNode, Nt as NumberSchemaNode, Ot as ArraySchemaNode, Pt as ObjectSchemaNode, Qt as TextNode, Rt as SchemaNode, S as DistributiveOmit, St as ParameterGroupNode, Tt as FileNode, Ut as UnionSchemaNode, Vt as StringSchemaNode, Wt as UrlSchemaNode, X as ParserOptions, Xt as JSDocNode, Y as InferSchemaNode, Yt as FunctionNode, Z as DispatchRule, Zt as JsxNode, _ as Printer, _t as ParameterNode, bt as FunctionParameterNode, ct as InputNode, d as ParentOf, dt as HttpMethod, en as NodeKind, f as Visitor, ft as HttpOperationNode, gt as ParameterLocation, ht as StatusCode, jt as EnumSchemaNode, kt as DateSchemaNode, lt as InputStreamNode, mt as ResponseNode, nt as DedupeLookups, ot as Node, p as VisitorContext, pt as OperationNode, qt as CodeNode, rt as DedupePlan, st as InputMeta, t as OperationParamsResolver, tt as DedupeCanonical, ut as OutputNode, v as PrinterFactoryOptions, vt as FunctionNodeType, wt as ExportNode, xt as FunctionParametersNode, y as PrinterPartial, yt as FunctionParamNode, zt as SchemaNodeByType } from "./types-BYujEIxF.js";
+export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupeLookups, DedupePlan, DispatchRule, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, InputStreamNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.53",
+  "version": "5.0.0-beta.54",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",

package/src/dedupe.ts

@@ -1,6 +1,7 @@
 import { createSchema } from './factory.ts'
 import type { Node, OperationNode, SchemaNode } from './nodes/index.ts'
 import { signatureOf } from './signature.ts'
+import { extractRefName } from './utils/index.ts'
 import { collectLazy, transform } from './visitor.ts'
 
 /**
@@ -28,6 +29,11 @@ export type DedupePlan = {
    * Maps a structural signature to the canonical schema that represents it.
    */
   canonicalBySignature: Map<string, DedupeCanonical>
+  /**
+   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
+   * references to the duplicate can be repointed at the first schema with the same content.
+   */
+  aliasNames: Map<string, DedupeCanonical>
   /**
    * New top-level schema definitions created for inline shapes that had no existing
    * named component. Nested duplicates inside each definition are already collapsed.
@@ -35,6 +41,11 @@ export type DedupePlan = {
   hoisted: Array<SchemaNode>
 }
 
+/**
+ * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
+ */
+export type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>
+
 /**
  * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
  * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
@@ -86,25 +97,35 @@ function createRefNode(node: SchemaNode, canonical: DedupeCanonical): SchemaNode
 /**
  * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
  * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again.
+ * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
+ * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
+ * the same content.
  *
  * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
  * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
- * const next = applyDedupe(operationNode, plan.canonicalBySignature)
+ * const next = applyDedupe(operationNode, plan)
  * ```
  */
-export function applyDedupe(node: SchemaNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): SchemaNode
-export function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): OperationNode
-export function applyDedupe(node: Node, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch = false): Node {
-  if (canonicalBySignature.size === 0) return node
+export function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode
+export function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode
+export function applyDedupe(node: Node, plan: DedupeLookups, skipRootMatch = false): Node {
+  const { canonicalBySignature, aliasNames } = plan
+  if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node
 
   const root = node
 
   return transform(node, {
     schema(schemaNode) {
+      if (schemaNode.type === 'ref') {
+        const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name
+        const canonical = target ? aliasNames.get(target) : undefined
+
+        return canonical ? { ...schemaNode, name: canonical.name, ref: canonical.ref } : undefined
+      }
+
       const signature = signatureOf(schemaNode)
       if (skipRootMatch && schemaNode === root) return undefined
 
@@ -128,9 +149,11 @@ function cleanDefinition(node: SchemaNode, name: string): SchemaNode {
  * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
  *
  * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, that name becomes the canonical (so other top-level duplicates
- * and inline copies turn into references to it). Otherwise a new definition is hoisted using
- * `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+ * is a named top-level schema, the first one becomes the canonical (so other top-level
+ * duplicates and inline copies turn into references to it). Every other top-level name with
+ * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+ * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+ * per node with {@link applyDedupe}.
  *
  * @example
  * ```ts
@@ -149,7 +172,7 @@ export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupe
   type Group = {
     count: number
     representative: SchemaNode
-    topLevelName?: string
+    topLevelNames: Array<string>
   }
   const groups = new Map<string, Group>()
 
@@ -161,9 +184,9 @@ export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupe
     const group = groups.get(signature)
     if (group) {
       group.count++
-      if (isTopLevel && !group.topLevelName) group.topLevelName = schemaNode.name!
+      if (isTopLevel) group.topLevelNames.push(schemaNode.name!)
     } else {
-      groups.set(signature, { count: 1, representative: schemaNode, topLevelName: isTopLevel ? schemaNode.name! : undefined })
+      groups.set(signature, { count: 1, representative: schemaNode, topLevelNames: isTopLevel ? [schemaNode.name!] : [] })
     }
   }
 
@@ -175,13 +198,19 @@ export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupe
   }
 
   const canonicalBySignature = new Map<string, DedupeCanonical>()
+  const aliasNames = new Map<string, DedupeCanonical>()
   const pendingHoists: Array<{ name: string; representative: SchemaNode }> = []
 
   for (const [signature, group] of groups) {
     if (group.count < minOccurrences) continue
 
-    if (group.topLevelName) {
-      canonicalBySignature.set(signature, { name: group.topLevelName, ref: refFor(group.topLevelName) })
+    const [firstName, ...duplicateNames] = group.topLevelNames
+    if (firstName) {
+      const canonical: DedupeCanonical = { name: firstName, ref: refFor(firstName) }
+      canonicalBySignature.set(signature, canonical)
+      for (const duplicate of duplicateNames) {
+        aliasNames.set(duplicate, canonical)
+      }
       continue
     }
 
@@ -194,7 +223,9 @@ export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupe
 
   // Build hoisted definitions only after every canonical name is known, so nested
   // duplicates inside a definition also resolve to refs.
-  const hoisted = pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, canonicalBySignature, true), name))
+  const hoisted = pendingHoists.map(({ name, representative }) =>
+    cleanDefinition(applyDedupe(representative, { canonicalBySignature, aliasNames }, true), name),
+  )
 
-  return { canonicalBySignature, hoisted }
+  return { canonicalBySignature, aliasNames, hoisted }
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-export type { DedupePlan } from './dedupe.ts'
+export type { DedupeCanonical, DedupeLookups, DedupePlan } from './dedupe.ts'
 export type { SchemaDialect } from './dialect.ts'
 export type { DispatchRule } from './dispatch.ts'
 export type { DistributiveOmit } from './factory.ts'