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

package/dist/index.cjs

@@ -470,141 +470,6 @@ function memoize(store, factory) {
 	};
 }
 //#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = /* @__PURE__ */ new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
-}
-/**
-* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
-*
-* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
-* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
-* deciding whether an object key needs quoting.
-*
-* @example
-* ```ts
-* isIdentifier('name')   // true
-* isIdentifier('x-total')// false
-* ```
-*/
-function isIdentifier(name) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/string.ts
-/**
-* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
-* any backslash or single quote in the content.
-*
-* @example
-* ```ts
-* singleQuote('foo')      // "'foo'"
-* singleQuote("o'clock")  // "'o\\'clock'"
-* ```
-*/
-function singleQuote(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-}
-//#endregion
 //#region src/utils/extractStringsFromNodes.ts
 /**
 * Extracts all string content from a `CodeNode` tree recursively.
@@ -641,7 +506,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 +738,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 +763,7 @@ function createFile(input) {
 				name: kept
 			}];
 		});
-	}
+	})();
 	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
 	return {
 		kind: "File",
@@ -924,31 +796,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
@@ -1592,74 +1449,35 @@ function createPrinter(build) {
 	};
 }
 //#endregion
-//#region src/utils/codegen.ts
-/**
-* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
-* comments.
-*
-* @example
-* ```ts
-* buildJSDoc(['@type string', '@example hello'])
-* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
-* ```
-*/
-function buildJSDoc(comments, options = {}) {
-	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
-	if (comments.length === 0) return fallback;
-	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
-}
+//#region src/utils/mergeAdjacentSchemas.ts
 /**
-* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
-*/
-function indentLines(text) {
-	if (!text) return "";
-	return text.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
-}
-/**
-* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
-* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
-*
-* @example
-* ```ts
-* objectKey('name')    // 'name'
-* objectKey('x-total') // "'x-total'"
-* ```
-*/
-function objectKey(name) {
-	return isIdentifier(name) ? name : singleQuote(name);
-}
-/**
-* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
-* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
-* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
-*
-* @example
-* ```ts
-* buildObject(['id: z.number()', 'name: z.string()'])
-* // '{\n  id: z.number(),\n  name: z.string(),\n}'
-* ```
-*/
-function buildObject(entries) {
-	if (entries.length === 0) return "{}";
-	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
-}
-/**
-* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
-* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
-* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
-* as `z.union([…])` and `z.array([…])`.
+* 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
-* buildList(['z.string()', 'z.number()'])
-* // '[z.string(), z.number()]'
+* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
 * ```
 */
-function buildList(items, brackets = ["[", "]"]) {
-	const [open, close] = brackets;
-	if (items.length === 0) return `${open}${close}`;
-	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
-	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+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
@@ -1758,151 +1576,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 +1648,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,20 +1754,6 @@ function mapSchemaItems(node, transform) {
 		output: transform(schema)
 	}));
 }
-/**
-* 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/macros/macroDiscriminatorEnum.ts
 /**
@@ -2270,12 +1929,12 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	applyMacros: () => applyMacros,
 	arrowFunctionDef: () => arrowFunctionDef,
 	breakDef: () => breakDef,
-	buildJSDoc: () => buildJSDoc,
-	buildList: () => buildList,
-	buildObject: () => buildObject,
 	childName: () => childName,
 	collect: () => collect,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
+	combineExports: () => combineExports,
+	combineImports: () => combineImports,
+	combineSources: () => combineSources,
 	composeMacros: () => composeMacros,
 	constDef: () => constDef,
 	containsCircularRef: () => containsCircularRef,
@@ -2292,15 +1951,11 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	fileDef: () => fileDef,
 	findCircularSchemas: () => findCircularSchemas,
 	functionDef: () => functionDef,
-	getNestedAccessor: () => getNestedAccessor,
 	importDef: () => importDef,
 	inputDef: () => inputDef,
 	isHttpOperationNode: () => isHttpOperationNode,
 	isStringType: () => isStringType,
-	isValidVarName: () => isValidVarName,
-	jsStringEscape: () => jsStringEscape,
 	jsxDef: () => jsxDef,
-	lazyGetter: () => lazyGetter,
 	macroDiscriminatorEnum: () => macroDiscriminatorEnum,
 	macroEnumName: () => macroEnumName,
 	macroSimplifyUnion: () => macroSimplifyUnion,
@@ -2310,7 +1965,6 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	mergeAdjacentObjectsLazy: () => mergeAdjacentObjectsLazy,
 	narrowSchema: () => narrowSchema,
 	nodeDefs: () => nodeDefs,
-	objectKey: () => objectKey,
 	operationDef: () => operationDef,
 	optionality: () => optionality,
 	outputDef: () => outputDef,
@@ -2321,13 +1975,9 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	schemaDef: () => schemaDef,
 	schemaTypes: () => schemaTypes,
 	sourceDef: () => sourceDef,
-	stringify: () => stringify,
-	stringifyObject: () => stringifyObject,
 	syncSchemaRef: () => syncSchemaRef,
 	textDef: () => textDef,
-	toRegExpString: () => toRegExpString,
 	transform: () => transform,
-	trimQuotes: () => trimQuotes,
 	typeDef: () => typeDef,
 	walk: () => walk
 });
@@ -2341,12 +1991,12 @@ Object.defineProperty(exports, "ast", {
 	}
 });
 exports.breakDef = breakDef;
-exports.buildJSDoc = buildJSDoc;
-exports.buildList = buildList;
-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;
@@ -2368,15 +2018,11 @@ Object.defineProperty(exports, "factory", {
 exports.fileDef = fileDef;
 exports.findCircularSchemas = findCircularSchemas;
 exports.functionDef = functionDef;
-exports.getNestedAccessor = getNestedAccessor;
 exports.importDef = importDef;
 exports.inputDef = inputDef;
 exports.isHttpOperationNode = isHttpOperationNode;
 exports.isStringType = isStringType;
-exports.isValidVarName = isValidVarName;
-exports.jsStringEscape = jsStringEscape;
 exports.jsxDef = jsxDef;
-exports.lazyGetter = lazyGetter;
 exports.macroDiscriminatorEnum = macroDiscriminatorEnum;
 exports.macroEnumName = macroEnumName;
 exports.macroSimplifyUnion = macroSimplifyUnion;
@@ -2386,7 +2032,6 @@ exports.mapSchemaProperties = mapSchemaProperties;
 exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
 exports.nodeDefs = nodeDefs;
-exports.objectKey = objectKey;
 exports.operationDef = operationDef;
 exports.optionality = optionality;
 exports.outputDef = outputDef;
@@ -2397,13 +2042,9 @@ exports.responseDef = responseDef;
 exports.schemaDef = schemaDef;
 exports.schemaTypes = schemaTypes;
 exports.sourceDef = sourceDef;
-exports.stringify = stringify;
-exports.stringifyObject = stringifyObject;
 exports.syncSchemaRef = syncSchemaRef;
 exports.textDef = textDef;
-exports.toRegExpString = toRegExpString;
 exports.transform = transform;
-exports.trimQuotes = trimQuotes;
 exports.typeDef = typeDef;
 exports.walk = walk;