@kubb/ast 5.0.0-beta.84 → 5.0.0-beta.85

package/dist/index.cjs

@@ -641,7 +641,7 @@ function extractStringsFromNodes(nodes) {
 	return collected.join("\n");
 }
 //#endregion
-//#region src/utils/fileMerge.ts
+//#region src/utils/combineFileMembers.ts
 function sourceKey(source) {
 	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
 }
@@ -873,16 +873,23 @@ const createSource = sourceDef.create;
 * ```
 */
 function createFile(input) {
-	const extname = node_path.default.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	const extname = node_path.default.extname(input.baseName);
 	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
 	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	let resolvedImports = [];
-	if (input.imports?.length) {
-		const source = extractStringsFromNodes((input.sources ?? []).flatMap((item) => item.nodes ?? [])) || void 0;
+	const resolvedImports = (() => {
+		if (!input.imports?.length) return [];
+		const sourceParts = [];
+		const localNames = /* @__PURE__ */ new Set();
+		for (const item of input.sources ?? []) {
+			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
+			if (extracted) sourceParts.push(extracted);
+			if (item.name) localNames.add(item.name);
+		}
+		const source = sourceParts.join("\n") || void 0;
 		const combinedImports = combineImports(input.imports, resolvedExports, source);
-		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;
-		resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+		return combinedImports.flatMap((imp) => {
+			if (imp.path === input.path) return [];
 			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 [];
@@ -891,7 +898,7 @@ function createFile(input) {
 				name: kept
 			}];
 		});
-	}
+	})();
 	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
 	return {
 		kind: "File",
@@ -924,31 +931,16 @@ const inputDef = defineNode({
 	visitorKey: "input"
 });
 /**
-* Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
-* `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
-* `schemas`/`operations`. Both variants get the defaulted `meta`.
+* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` per
+* {@link inputDef}.
 *
-* @example Eager
+* @example
 * ```ts
 * const input = createInput()
 * // { kind: 'Input', schemas: [], operations: [] }
 * ```
-*
-* @example Streaming
-* ```ts
-* const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
-* ```
 */
-function createInput(options = {}) {
-	const { stream, ...overrides } = options;
-	if (stream) return {
-		kind: "Input",
-		meta: {
-			circularNames: [],
-			enumNames: []
-		},
-		...overrides
-	};
+function createInput(overrides = {}) {
 	return inputDef.create(overrides);
 }
 //#endregion
@@ -1661,6 +1653,51 @@ function buildList(items, brackets = ["[", "]"]) {
 	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
 	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
 }
+/**
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
+*
+* @example
+* ```ts
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
+* ```
+*/
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region src/utils/mergeAdjacentSchemas.ts
+/**
+* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
+* run and pass through unchanged. The merge follows member order, so callers control which members
+* combine by where they place them in the sequence.
+*
+* @example
+* ```ts
+* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
+* ```
+*/
+function* mergeAdjacentObjectsLazy(members) {
+	let acc;
+	for (const member of members) {
+		const objectMember = narrowSchema(member, "object");
+		if (objectMember && !objectMember.name && acc !== void 0) {
+			const accObject = narrowSchema(acc, "object");
+			if (accObject && !accObject.name) {
+				acc = createSchema({
+					...accObject,
+					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
+				});
+				continue;
+			}
+		}
+		if (acc !== void 0) yield acc;
+		acc = member;
+	}
+	if (acc !== void 0) yield acc;
+}
 //#endregion
 //#region src/utils/refs.ts
 const plainStringTypes = /* @__PURE__ */ new Set([
@@ -1758,151 +1795,6 @@ function isStringType(node) {
 	return false;
 }
 //#endregion
-//#region src/utils/schemaMerge.ts
-/**
-* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
-* run and pass through unchanged. The merge follows member order, so callers control which members
-* combine by where they place them in the sequence.
-*
-* @example
-* ```ts
-* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
-* ```
-*/
-function* mergeAdjacentObjectsLazy(members) {
-	let acc;
-	for (const member of members) {
-		const objectMember = narrowSchema(member, "object");
-		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = narrowSchema(acc, "object");
-			if (accObject && !accObject.name) {
-				acc = createSchema({
-					...accObject,
-					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
-				});
-				continue;
-			}
-		}
-		if (acc !== void 0) yield acc;
-		acc = member;
-	}
-	if (acc !== void 0) yield acc;
-}
-//#endregion
-//#region src/utils/strings.ts
-/**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
-*
-* @example
-* ```ts
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
-* ```
-*/
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
-}
-/**
-* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
-*
-* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
-* code matches the repo style without a formatter.
-*
-* @example
-* ```ts
-* stringify('hello')   // "'hello'"
-* stringify('"hello"') // "'hello'"
-* ```
-*/
-function stringify(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
-}
-/**
-* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
-* and the Unicode line terminators U+2028 and U+2029.
-*
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-*
-* @example
-* ```ts
-* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
-* ```
-*/
-function jsStringEscape(input) {
-	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-		switch (character) {
-			case "\"":
-			case "'":
-			case "\\": return `\\${character}`;
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "\u2028": return "\\u2028";
-			case "\u2029": return "\\u2029";
-			default: return "";
-		}
-	});
-}
-/**
-* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
-* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
-* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
-*
-* @example
-* ```ts
-* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
-* toRegExpString('^(?im)foo', null) // '/^foo/im'
-* ```
-*/
-function toRegExpString(text, func = "RegExp") {
-	const raw = trimQuotes(text);
-	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
-	const replacementTarget = match?.[1] ?? "";
-	const matchedFlags = match?.[2];
-	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
-	const { source, flags } = new RegExp(cleaned, matchedFlags);
-	if (func === null) return `/${source}/${flags}`;
-	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
-}
-/**
-* Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested
-* objects recurse with fixed indentation, so the result drops straight into an object literal
-* without re-parsing.
-*
-* @example
-* ```ts
-* stringifyObject({ foo: 'bar', nested: { a: 1 } })
-* // 'foo: bar,\nnested: {\n        a: 1\n      }'
-* ```
-*/
-function stringifyObject(value) {
-	return Object.entries(value).map(([key, val]) => {
-		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
-		return `${key}: ${val}`;
-	}).filter(Boolean).join(",\n");
-}
-/**
-* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
-* `accessor`. Returns `null` for an empty path.
-*
-* @example
-* ```ts
-* getNestedAccessor('pagination.next.id', 'lastPage')
-* // "lastPage?.['pagination']?.['next']?.['id']"
-* ```
-*/
-function getNestedAccessor(param, accessor) {
-	const parts = Array.isArray(param) ? param : param.split(".");
-	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
-	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
-}
-//#endregion
 //#region src/utils/schemaGraph.ts
 /**
 * Memoized inner pass that walks a single node and returns the names of every schema it references.
@@ -1975,7 +1867,7 @@ function computeUsedSchemaNames(operations, schemas) {
 *
 * @example Only generate schemas referenced by included operations
 * ```ts
