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

package/LICENSE

@@ -1,14 +1,21 @@
-Copyright (c) 2026 Stijn Van Hulle
-
-This repository contains software under two licenses:
+MIT License
 
-1. Most of the code in this repository is licensed under the
-   MIT License — see licenses/LICENSE-MIT for the full license text.
+Copyright (c) 2026 Stijn Van Hulle
 
-2. The following components are licensed under the
-   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
-   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-   - packages/agent (published as @kubb/agent)
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Each package's own LICENSE file or package.json specifies its applicable license.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,17 +1,16 @@
 <div align="center">
-  <h1>@kubb/ast</h1>
   <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
-    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+    <img src="https://kubb.dev/og.png" alt="Kubb banner">
   </a>
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
+[![Stars][stars-src]][stars-href]
 [![License][license-src]][license-href]
-[![Sponsors][sponsors-src]][sponsors-href]
+[![Node][node-src]][node-href]
 
 <h4>
-<a href="https://kubb.dev/" target="_blank">Documentation</a>
+<a href="https://kubb.dev" target="_blank">Documentation</a>
 <span> · </span>
 <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
 <span> · </span>
@@ -19,14 +18,22 @@
 </h4>
 </div>
 
-Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, factory functions, and type guards used across codegen plugins.
+<br />
+
+# @kubb/ast
+
+### Spec-agnostic AST layer for Kubb
+
+Defines the node tree, visitor pattern, factory functions, and type guards used across every Kubb code generation plugin.
 
 ## Imports
 
-| Path              | Contents                                                            |
-| ----------------- | ------------------------------------------------------------------- |
-| `@kubb/ast`       | Runtime: factory functions, guards, visitor, ref helpers, constants |
-| `@kubb/ast/types` | Types only: all node interfaces, type aliases, visitor types        |
+| Path                | Contents                                                                                 |
+| ------------------- | ---------------------------------------------------------------------------------------- |
+| `@kubb/ast`         | Runtime: node definitions, guards, visitor, transformers, constants                      |
+| `@kubb/ast/factory` | Node constructors (`createSchema`, `createFile`, and friends), the `ts.factory` analogue |
+| `@kubb/ast/types`   | Types only: all node interfaces, type aliases, visitor types                             |
+| `@kubb/ast/utils`   | Spec-agnostic string and identifier helpers, ref helpers                                 |
 
 ## Node tree
 
@@ -51,10 +58,12 @@ SchemaNode (discriminated union)
 
 ### Factory
 
+Constructors live on the `@kubb/ast/factory` subpath, mirroring `ts.factory.createX`. Through `@kubb/core` the same set is reachable as `ast.factory.createSchema(...)`.
+
 ```ts
-import { createRoot, createOperation, createSchema, createProperty } from '@kubb/ast'
+import { createInput, createSchema, createProperty } from '@kubb/ast/factory'
 
-const root = createRoot({
+const root = createInput({
   schemas: [
     createSchema({
       name: 'Pet',
@@ -106,11 +115,11 @@ const types = collect<string>(root, {
 ### Guards
 
 ```ts
