@kubb/ast 5.0.0-beta.80 → 5.0.0-beta.81

package/dist/utils.cjs

@@ -1,613 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_visitor = require("./visitor-h6dEM3vR.cjs");
-const require_refs = require("./refs-Bg3rmujP.cjs");
-//#region ../../internals/utils/src/promise.ts
-/**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-//#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/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}`;
-}
-/**
-* 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([…])`.
-*
-* @example
-* ```ts
-* buildList(['z.string()', 'z.number()'])
-* // '[z.string(), z.number()]'
-* ```
-*/
-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}`;
-}
-//#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 = require_visitor.narrowSchema(member, "object");
-		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = require_visitor.narrowSchema(acc, "object");
-			if (accObject && !accObject.name) {
-				acc = require_visitor.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.
-*/
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	require_visitor.collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = require_refs.resolveRefName(child);
-			if (name) refs.add(name);
-		}
-	} });
-	return refs;
-});
-/**
-* Collects the names of every ref found anywhere inside a node's own subtree.
-*
-* Each ref contributes its name only, so the schema it points to is never traversed here. Pass `out`
-* to accumulate names from several nodes into one set.
-*
-* @example Collect refs from a single schema
-* ```ts
-* const names = collectReferencedSchemaNames(petSchema)
-* // Set { 'Category', 'Tag' }
-* ```
-*
-* @example Accumulate refs from multiple schemas into one set
-* ```ts
-* const out = new Set<string>()
-* for (const schema of schemas) {
-*   collectReferencedSchemaNames(schema, out)
-* }
-* ```
-*/
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	for (const name of collectSchemaRefs(node)) out.add(name);
-	return out;
-}
-/**
-* Memoized two-level cache keyed first on the operations array, then on the schemas array.
-*/
-const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
-function computeUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		const directRefs = collectReferencedSchemaNames(schema);
-		for (const name of directRefs) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
-	}
-	for (const op of operations) for (const schema of require_visitor.collectLazy(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-/**
-* Collects the names of all top-level schemas transitively used by a set of operations.
-*
-* An operation uses a schema when its parameters, request body, or responses reference it, directly
-* or through other named schemas. Once a name is added to the result it is not revisited, so
-* reference cycles terminate.
-*
-* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
-*
-* @example Only generate schemas referenced by included operations
-* ```ts
-* const includedOps = operations.filter((op) => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-*
-* for (const schema of schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // generate schema
-* }
-* ```
-*/
-function collectUsedSchemaNames(operations, schemas) {
-	return collectUsedSchemaNamesMemo(operations)(schemas);
-}
-const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
-		}
-	}
-	return circular;
-});
-/**
-* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
-*
-* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
-* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
-* linear in the size of the schema graph.
-*
-* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
-*/
-function findCircularSchemas(schemas) {
-	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
-	return findCircularSchemasMemo(schemas);
-}
-/**
-* Returns `true` when a schema, or anything nested inside it, references a circular schema.
-*
-* Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled
-* on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.
-*
-* @note Stops at the first matching circular ref.
-*/
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of require_visitor.collectLazy(node, { schema(child) {
-		if (child.type !== "ref") return null;
-		const name = require_refs.resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
-	} })) return true;
-	return false;
-}
-//#endregion
-//#region src/utils/schemaTraversal.ts
-/**
-* Maps each property of an object schema to its transformed output. Pairs every result with the
-* original property so the printer keeps full control over modifiers, getters, and key syntax.
-*
-* @example
-* ```ts
-* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
-* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
-* ```
-*/
-function mapSchemaProperties(node, transform) {
-	return node.properties.map((property) => ({
-		name: property.name,
-		property,
-		output: transform(property.schema)
-	}));
-}
-/**
-* Maps each member of a union or intersection schema to its transformed output, pairing every
-* result with the original member.
-*/
-function mapSchemaMembers(node, transform) {
-	return (node.members ?? []).map((schema) => ({
-		schema,
-		output: transform(schema)
-	}));
-}
-/**
-* Maps each item of an array or tuple schema to its transformed output, pairing every result with
-* the original item.
-*/
-function mapSchemaItems(node, transform) {
-	return (node.items ?? []).map((schema) => ({
-		schema,
-		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
-exports.buildJSDoc = buildJSDoc;
-exports.buildList = buildList;
-exports.buildObject = buildObject;
-exports.childName = require_refs.childName;
-exports.collectUsedSchemaNames = collectUsedSchemaNames;
-exports.containsCircularRef = containsCircularRef;
-exports.enumPropName = require_refs.enumPropName;
-exports.extractRefName = require_refs.extractRefName;
-exports.extractStringsFromNodes = require_visitor.extractStringsFromNodes;
-exports.findCircularSchemas = findCircularSchemas;
-exports.getNestedAccessor = getNestedAccessor;
-exports.isStringType = require_refs.isStringType;
-exports.isValidVarName = isValidVarName;
-exports.jsStringEscape = jsStringEscape;
-exports.lazyGetter = lazyGetter;
-exports.mapSchemaItems = mapSchemaItems;
-exports.mapSchemaMembers = mapSchemaMembers;
-exports.mapSchemaProperties = mapSchemaProperties;
-exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
-exports.objectKey = objectKey;
-exports.stringify = stringify;
-exports.stringifyObject = stringifyObject;
-exports.syncSchemaRef = require_refs.syncSchemaRef;
-exports.toRegExpString = toRegExpString;
-exports.trimQuotes = trimQuotes;
-
-//# sourceMappingURL=utils.cjs.map