@kubb/kit 5.0.0-beta.100

package/dist/index.cjs

@@ -0,0 +1,627 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#endregion
+let _kubb_ast = require("@kubb/ast");
+let _kubb_core = require("@kubb/core");
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#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/Url.ts
+function transformParam(raw) {
+	return isValidVarName(raw) ? raw : camelCase(raw);
+}
+/**
+* Renders how a grouped `path` object's member is accessed: dot access for a valid
+* identifier, bracket access with the raw name otherwise.
+*/
+function groupedAccessor(name) {
+	return isValidVarName(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+}
+function toParamsObject(path, { replacer } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1]);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
+/**
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+*/
+var Url = class Url {
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
+	*
+	* @example
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
+	*/
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
+	*/
+	static toTemplateString(path, { prefix, replacer } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off a
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``.
+	* Parameter names are kept exactly as they appear in the OpenAPI path; a name falls back to
+	* bracket access (`` path['pet-id'] ``) only when it isn't a valid JS identifier.
+	* `prefix` is prepended inside the literal. Shared by generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*
+	* @example
+	* Url.toGroupedTemplateString('/user/{monetary-account-id}') // '`/user/${path["monetary-account-id"]}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => i % 2 === 0 ? part : `\${path${groupedAccessor(part)}}`).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
+	*
+	* @example
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	*/
+	static toObject(path, { type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, { replacer }),
+			params: toParamsObject(path, { replacer })
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+};
+//#endregion
+//#region src/macros/macroDiscriminatorEnum.ts
+/**
+* Builds a macro that replaces a discriminator property's schema with a string enum of the given
+* values. Object schemas that lack the property are returned unchanged.
+*
+* @example
+* ```ts
+* const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })
+* const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })
+* ```
+*/
+function macroDiscriminatorEnum({ propertyName, values, enumName }) {
+	return _kubb_ast.ast.defineMacro({
+		name: "discriminator-enum",
+		schema(node) {
+			const objectNode = _kubb_ast.ast.narrowSchema(node, "object");
+			if (!objectNode?.properties?.length) return void 0;
+			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
+			return _kubb_ast.ast.factory.createSchema({
+				...objectNode,
+				properties: objectNode.properties.map((prop) => {
+					if (prop.name !== propertyName) return prop;
+					return _kubb_ast.ast.factory.createProperty({
+						...prop,
+						schema: _kubb_ast.ast.factory.createSchema({
+							type: "enum",
+							primitive: "string",
+							enumValues: values,
+							name: enumName,
+							readOnly: prop.schema.readOnly,
+							writeOnly: prop.schema.writeOnly
+						})
+					});
+				})
+			});
+		}
+	});
+}
+//#endregion
+//#region src/utils/refs.ts
+const plainStringTypes = /* @__PURE__ */ new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns the last path segment of a reference string.
+*
+* @example
+* `extractRefName('#/components/schemas/Pet') // 'Pet'`
+*/
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
+}
+/**
+* Builds a PascalCase child schema name by joining a parent name and property name.
+* Returns `null` when there is no parent to nest under.
+*
+* @example Nested under a parent
+* `childName('Order', 'shipping_address') // 'OrderShippingAddress'`
+*
+* @example No parent
+* `childName(undefined, 'params') // null`
+*/
+function childName(parentName, propName) {
+	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
+}
+/**
+* Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any
+* empty parts.
+*
+* @example
+* `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`
+*/
+function enumPropName(parentName, propName, enumSuffix) {
+	return pascalCase([
+		parentName,
+		propName,
+		enumSuffix
+	].filter(Boolean).join(" "));
+}
+/**
+* Merges a ref node with its resolved schema, giving usage-site fields precedence.
+*
+* Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the
+* same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,
+* `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref
+* nodes and refs without a resolved `schema` are returned unchanged.
+*
+* @example
+* ```ts
+* const ref = ast.factory.createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+* const merged = syncSchemaRef(ref) // merges with resolved Pet schema
+* ```
+*/
+function syncSchemaRef(node) {
+	const ref = _kubb_ast.ast.narrowSchema(node, "ref");
+	if (!ref) return node;
+	if (!ref.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+	return _kubb_ast.ast.factory.createSchema({
+		...ref.schema,
+		...definedOverrides
+	});
+}
+/**
+* Returns `true` when a schema emits as a plain `string` type.
+*
+* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
+* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+*/
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = _kubb_ast.ast.narrowSchema(node, "date") ?? _kubb_ast.ast.narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+//#endregion
+//#region src/macros/macroEnumName.ts
+/**
+* Builds a macro that names an inline enum schema from its parent and property name. Boolean enums
+* are left anonymous. Non-enum nodes are returned unchanged.
+*
+* @example
+* ```ts
+* const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })
+* const named = applyMacros(propSchema, [macro], { depth: 'shallow' })
+* ```
+*/
+function macroEnumName({ parentName, propName, enumSuffix }) {
+	return _kubb_ast.ast.defineMacro({
+		name: "enum-name",
+		schema(node) {
+			const enumNode = _kubb_ast.ast.narrowSchema(node, "enum");
+			if (enumNode?.primitive === "boolean") return {
+				...node,
+				name: null
+			};
+			if (enumNode) return {
+				...node,
+				name: enumPropName(parentName, propName, enumSuffix)
+			};
+		}
+	});
+}
+//#endregion
+//#region src/macros/macroRenameSchema.ts
+/**
+* Builds a macro that renames a schema consistently: the declaration (`name`) and every ref
+* pointing at it (`targetName`) change together, so imports and printed references stay in
+* sync. Renaming only one side by hand produces imports for files that are never generated.
+*
+* @example
+* `const macro = macroRenameSchema({ from: 'Order', to: 'StoreOrder' })`
+*/
+function macroRenameSchema({ from, to }) {
+	return _kubb_ast.ast.defineMacro({
+		name: "rename-schema",
+		schema(node) {
+			const refNode = _kubb_ast.ast.narrowSchema(node, "ref");
+			if (!refNode) return node.name === from ? {
+				...node,
+				name: to
+			} : void 0;
+			const renamesDeclaration = refNode.name === from;
+			const renamesTarget = _kubb_ast.ast.resolveRefName(refNode) === from;
+			if (!renamesDeclaration && !renamesTarget) return void 0;
+			return {
+				...refNode,
+				...renamesDeclaration ? { name: to } : {},
+				...renamesTarget ? { targetName: to } : {}
+			};
+		}
+	});
+}
+//#endregion
+//#region src/macros/macroSimplifyUnion.ts
+/**
+* Scalar primitive schema types used for union simplification and type narrowing.
+*/
+const SCALAR_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
+/**
+* Filters union members, dropping enum members that a broader scalar primitive already covers.
+*/
+function simplifyUnionMembers(members) {
+	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
+	if (!scalarPrimitives.size) return members;
+	return members.filter((member) => {
+		const enumNode = _kubb_ast.ast.narrowSchema(member, "enum");
+		if (!enumNode) return true;
+		const primitive = enumNode.primitive;
+		if (!primitive) return true;
+		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
+		if (scalarPrimitives.has(primitive)) return false;
+		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
+		return true;
+	});
+}
+/**
+* Removes union members a broader scalar primitive already covers, such as a multi-value string enum
+* sitting next to a plain `string`. Single-value enums are kept.
+*
+* @example
+* ```ts
+* const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
+* ```
+*/
+const macroSimplifyUnion = _kubb_ast.ast.defineMacro({
+	name: "simplify-union",
+	schema(node) {
+		const unionNode = _kubb_ast.ast.narrowSchema(node, "union");
+		if (!unionNode?.members?.length) return void 0;
+		const simplified = simplifyUnionMembers(unionNode.members);
+		if (simplified.length === unionNode.members.length) return void 0;
+		return {
+			...unionNode,
+			members: simplified
+		};
+	}
+});
+//#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 = _kubb_ast.ast.narrowSchema(member, "object");
+		if (objectMember && !objectMember.name && acc !== void 0) {
+			const accObject = _kubb_ast.ast.narrowSchema(acc, "object");
+			if (accObject && !accObject.name) {
+				acc = _kubb_ast.ast.factory.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/schemaGraph.ts
+/**
+* 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 `ast.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 _kubb_ast.ast.collect(node, { schema(child) {
+		if (child.type !== "ref") return null;
+		const name = _kubb_ast.ast.resolveRefName(child);
+		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
+	} })) return true;
+	return false;
+}
+//#endregion
+Object.defineProperty(exports, "Diagnostics", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.Diagnostics;
+	}
+});
+Object.defineProperty(exports, "Hookable", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.Hookable;
+	}
+});
+Object.defineProperty(exports, "Resolver", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.Resolver;
+	}
+});
+exports.Url = Url;
+Object.defineProperty(exports, "ast", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.ast;
+	}
+});
+exports.childName = childName;
+exports.containsCircularRef = containsCircularRef;
+Object.defineProperty(exports, "createAdapter", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.createAdapter;
+	}
+});
+Object.defineProperty(exports, "createRenderer", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.createRenderer;
+	}
+});
+Object.defineProperty(exports, "createResolver", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.createResolver;
+	}
+});
+Object.defineProperty(exports, "createStorage", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.createStorage;
+	}
+});
+Object.defineProperty(exports, "defineGenerator", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.defineGenerator;
+	}
+});
+Object.defineProperty(exports, "defineParser", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.defineParser;
+	}
+});
+Object.defineProperty(exports, "definePlugin", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.definePlugin;
+	}
+});
+exports.enumPropName = enumPropName;
+exports.extractRefName = extractRefName;
+Object.defineProperty(exports, "fsStorage", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.fsStorage;
+	}
+});
+exports.isStringType = isStringType;
+exports.macroDiscriminatorEnum = macroDiscriminatorEnum;
+exports.macroEnumName = macroEnumName;
+exports.macroRenameSchema = macroRenameSchema;
+exports.macroSimplifyUnion = macroSimplifyUnion;
+Object.defineProperty(exports, "memoryStorage", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.memoryStorage;
+	}
+});
+exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
+exports.syncSchemaRef = syncSchemaRef;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["ast","ast","ast","ast","ast","ast","ast"],"sources":["../../../internals/utils/src/casing.ts","../../../internals/utils/src/reserved.ts","../../../internals/utils/src/Url.ts","../src/macros/macroDiscriminatorEnum.ts","../src/utils/refs.ts","../src/macros/macroEnumName.ts","../src/macros/macroRenameSchema.ts","../src/macros/macroSimplifyUnion.ts","../src/utils/mergeAdjacentSchemas.ts","../src/utils/schemaGraph.ts"],"sourcesContent":["type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n *\n * @example\n * ```ts\n * isValidVarName('status')  // true\n * isValidVarName('class')   // false (reserved word)\n * isValidVarName('42foo')   // false (starts with digit)\n * ```\n */\nexport function isValidVarName(name: string): boolean {\n  if (!name || reservedWords.has(name as 'valueOf')) {\n    return false\n  }\n  return isIdentifier(name)\n}\n\n/**\n * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.\n *\n * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys\n * even though they are not valid variable names, so use this (not {@link isValidVarName}) when\n * deciding whether an object key needs quoting.\n *\n * @example\n * ```ts\n * isIdentifier('name')   // true\n * isIdentifier('x-total')// false\n * ```\n */\nexport function isIdentifier(name: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n}\n","import { camelCase } from './casing.ts'\nimport { isValidVarName } from './reserved.ts'\n\ntype URLObject = {\n  /**\n   * The resolved URL string (Express-style or template literal, depending on context).\n   */\n  url: string\n  /**\n   * Extracted path parameters as a key-value map, or `null` when the path has none.\n   */\n  params: Record<string, string> | null\n}\n\ntype TemplateOptions = {\n  /**\n   * Literal text prepended inside the template literal, e.g. a base URL.\n   */\n  prefix?: string | null\n  /**\n   * Transform applied to each extracted parameter name before interpolation.\n   */\n  replacer?: (pathParam: string) => string\n}\n\ntype ObjectOptions = {\n  /**\n   * Controls whether the `url` is rendered as an Express path or a template literal.\n   * @default 'path'\n   */\n  type?: 'path' | 'template'\n  /**\n   * Transform applied to each extracted parameter name.\n   */\n  replacer?: (pathParam: string) => string\n  /**\n   * When `true`, the result is serialized to a string expression instead of a plain object.\n   */\n  stringify?: boolean\n}\n\nfunction transformParam(raw: string): string {\n  return isValidVarName(raw) ? raw : camelCase(raw)\n}\n\n/**\n * Renders how a grouped `path` object's member is accessed: dot access for a valid\n * identifier, bracket access with the raw name otherwise.\n */\nfunction groupedAccessor(name: string): string {\n  return isValidVarName(name) ? `.${name}` : `[${JSON.stringify(name)}]`\n}\n\nfunction toParamsObject(path: string, { replacer }: { replacer?: (pathParam: string) => string } = {}): Record<string, string> | null {\n  const params: Record<string, string> = {}\n\n  for (const match of path.matchAll(/\\{([^}]+)\\}/g)) {\n    const param = transformParam(match[1]!)\n    const key = replacer ? replacer(param) : param\n    params[key] = key\n  }\n\n  return Object.keys(params).length > 0 ? params : null\n}\n\n/**\n * Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.\n */\nexport class Url {\n  /**\n   * Converts an OpenAPI/Swagger path to Express-style colon syntax.\n   *\n   * @example\n   * Url.toPath('/pet/{petId}') // '/pet/:petId'\n   */\n  static toPath(path: string): string {\n    return path.replace(/\\{([^}]+)\\}/g, ':$1')\n  }\n\n  /**\n   * Converts an OpenAPI/Swagger path to a TypeScript template literal string.\n   * `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.\n   *\n   * @example\n   * Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'\n   *\n   * @example\n   * Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'\n   */\n  static toTemplateString(path: string, { prefix, replacer }: TemplateOptions = {}): string {\n    const parts = path.split(/\\{([^}]+)\\}/)\n    const result = parts\n      .map((part, i) => {\n        if (i % 2 === 0) return part\n        const param = transformParam(part)\n        return `\\${${replacer ? replacer(param) : param}}`\n      })\n      .join('')\n\n    return `\\`${prefix ?? ''}${result}\\``\n  }\n\n  /**\n   * Converts an OpenAPI/Swagger path to a template literal that reads each parameter off a\n   * grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``.\n   * Parameter names are kept exactly as they appear in the OpenAPI path; a name falls back to\n   * bracket access (`` path['pet-id'] ``) only when it isn't a valid JS identifier.\n   * `prefix` is prepended inside the literal. Shared by generators that pass a grouped `path` object.\n   *\n   * @example\n   * Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'\n   *\n   * @example\n   * Url.toGroupedTemplateString('/user/{monetary-account-id}') // '`/user/${path[\"monetary-account-id\"]}`'\n   */\n  static toGroupedTemplateString(path: string, { prefix }: { prefix?: string | null } = {}): string {\n    const parts = path.split(/\\{([^}]+)\\}/)\n    const result = parts.map((part, i) => (i % 2 === 0 ? part : `\\${path${groupedAccessor(part)}}`)).join('')\n\n    return `\\`${prefix ?? ''}${result}\\``\n  }\n\n  /**\n   * Returns the path and its extracted params as a structured `URLObject`, or as a stringified\n   * expression when `stringify` is set.\n   *\n   * @example\n   * Url.toObject('/pet/{petId}')\n   * // { url: '/pet/:petId', params: { petId: 'petId' } }\n   */\n  static toObject(path: string, { type = 'path', replacer, stringify }: ObjectOptions = {}): URLObject | string {\n    const object: URLObject = {\n      url: type === 'path' ? Url.toPath(path) : Url.toTemplateString(path, { replacer }),\n      params: toParamsObject(path, { replacer }),\n    }\n\n    if (stringify) {\n      if (type === 'template') {\n        return JSON.stringify(object).replaceAll(\"'\", '').replaceAll(`\"`, '')\n      }\n\n      if (object.params) {\n        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll(\"'\", '').replaceAll(`\"`, '')} }`\n      }\n\n      return `{ url: '${object.url}' }`\n    }\n\n    return object\n  }\n}\n","import { ast } from '@kubb/ast'\n\ntype Props = {\n  propertyName: string\n  values: Array<string>\n  enumName?: string\n}\n\n/**\n * Builds a macro that replaces a discriminator property's schema with a string enum of the given\n * values. Object schemas that lack the property are returned unchanged.\n *\n * @example\n * ```ts\n * const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })\n * const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })\n * ```\n */\nexport function macroDiscriminatorEnum({ propertyName, values, enumName }: Props) {\n  return ast.defineMacro({\n    name: 'discriminator-enum',\n    schema(node) {\n      const objectNode = ast.narrowSchema(node, 'object')\n      if (!objectNode?.properties?.length) return undefined\n      if (!objectNode.properties.some((prop) => prop.name === propertyName)) return undefined\n\n      return ast.factory.createSchema({\n        ...objectNode,\n        properties: objectNode.properties.map((prop) => {\n          if (prop.name !== propertyName) return prop\n\n          return ast.factory.createProperty({\n            ...prop,\n            schema: ast.factory.createSchema({\n              type: 'enum',\n              primitive: 'string',\n              enumValues: values,\n              name: enumName,\n              readOnly: prop.schema.readOnly,\n              writeOnly: prop.schema.writeOnly,\n            }),\n          })\n        }),\n      })\n    },\n  })\n}\n","import { ast } from '@kubb/ast'\nimport type { SchemaNode, SchemaType } from '@kubb/ast'\nimport { pascalCase } from '@internals/utils'\n\nconst plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)\n\n/**\n * Returns the last path segment of a reference string.\n *\n * @example\n * `extractRefName('#/components/schemas/Pet') // 'Pet'`\n */\nexport function extractRefName(ref: string): string {\n  return ref.split('/').at(-1) ?? ref\n}\n\n/**\n * Builds a PascalCase child schema name by joining a parent name and property name.\n * Returns `null` when there is no parent to nest under.\n *\n * @example Nested under a parent\n * `childName('Order', 'shipping_address') // 'OrderShippingAddress'`\n *\n * @example No parent\n * `childName(undefined, 'params') // null`\n */\nexport function childName(parentName: string | null | undefined, propName: string): string | null {\n  return parentName ? pascalCase([parentName, propName].join(' ')) : null\n}\n\n/**\n * Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any\n * empty parts.\n *\n * @example\n * `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`\n */\nexport function enumPropName(parentName: string | null | undefined, propName: string, enumSuffix: string): string {\n  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))\n}\n\n/**\n * Merges a ref node with its resolved schema, giving usage-site fields precedence.\n *\n * Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the\n * same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,\n * `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref\n * nodes and refs without a resolved `schema` are returned unchanged.\n *\n * @example\n * ```ts\n * const ref = ast.factory.createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })\n * const merged = syncSchemaRef(ref) // merges with resolved Pet schema\n * ```\n */\nexport function syncSchemaRef(node: SchemaNode): SchemaNode {\n  const ref = ast.narrowSchema(node, 'ref')\n\n  if (!ref) return node\n  if (!ref.schema) return node\n\n  const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref\n\n  // Filter out undefined override values so they don't shadow the resolved schema's fields.\n  const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== undefined))\n\n  return ast.factory.createSchema({ ...ref.schema, ...definedOverrides })\n}\n\n/**\n * Returns `true` when a schema emits as a plain `string` type.\n *\n * Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`\n * types, returns `true` only when `representation` is `'string'` rather than `'date'`.\n */\nexport function isStringType(node: SchemaNode): boolean {\n  if (plainStringTypes.has(node.type)) {\n    return true\n  }\n\n  const temporal = ast.narrowSchema(node, 'date') ?? ast.narrowSchema(node, 'time')\n  if (temporal) {\n    return temporal.representation !== 'date'\n  }\n\n  return false\n}\n","import { ast } from '@kubb/ast'\nimport { enumPropName } from '../utils/refs.ts'\n\ntype Props = {\n  parentName: string | null | undefined\n  propName: string\n  enumSuffix: string\n}\n\n/**\n * Builds a macro that names an inline enum schema from its parent and property name. Boolean enums\n * are left anonymous. Non-enum nodes are returned unchanged.\n *\n * @example\n * ```ts\n * const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })\n * const named = applyMacros(propSchema, [macro], { depth: 'shallow' })\n * ```\n */\nexport function macroEnumName({ parentName, propName, enumSuffix }: Props) {\n  return ast.defineMacro({\n    name: 'enum-name',\n    schema(node) {\n      const enumNode = ast.narrowSchema(node, 'enum')\n\n      if (enumNode?.primitive === 'boolean') return { ...node, name: null }\n      if (enumNode) return { ...node, name: enumPropName(parentName, propName, enumSuffix) }\n\n      return undefined\n    },\n  })\n}\n","import { ast } from '@kubb/ast'\n\ntype Props = {\n  from: string\n  to: string\n}\n\n/**\n * Builds a macro that renames a schema consistently: the declaration (`name`) and every ref\n * pointing at it (`targetName`) change together, so imports and printed references stay in\n * sync. Renaming only one side by hand produces imports for files that are never generated.\n *\n * @example\n * `const macro = macroRenameSchema({ from: 'Order', to: 'StoreOrder' })`\n */\nexport function macroRenameSchema({ from, to }: Props) {\n  return ast.defineMacro({\n    name: 'rename-schema',\n    schema(node) {\n      const refNode = ast.narrowSchema(node, 'ref')\n\n      if (!refNode) {\n        return node.name === from ? { ...node, name: to } : undefined\n      }\n\n      const renamesDeclaration = refNode.name === from\n      const renamesTarget = ast.resolveRefName(refNode) === from\n      if (!renamesDeclaration && !renamesTarget) return undefined\n\n      return {\n        ...refNode,\n        ...(renamesDeclaration ? { name: to } : {}),\n        ...(renamesTarget ? { targetName: to } : {}),\n      }\n    },\n  })\n}\n","import { ast } from '@kubb/ast'\nimport type { SchemaNode } from '@kubb/ast'\n\ntype ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'\n\n/**\n * Scalar primitive schema types used for union simplification and type narrowing.\n */\nconst SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])\n\nfunction isScalarPrimitive(type: string): type is ScalarPrimitive {\n  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)\n}\n\n/**\n * Filters union members, dropping enum members that a broader scalar primitive already covers.\n */\nfunction simplifyUnionMembers(members: Array<SchemaNode>): Array<SchemaNode> {\n  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))\n  if (!scalarPrimitives.size) return members\n\n  return members.filter((member) => {\n    const enumNode = ast.narrowSchema(member, 'enum')\n    if (!enumNode) return true\n\n    const primitive = enumNode.primitive\n    if (!primitive) return true\n\n    const enumValueCount = enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0\n    if (enumValueCount <= 1) return true\n\n    if (scalarPrimitives.has(primitive)) return false\n    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) return false\n\n    return true\n  })\n}\n\n/**\n * Removes union members a broader scalar primitive already covers, such as a multi-value string enum\n * sitting next to a plain `string`. Single-value enums are kept.\n *\n * @example\n * ```ts\n * const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })\n * ```\n */\nexport const macroSimplifyUnion = ast.defineMacro({\n  name: 'simplify-union',\n  schema(node) {\n    const unionNode = ast.narrowSchema(node, 'union')\n    if (!unionNode?.members?.length) return undefined\n\n    const simplified = simplifyUnionMembers(unionNode.members)\n    if (simplified.length === unionNode.members.length) return undefined\n\n    return { ...unionNode, members: simplified }\n  },\n})\n","import { ast } from '@kubb/ast'\nimport type { SchemaNode } from '@kubb/ast'\n\n/**\n * Merges a run of adjacent anonymous object members into one. Named or non-object members break the\n * run and pass through unchanged. The merge follows member order, so callers control which members\n * combine by where they place them in the sequence.\n *\n * @example\n * ```ts\n * const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]\n * ```\n */\nexport function* mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined> {\n  let acc: SchemaNode | undefined\n\n  for (const member of members) {\n    const objectMember = ast.narrowSchema(member, 'object')\n    if (objectMember && !objectMember.name && acc !== undefined) {\n      const accObject = ast.narrowSchema(acc, 'object')\n      if (accObject && !accObject.name) {\n        acc = ast.factory.createSchema({\n          ...accObject,\n          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],\n        })\n        continue\n      }\n    }\n    if (acc !== undefined) yield acc\n    acc = member\n  }\n\n  if (acc !== undefined) yield acc\n}\n","import { ast } from '@kubb/ast'\nimport type { SchemaNode } from '@kubb/ast'\n\n/**\n * Returns `true` when a schema, or anything nested inside it, references a circular schema.\n *\n * Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled\n * on their own. Pair it with `ast.findCircularSchemas()` to decide where lazy wrappers go.\n *\n * @note Stops at the first matching circular ref.\n */\nexport function containsCircularRef(\n  node: SchemaNode | undefined,\n  { circularSchemas, excludeName }: { circularSchemas: ReadonlySet<string>; excludeName?: string },\n): boolean {\n  if (!node || circularSchemas.size === 0) return false\n\n  for (const _ of ast.collect<true>(node, {\n    schema(child) {\n      if (child.type !== 'ref') return null\n      const name = ast.resolveRefName(child)\n      return name && name !== excludeName && circularSchemas.has(name) ? true : null\n    },\n  })) {\n    return true\n  }\n\n  return false\n}\n"],"mappings":"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"}