-* const includedOps = operations.filter((op) => resolver.resolveOptions(op, { options, include }) !== null)
+* const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
 * const allowed = collectUsedSchemaNames(includedOps, schemas)
 *
 * for (const schema of schemas) {
@@ -2081,19 +1973,119 @@ function mapSchemaItems(node, transform) {
 		output: transform(schema)
 	}));
 }
+//#endregion
+//#region src/utils/strings.ts
 /**
-* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
-* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
-* of a recursive schema until first access.
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
 *
 * @example
 * ```ts
-* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
-* // "get parent() { return z.lazy(() => Pet) }"
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
 * ```
 */
-function lazyGetter({ name, body }) {
-	return `get ${objectKey(name)}() { return ${body} }`;
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
+}
+/**
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+*
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
+*
+* @example
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+/**
+* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+* and the Unicode line terminators U+2028 and U+2029.
+*
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+*
+* @example
+* ```ts
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+/**
+* Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested
+* objects recurse with fixed indentation, so the result drops straight into an object literal
+* without re-parsing.
+*
+* @example
+* ```ts
+* stringifyObject({ foo: 'bar', nested: { a: 1 } })
+* // 'foo: bar,\nnested: {\n        a: 1\n      }'
+* ```
+*/
+function stringifyObject(value) {
+	return Object.entries(value).map(([key, val]) => {
+		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
+		return `${key}: ${val}`;
+	}).filter(Boolean).join(",\n");
+}
+/**
+* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+* `accessor`. Returns `null` for an empty path.
+*
+* @example
+* ```ts
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // "lastPage?.['pagination']?.['next']?.['id']"
+* ```
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 //#endregion
 //#region src/macros/macroDiscriminatorEnum.ts
@@ -2276,6 +2268,9 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	childName: () => childName,
 	collect: () => collect,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
+	combineExports: () => combineExports,
+	combineImports: () => combineImports,
+	combineSources: () => combineSources,
 	composeMacros: () => composeMacros,
 	constDef: () => constDef,
 	containsCircularRef: () => containsCircularRef,
@@ -2347,6 +2342,9 @@ exports.buildObject = buildObject;
 exports.childName = childName;
 exports.collect = collect;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
+exports.combineExports = combineExports;
+exports.combineImports = combineImports;
+exports.combineSources = combineSources;
 exports.composeMacros = composeMacros;
 exports.constDef = constDef;
 exports.containsCircularRef = containsCircularRef;