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

package/dist/index.cjs

@@ -1,8 +1,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-CMRZrT-w.cjs");
+const require_utils = require("./utils-cdQ6Pzyi.cjs");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = require_utils.__toESM(node_path, 1);
+//#region ../../internals/utils/src/fs.ts
+/**
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+//#endregion
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -1055,7 +1072,7 @@ function createInput(overrides = {}) {
 	};
 }
 /**
-* Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
 *
 * @example
 * ```ts
@@ -1482,7 +1499,7 @@ function createFile(input) {
 		kind: "File",
 		...input,
 		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
-		name: require_utils.trimExtName(input.baseName),
+		name: trimExtName(input.baseName),
 		extname,
 		imports: resolvedImports,
 		exports: resolvedExports,
@@ -1678,9 +1695,7 @@ function createJsx(value) {
 //#endregion
 //#region src/signature.ts
 /**
-* The shape-affecting flags shared by every node kind: base primitive, format, and `nullable`.
-* Documentation and usage-slot flags (`optional`/`nullish`/`readOnly`/`writeOnly`) are
-* intentionally excluded, they describe the property slot, not the type.
+* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
 */
 function flagsDescriptor(node) {
 	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
@@ -1753,9 +1768,8 @@ const rangeFields = [{
 	prefix: "mx"
 }];
 /**
-* Maps each schema node `type` to the ordered list of shape-contributing fields.
-* Node types absent from this map (scalar types like boolean, null, any, etc.) fall
-* back to `${type}|${flags}` with no additional fields.
+* 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 = {
 	object: [
@@ -1892,9 +1906,8 @@ function serializeShapeField(field, node, record) {
 	}
 }
 /**
-* Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
-* children's signatures. {@link signatureOf} hashes this string. Children contribute their
-* fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
+* constraints, and its children's signatures.
 */
 function describeShape(node) {
 	const flags = flagsDescriptor(node);
@@ -1906,22 +1919,23 @@ function describeShape(node) {
 	return parts.join("|");
 }
 /**
-* Persistent hash-consing cache: `SchemaNode` → signature digest, keyed by node identity.
-*
-* A `WeakMap` so entries are released once the node is garbage-collected, and so a node hashed
-* during dedupe planning is not re-hashed when the same tree is rewritten during streaming
-* (where `schemaSignature` and `applyDedupe` would otherwise each walk it from scratch). Reuse
-* across calls is sound because a signature depends only on a node's content, and schema nodes
-* are immutable once created, transforms allocate new objects rather than mutating in place.
+* Node → digest cache, 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 = /* @__PURE__ */ new WeakMap();
 /**
-* Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
-* children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
-* full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
-* digest is identical across calls because it depends only on content, never on traversal
-* order. This keeps the keys built during planning consistent with the ones recomputed later
-* during streaming. {@link signatureCache} memoizes node → digest across every computation.
+* 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'] }))
+* ```
 */
 function signatureOf(node) {
 	const cached = signatureCache.get(node);
@@ -1930,24 +1944,6 @@ function signatureOf(node) {
 	signatureCache.set(node, signature);
 	return signature;
 }
-/**
-* Computes a deterministic, shape-only signature (a fixed-length 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. `ref` nodes compare by target name,
-* which also keeps the algorithm terminating on circular shapes.
-*
-* @example Two enums with different descriptions share a signature
-* ```ts
-* schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
-*   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
-* ```
-*/
-function schemaSignature(node) {
-	return signatureOf(node);
-}
 //#endregion
 //#region src/dedupe.ts
 /**
@@ -1969,10 +1965,20 @@ function createRefNode(node, canonical) {
 		example: node.example
 	});
 }
-function applyDedupe(node, canonicalBySignature, skipRootMatch = false) {
-	if (canonicalBySignature.size === 0) return node;
+function applyDedupe(node, plan, skipRootMatch = false) {
+	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 ? require_utils.extractRefName(schemaNode.ref) : schemaNode.name;
+			const canonical = target ? aliasNames.get(target) : void 0;
+			return canonical ? {
+				...schemaNode,
+				name: canonical.name,
+				ref: canonical.ref
+			} : void 0;
+		}
 		const signature = signatureOf(schemaNode);
 		if (skipRootMatch && schemaNode === root) return void 0;
 		const canonical = canonicalBySignature.get(signature);
@@ -1996,9 +2002,11 @@ function cleanDefinition(node, name) {
 * 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
@@ -2020,11 +2028,11 @@ function buildDedupePlan(roots, options) {
 		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 : void 0
+			topLevelNames: isTopLevel ? [schemaNode.name] : []
 		});
 	}
 	for (const root of roots) {
@@ -2032,14 +2040,18 @@ function buildDedupePlan(roots, options) {
 		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
 	}
 	const canonicalBySignature = /* @__PURE__ */ new Map();
+	const aliasNames = /* @__PURE__ */ new Map();
 	const pendingHoists = [];
 	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 = {
+				name: firstName,
+				ref: refFor(firstName)
+			};
+			canonicalBySignature.set(signature, canonical);
+			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
 			continue;
 		}
 		const name = nameFor(group.representative, signature);
@@ -2055,15 +2067,18 @@ function buildDedupePlan(roots, options) {
 	}
 	return {
 		canonicalBySignature,
-		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, canonicalBySignature, true), name))
+		aliasNames,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
+			canonicalBySignature,
+			aliasNames
+		}, true), name))
 	};
 }
 //#endregion
 //#region src/dialect.ts
 /**
-* Identity helper that types a {@link SchemaDialect} for an adapter. Like
-* `defineParser`, it adds no runtime behavior, it pins the dialect's type for
-* inference and gives adapter authors a discoverable anchor.
+* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
 * @example
 * ```ts
@@ -2081,38 +2096,6 @@ function defineSchemaDialect(dialect) {
 	return dialect;
 }
 //#endregion
-//#region src/dispatch.ts
-/**
-* Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
-*
-* This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
-* The contract an adapter follows is intentionally minimal:
-*
-*     context → [rule.match → rule.convert] → node
-*
-* An adapter derives a context from a source spec node, then declares an ordered table of
-* rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
-* context type and a new rules table, the traversal here is reused unchanged.
-*
-* Order is significant: earlier rules win, so list higher-precedence or more specific shapes
-* first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
-* may still `convert` to `null` to defer to later rules. When no rule produces a node this
-* returns `null`, leaving the caller to apply its own fallback.
-*
-* @example
-* ```ts
-* const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
-* ```
-*/
-function dispatch(rules, context) {
-	for (const rule of rules) {
-		if (!rule.match(context)) continue;
-		const node = rule.convert(context);
-		if (node !== null && node !== void 0) return node;
-	}
-	return null;
-}
-//#endregion
 //#region src/printer.ts
 /**
 * Defines a schema printer: a function that takes a `SchemaNode` and emits
@@ -2190,21 +2173,6 @@ function createPrinterFactory(getKey) {
 	};
 }
 //#endregion
-//#region src/resolvers.ts
-/**
-* Collects import entries for all `ref` schema nodes in `node`.
-*/
-function collectImports({ node, nameMapping, resolve }) {
-	return collect(node, { schema(schemaNode) {
-		const schemaRef = narrowSchema(schemaNode, "ref");
-		if (!schemaRef?.ref) return null;
-		const rawName = require_utils.extractRefName(schemaRef.ref);
-		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return null;
-		return result;
-	} });
-}
-//#endregion
 //#region src/transformers.ts
 /**
 * Replaces a discriminator property's schema with a string enum of allowed values.
@@ -2316,7 +2284,6 @@ exports.applyDedupe = applyDedupe;
 exports.buildDedupePlan = buildDedupePlan;
 exports.caseParams = caseParams;
 exports.collect = collect;
-exports.collectImports = collectImports;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
@@ -2347,7 +2314,6 @@ exports.createText = createText;
 exports.createType = createType;
 exports.definePrinter = definePrinter;
 exports.defineSchemaDialect = defineSchemaDialect;
-exports.dispatch = dispatch;
 exports.extractStringsFromNodes = extractStringsFromNodes;
 exports.findCircularSchemas = findCircularSchemas;
 exports.httpMethods = require_utils.httpMethods;
@@ -2359,10 +2325,10 @@ exports.isSchemaNode = isSchemaNode;
 exports.isStringType = isStringType;
 exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
-exports.schemaSignature = schemaSignature;
 exports.schemaTypes = require_utils.schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;
 exports.setEnumName = setEnumName;
+exports.signatureOf = signatureOf;
 exports.simplifyUnion = simplifyUnion;
 exports.syncOptionality = syncOptionality;
 exports.syncSchemaRef = syncSchemaRef;