-import { isSchemaNode, narrowSchema } from '@kubb/ast'
+import { narrowSchema, schemaDef } from '@kubb/ast'
 import type { Node } from '@kubb/ast/types'
 
 function process(node: Node) {
-  if (isSchemaNode(node)) {
+  if (schemaDef.is(node)) {
     const obj = narrowSchema(node, 'object')
     obj?.properties?.forEach((p) => console.log(p.name))
   }
@@ -120,17 +129,27 @@ function process(node: Node) {
 ### Refs
 
 ```ts
-import { buildRefMap, resolveRef } from '@kubb/ast'
+import { extractRefName } from '@kubb/ast/utils'
 
-const refMap = buildRefMap(root)
-const pet = resolveRef(refMap, 'Pet')
+extractRefName('#/components/schemas/Pet') // 'Pet'
 ```
 
+## Adding a node
+
+Adding a node touches three files. The barrels and visitor tables derive the rest.
+
+1. Define the node in its own `src/nodes/*.ts` file. Call `defineNode` and export the resulting `fooDef`, the `createFoo` constructor, and the node's type.
+2. Add `fooDef` to the `nodeDefs` array in `src/registry.ts`.
+3. Re-export `createFoo` from `src/factory.ts`.
+
+Everything else follows from there. `@kubb/ast/types` picks up the node type through `export type *`, the `@kubb/ast` barrel picks up `fooDef` through `export * from './registry.ts'`, and the visitor tables (`VISITOR_KEYS`, `VISITOR_KEY_BY_KIND`, `nodeRebuilders`) come from the def's `children`, `visitorKey`, and `rebuild` fields. `registry.test.ts` fails when a def has no matching `factory.create*`, so missing wiring is caught in CI.
+
 ## Supporting Kubb
 
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+- [See sponsorship tiers and our sponsors](https://kubb.dev/sponsors)
 
 <p align="center">
   <a href="https://github.com/sponsors/stijnvanhulle">
@@ -138,15 +157,19 @@ Kubb uses an MIT-licensed open source project with its ongoing development made
   </a>
 </p>
 
+## License
+
+[MIT](https://github.com/kubb-labs/kubb/blob/main/licenses/LICENSE-MIT)
+
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/ast?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/ast
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/ast?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/ast
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[npm-version-src]: https://shieldcn.dev/npm/v/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-version-href]: https://npmx.dev/package/@kubb/ast
+[npm-downloads-src]: https://shieldcn.dev/npm/dm/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-downloads-href]: https://npmx.dev/package/@kubb/ast
+[stars-src]: https://shieldcn.dev/github/stars/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[stars-href]: https://github.com/kubb-labs/kubb
+[license-src]: https://shieldcn.dev/npm/license/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc
 [license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/ast
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+[node-src]: https://shieldcn.dev/npm/node/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[node-href]: https://npmx.dev/package/@kubb/ast

package/dist/chunk-CNktS9qV.js

@@ -0,0 +1,17 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __name as n, __exportAll as t };

package/dist/extractStringsFromNodes-WMYJ8nQL.d.ts

@@ -0,0 +1,82 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+import { Pt as CodeNode, _t as SchemaNode } from "./index-BzjwdK2M.js";
+
+//#region src/transformers.d.ts
+/**
+ * Replaces a discriminator property's schema with a string enum of allowed values.
+ *
+ * If `node` is not an object schema, or if the property does not exist, the input
+ * node is returned as-is.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({
+ *   type: 'object',
+ *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+ * })
+ * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+ * ```
+ */
+declare function setDiscriminatorEnum({
+  node,
+  propertyName,
+  values,
+  enumName
+}: {
+  node: SchemaNode;
+  propertyName: string;
+  values: Array<string>;
+  enumName?: string;
+}): SchemaNode;
+/**
+ * Merges adjacent anonymous object members into a single anonymous object member.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeAdjacentObjects([
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+ * ])
+ * ```
+ */
+declare function mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined>;
+/**
+ * Removes enum members that are covered by broader scalar primitives in the same union.
+ *
+ * @example
+ * ```ts
+ * const simplified = simplifyUnion([
+ *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+ *   createSchema({ type: 'string' }),
+ * ])
+ * // keeps only string member
+ * ```
+ */
+declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
+declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
+/**
+ * Merges a ref node with its resolved schema, giving usage-site fields precedence.
+ *
+ * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
+ * the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
+ *
+ * @example
+ * ```ts
+ * // Ref with description override
+ * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+ * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
+ * ```
+ */
+declare function syncSchemaRef(node: SchemaNode): SchemaNode;
+//#endregion
+//#region src/utils/extractStringsFromNodes.d.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.
+ */
+declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
+//#endregion
+export { simplifyUnion as a, setEnumName as i, mergeAdjacentObjectsLazy as n, syncSchemaRef as o, setDiscriminatorEnum as r, extractStringsFromNodes as t };
+//# sourceMappingURL=extractStringsFromNodes-WMYJ8nQL.d.ts.map

package/dist/factory-Cl8Z7mcc.cjs

@@ -0,0 +1,299 @@
+const require_response = require("./response-DS5S3IG4.cjs");
+let node_crypto = require("node:crypto");
+let node_path = require("node:path");
+node_path = require_response.__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 src/utils/fileMerge.ts
+function sourceKey(source) {
+	return `${source.name ?? require_response.extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	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) {
+	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.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	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(existing, incoming) {
+	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.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	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 = {
+					...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.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	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 = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	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 = {
+					...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;
+}
+//#endregion
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ require_response.__exportAll({
+	createArrowFunction: () => require_response.createArrowFunction,
+	createBreak: () => require_response.createBreak,
+	createConst: () => require_response.createConst,
+	createContent: () => require_response.createContent,
+	createExport: () => require_response.createExport,
+	createFile: () => createFile,
+	createFunction: () => require_response.createFunction,
+	createFunctionParameter: () => require_response.createFunctionParameter,
+	createFunctionParameters: () => require_response.createFunctionParameters,
+	createImport: () => require_response.createImport,
+	createIndexedAccessType: () => require_response.createIndexedAccessType,
+	createInput: () => require_response.createInput,
+	createJsx: () => require_response.createJsx,
+	createObjectBindingPattern: () => require_response.createObjectBindingPattern,
+	createOperation: () => require_response.createOperation,
+	createOutput: () => require_response.createOutput,
+	createParameter: () => require_response.createParameter,
+	createProperty: () => require_response.createProperty,
+	createRequestBody: () => require_response.createRequestBody,
+	createResponse: () => require_response.createResponse,
+	createSchema: () => require_response.createSchema,
+	createSource: () => require_response.createSource,
+	createText: () => require_response.createText,
+	createType: () => require_response.createType,
+	createTypeLiteral: () => require_response.createTypeLiteral,
+	update: () => update
+});
+/**
+* Identity-preserving node update: returns `node` unchanged when every field in
+* `changes` already equals (by reference) the current value, otherwise a new node
+* with the changes applied.
+*
+* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
+* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is
+* shallow: a structurally-equal but newly-allocated array/object counts as a change.
+*
+* @example
+* ```ts
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* ```
+*/
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
+	};
+	return node;
+}
+/**
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
+*
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
+*
+* @throws {Error} when `baseName` has no extension.
+*
+* @example
+* ```ts
+* const file = createFile({
+*   baseName: 'petStore.ts',
+*   path: 'src/models/petStore.ts',
+*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+*   imports: [createImport({ name: ['z'], path: 'zod' })],
+*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+* })
+* // file.id      = SHA256 hash of 'src/models/petStore.ts'
+* // file.name    = 'petStore'
+* // file.extname = '.ts'
+* ```
+*/
+function createFile(input) {
+	const extname = node_path.default.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => require_response.extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
+	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
+		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
+		if (!kept.length) return [];
+		return [kept.length === imp.name.length ? imp : {
+			...imp,
+			name: kept
+		}];
+	});
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createFile", {
+	enumerable: true,
+	get: function() {
+		return createFile;
+	}
+});
+Object.defineProperty(exports, "factory_exports", {
+	enumerable: true,
+	get: function() {
+		return factory_exports;
+	}
+});
+Object.defineProperty(exports, "update", {
+	enumerable: true,
+	get: function() {
+		return update;
+	}
+});
+
+//# sourceMappingURL=factory-Cl8Z7mcc.cjs.map

package/dist/factory-Cl8Z7mcc.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-Cl8Z7mcc.cjs","names":["extractStringsFromNodes","path","extractStringsFromNodes"],"sources":["../../../internals/utils/src/fs.ts","../src/utils/fileMerge.ts","../src/factory.ts"],"sourcesContent":["import { existsSync } from 'node:fs'\nimport { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises'\nimport { dirname, join, posix, resolve } from 'node:path'\nimport { camelCase } from './casing.ts'\nimport { runtime } from './runtime.ts'\n\n/**\n * Walks up the directory tree from `cwd` (defaults to `process.cwd()`) and\n * returns the absolute path of the nearest `package.json`, or `null` when none\n * is found before reaching the filesystem root.\n *\n * @example\n * ```ts\n * const pkgPath = findPackageJSON('/home/user/project/src') // '/home/user/project/package.json'\n * ```\n */\nexport function findPackageJSON(cwd?: string): string | null {\n  let dir = cwd ? resolve(cwd) : process.cwd()\n  while (true) {\n    const pkgPath = join(dir, 'package.json')\n    if (existsSync(pkgPath)) return pkgPath\n    const parent = dirname(dir)\n    if (parent === dir) return null\n    dir = parent\n  }\n}\n\n/**\n * Converts all backslashes to forward slashes.\n * Extended-length Windows paths (`\\\\?\\...`) are left unchanged.\n */\nfunction toSlash(p: string): string {\n  if (p.startsWith('\\\\\\\\?\\\\')) return p\n\n  return p.replaceAll('\\\\', '/')\n}\n\n/**\n * Returns the relative path from `rootDir` to `filePath`, always using forward slashes\n * and prefixed with `./` when not already traversing upward.\n *\n * @example\n * ```ts\n * getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'\n * getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'\n * ```\n */\nexport function getRelativePath(rootDir?: string | null, filePath?: string | null): string {\n  if (!rootDir || !filePath) {\n    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)\n  }\n\n  const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath))\n\n  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`\n}\n\n/**\n * Resolves to `true` when the file or directory at `path` exists.\n * Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.\n *\n * @example\n * ```ts\n * if (await exists('./kubb.config.ts')) {\n *   const content = await read('./kubb.config.ts')\n * }\n * ```\n */\nexport async function exists(path: string): Promise<boolean> {\n  if (runtime.isBun) {\n    return Bun.file(path).exists()\n  }\n  return access(path).then(\n    () => true,\n    () => false,\n  )\n}\n\n/**\n * Reads the file at `path` as a UTF-8 string.\n * Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.\n *\n * @example\n * ```ts\n * const source = await read('./src/Pet.ts')\n * ```\n */\nexport async function read(path: string): Promise<string> {\n  if (runtime.isBun) {\n    return Bun.file(path).text()\n  }\n  return readFile(path, { encoding: 'utf8' })\n}\n\ntype WriteOptions = {\n  /**\n   * When `true`, re-reads the file immediately after writing and throws if the\n   * content does not match — useful for catching write failures on unreliable file systems.\n   */\n  sanity?: boolean\n}\n\n/**\n * Writes `data` to `path`, trimming leading/trailing whitespace before saving.\n * Skips the write when the trimmed content is empty or identical to what is already on disk.\n * Creates any missing parent directories automatically.\n * When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.\n *\n * @example\n * ```ts\n * await write('./src/Pet.ts', source)         // writes and returns trimmed content\n * await write('./src/Pet.ts', source)         // null — file unchanged\n * await write('./src/Pet.ts', '  ')           // null — empty content skipped\n * ```\n */\nexport async function write(path: string, data: string, options: WriteOptions = {}): Promise<string | null> {\n  const trimmed = data.trim()\n  if (trimmed === '') return null\n\n  const resolved = resolve(path)\n\n  if (runtime.isBun) {\n    const file = Bun.file(resolved)\n    const oldContent = (await file.exists()) ? await file.text() : null\n    if (oldContent === trimmed) return null\n    await Bun.write(resolved, trimmed)\n    return trimmed\n  }\n\n  try {\n    const oldContent = await readFile(resolved, { encoding: 'utf-8' })\n    if (oldContent === trimmed) return null\n  } catch {\n    /* file doesn't exist yet */\n  }\n\n  await mkdir(dirname(resolved), { recursive: true })\n  await writeFile(resolved, trimmed, { encoding: 'utf-8' })\n\n  if (options.sanity) {\n    const savedData = await readFile(resolved, { encoding: 'utf-8' })\n    if (savedData !== trimmed) {\n      throw new Error(`Sanity check failed for ${path}\\n\\nData[${data.length}]:\\n${data}\\n\\nSaved[${savedData.length}]:\\n${savedData}\\n`)\n    }\n    return savedData\n  }\n\n  return trimmed\n}\n\n/**\n * Recursively removes `path`. Silently succeeds when `path` does not exist.\n *\n * @example\n * ```ts\n * await clean('./dist')\n * ```\n */\nexport async function clean(path: string): Promise<void> {\n  return rm(path, { recursive: true, force: true })\n}\n\n/**\n * Converts a filesystem path to use POSIX (`/`) separators.\n *\n * Most of the codebase compares and composes paths as strings (prefix matching, joining for\n * import specifiers, splitting on `/`). On POSIX `path.resolve` already returns `/`-separated\n * paths, but on Windows it returns `\\`-separated paths, which breaks every such comparison.\n *\n * Routing every path that crosses a module boundary through `toPosixPath` keeps the rest of the\n * code platform-agnostic. The conversion runs unconditionally so Windows-specific behavior is\n * exercisable from POSIX CI.\n *\n * @example\n * toPosixPath('C:\\\\repo\\\\src\\\\pet.ts') // 'C:/repo/src/pet.ts'\n */\nexport function toPosixPath(filePath: string): string {\n  return filePath.replaceAll('\\\\', '/')\n}\n\n/**\n * Strips the file extension from a path or file name.\n * Only removes the last `.ext` segment when the dot is not part of a directory name.\n *\n * @example\n * trimExtName('petStore.ts')             // 'petStore'\n * trimExtName('/src/models/pet.ts')      // '/src/models/pet'\n * trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'\n * trimExtName('noExtension')             // 'noExtension'\n */\nexport function trimExtName(text: string): string {\n  const dotIndex = text.lastIndexOf('.')\n  if (dotIndex > 0 && !text.includes('/', dotIndex)) {\n    return text.slice(0, dotIndex)\n  }\n  return text\n}\n\n/**\n * Builds a nested file path from a dotted name. Splits on dots that precede a letter\n * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases\n * every earlier segment, applies `caseLast` to the final segment, and joins with `/`.\n *\n * Empty segments are dropped before joining. They arise when the name starts with a dot\n * followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to\n * an empty string). Without this a leading `/` would form, which `path.resolve` reads as an\n * absolute path, letting generated files escape the configured output directory.\n *\n * @example Nested path from a dotted name\n * `toFilePath('pet.petId') // 'pet/petId'`\n *\n * @example PascalCase the final segment\n * `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`\n *\n * @example Suffix applied to the final segment only\n * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`\n */\nexport function toFilePath(name: string, caseLast: (part: string) => string = camelCase): string {\n  const parts = name.split(/\\.(?=[a-zA-Z])/)\n  return parts\n    .map((part, i) => (i === parts.length - 1 ? caseLast(part) : camelCase(part)))\n    .filter(Boolean)\n    .join('/')\n}\n","/**\n * File-member merging. `combineImports`, `combineExports`, and `combineSources` deduplicate and sort\n * the import, export, and source entries of one file, and drop imports nothing references. This works\n * on a file's members, not on schema content.\n *\n * For collapsing duplicate schema shapes by structural signature, see `dedupe.ts`.\n */\nimport type { ExportNode, ImportNode, SourceNode } from '../nodes/index.ts'\nimport { extractStringsFromNodes } from './extractStringsFromNodes.ts'\n\nfunction sourceKey(source: SourceNode): string {\n  const nameKey = source.name ?? extractStringsFromNodes(source.nodes)\n  return `${nameKey}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`\n}\n\nfunction pathTypeKey(path: string, isTypeOnly: boolean | null | undefined): string {\n  return `${path}:${isTypeOnly ?? false}`\n}\n\nfunction exportKey(path: string, name: string | null | undefined, isTypeOnly: boolean | null | undefined, asAlias: boolean | null | undefined): string {\n  return `${path}:${name ?? ''}:${isTypeOnly ?? false}:${asAlias ?? ''}`\n}\n\nfunction importKey(path: string, name: string | null | undefined, isTypeOnly: boolean | null | undefined): string {\n  return `${path}:${name ?? ''}:${isTypeOnly ?? false}`\n}\n\n/**\n * Computes a multi-level sort key for exports and imports:\n * non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.\n */\nfunction sortKey(node: { name?: string | Array<unknown> | null; isTypeOnly?: boolean | null; path: string }): string {\n  const isArray = Array.isArray(node.name) ? '1' : '0'\n  const typeOnly = node.isTypeOnly ? '0' : '1'\n  const hasName = node.name != null ? '1' : '0'\n  const name = Array.isArray(node.name) ? node.name.toSorted().join('\\0') : (node.name ?? '')\n  return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`\n}\n\n/**\n * Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.\n *\n * Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.\n */\nexport function combineSources(sources: Array<SourceNode>): Array<SourceNode> {\n  const seen = new Map<string, SourceNode>()\n  for (const source of sources) {\n    const key = sourceKey(source)\n    if (!seen.has(key)) seen.set(key, source)\n  }\n  return [...seen.values()]\n}\n\n/**\n * Merges `incoming` names into `existing`, preserving order and dropping duplicates.\n *\n * Shared by `combineExports` and `combineImports` for the same-path name-merge case.\n */\nfunction mergeNameArrays<TName>(existing: Array<TName>, incoming: Array<TName>): Array<TName> {\n  const merged = new Set(existing)\n  for (const name of incoming) merged.add(name)\n  return [...merged]\n}\n\n/**\n * Deduplicates and merges `ExportNode` objects by path and type.\n *\n * Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.\n * Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.\n */\nexport function combineExports(exports: Array<ExportNode>): Array<ExportNode> {\n  const result: Array<ExportNode> = []\n  // Accumulates array-named exports keyed by `path:isTypeOnly` for name-merging\n  const namedByPath = new Map<string, ExportNode>()\n  // Deduplicates non-array exports by their exact identity\n  const seen = new Set<string>()\n\n  // Precompute sort keys once, avoids recomputing per comparison.\n  const keyed = exports.map((node) => ({ node, key: sortKey(node) }))\n  keyed.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))\n\n  for (const { node: curr } of keyed) {\n    const { name, path, isTypeOnly, asAlias } = curr\n\n    if (Array.isArray(name)) {\n      if (!name.length) continue\n\n      const key = pathTypeKey(path, isTypeOnly)\n      const existing = namedByPath.get(key)\n\n      if (existing && Array.isArray(existing.name)) {\n        existing.name = mergeNameArrays(existing.name, name)\n      } else {\n        const newItem: ExportNode = { ...curr, name: [...new Set(name)] }\n        result.push(newItem)\n        namedByPath.set(key, newItem)\n      }\n    } else {\n      const key = exportKey(path, name, isTypeOnly, asAlias)\n      if (!seen.has(key)) {\n        result.push(curr)\n        seen.add(key)\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Deduplicates and merges `ImportNode` objects, filtering out unused imports.\n *\n * Retains imports that are referenced in `source` or re-exported. Imports with the same path and\n * `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.\n */\nexport function combineImports(imports: Array<ImportNode>, exports: Array<ExportNode>, source?: string): Array<ImportNode> {\n  // Build a lookup of all exported names to retain imports that are re-exported\n  const exportedNames = new Set(exports.flatMap((e) => (Array.isArray(e.name) ? e.name : e.name ? [e.name] : [])))\n  const isUsed = (importName: string): boolean => !source || source.includes(importName) || exportedNames.has(importName)\n\n  // Memoize object import names so the same logical (propertyName, name) pair always\n  // reuses the same object reference. Set-based deduplication then works correctly.\n  const importNameMemo = new Map<string, { propertyName: string; name?: string }>()\n  const canonicalizeName = (n: string | { propertyName: string; name?: string }): string | { propertyName: string; name?: string } => {\n    if (typeof n === 'string') return n\n    const key = `${n.propertyName}:${n.name ?? ''}`\n    if (!importNameMemo.has(key)) importNameMemo.set(key, n)\n    return importNameMemo.get(key)!\n  }\n\n  // Paths that keep at least one used named import. A default import from such a path is retained\n  // even when its binding can't be found in `source` e.g. a generated `client` default import\n  // alongside `import type { Client } from <same path>`, where merged grouped output omits the body.\n  const pathsWithUsedNamedImport = new Set<string>()\n  for (const node of imports) {\n    if (!Array.isArray(node.name)) continue\n    if (node.name.some((item) => (typeof item === 'string' ? isUsed(item) : isUsed(item.name ?? item.propertyName)))) {\n      pathsWithUsedNamedImport.add(node.path)\n    }\n  }\n\n  const result: Array<ImportNode> = []\n  // Accumulates array-named imports keyed by `path:isTypeOnly` for name-merging\n  const namedByPath = new Map<string, ImportNode>()\n  // Deduplicates non-array imports by their exact identity\n  const seen = new Set<string>()\n\n  // Precompute sort keys once, avoids recomputing per comparison.\n  const keyed = imports.map((node) => ({ node, key: sortKey(node) }))\n  keyed.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))\n\n  for (const { node: curr } of keyed) {\n    if (curr.path === curr.root) continue\n\n    const { path, isTypeOnly } = curr\n    let { name } = curr\n\n    if (Array.isArray(name)) {\n      name = [...new Set(name.map(canonicalizeName))].filter((item) => (typeof item === 'string' ? isUsed(item) : isUsed(item.name ?? item.propertyName)))\n      if (!name.length) continue\n\n      const key = pathTypeKey(path, isTypeOnly)\n      const existing = namedByPath.get(key)\n\n      if (existing && Array.isArray(existing.name)) {\n        existing.name = mergeNameArrays(existing.name, name)\n      } else {\n        const newItem: ImportNode = { ...curr, name }\n        result.push(newItem)\n        namedByPath.set(key, newItem)\n      }\n    } else {\n      if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue\n\n      const key = importKey(path, name, isTypeOnly)\n      if (!seen.has(key)) {\n        result.push(curr)\n        seen.add(key)\n      }\n    }\n  }\n\n  return result\n}\n","import { hash } from 'node:crypto'\nimport path from 'node:path'\nimport { trimExtName } from '@internals/utils'\nimport type { FileNode, Node } from './nodes/index.ts'\nimport { extractStringsFromNodes } from './utils/extractStringsFromNodes.ts'\nimport { combineExports, combineImports, combineSources } from './utils/fileMerge.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createImport, createSource } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the\n * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is\n * shallow: a structurally-equal but newly-allocated array/object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n\n/**\n * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed\n * and `imports`/`exports`/`sources` are deduplicated.\n */\nexport type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> &\n  Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>\n\n/**\n * Creates a fully resolved `FileNode` from a file input descriptor.\n *\n * Computes:\n * - `id` SHA256 hash of the file path\n * - `name` `baseName` without extension\n * - `extname` extension extracted from `baseName`\n *\n * Deduplicates:\n * - `sources` via `combineSources`\n * - `exports` via `combineExports`\n * - `imports` via `combineImports` (also filters unused imports)\n *\n * @throws {Error} when `baseName` has no extension.\n *\n * @example\n * ```ts\n * const file = createFile({\n *   baseName: 'petStore.ts',\n *   path: 'src/models/petStore.ts',\n *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],\n *   imports: [createImport({ name: ['z'], path: 'zod' })],\n *   exports: [createExport({ name: ['Pet'], path: './petStore' })],\n * })\n * // file.id      = SHA256 hash of 'src/models/petStore.ts'\n * // file.name    = 'petStore'\n * // file.extname = '.ts'\n * ```\n */\nexport function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta> {\n  const rawExtname = path.extname(input.baseName)\n  // Handle dotfile basename like '.ts' where path.extname returns ''\n  const extname = (rawExtname || (input.baseName.startsWith('.') ? input.baseName : '')) as `.${string}`\n  if (!extname) {\n    throw new Error(`No extname found for ${input.baseName}`)\n  }\n\n  const source = (input.sources ?? [])\n    .flatMap((item) => item.nodes ?? [])\n    .map((node) => extractStringsFromNodes([node]))\n    .filter(Boolean)\n    .join('\\n\\n')\n  const resolvedExports = input.exports?.length ? combineExports(input.exports) : []\n  const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || undefined) : []\n  const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name): name is string => Boolean(name)))\n  const nameOf = (item: string | { propertyName: string; name?: string }): string => (typeof item === 'string' ? item : (item.name ?? item.propertyName))\n  // Drop self-imports. Consolidating output (`mode: 'file'`) can place a symbol's\n  // definition and a cross-file import of it in the same file. The first pass catches imports that\n  // resolve to this file's own path. The second drops imports of names the file already defines,\n  // the case consolidation produces when the import path no longer matches `input.path`. Sources\n  // stay intact, so the local definition remains. Bare specifiers like `'zod'` never match a path.\n  const resolvedImports = combinedImports\n    .filter((imp) => imp.path !== input.path)\n    .flatMap((imp) => {\n      if (!Array.isArray(imp.name)) {\n        return typeof imp.name === 'string' && localNames.has(imp.name) ? [] : [imp]\n      }\n      const kept = imp.name.filter((item) => !localNames.has(nameOf(item)))\n      if (!kept.length) return []\n      return [kept.length === imp.name.length ? imp : { ...imp, name: kept }]\n    })\n  const resolvedSources = input.sources?.length ? combineSources(input.sources) : []\n\n  return {\n    kind: 'File',\n    ...input,\n    id: hash('sha256', input.path, 'hex'),\n    name: trimExtName(input.baseName),\n    extname,\n    imports: resolvedImports,\n    exports: resolvedExports,\n    sources: resolvedSources,\n    meta: input.meta ?? ({} as TMeta),\n  }\n}\n"],"mappings":"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"}