@kubb/plugin-cypress 5.0.0-alpha.22 → 5.0.0-alpha.24

package/dist/index.cjs

@@ -1,69 +1,523 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_components = require("./components-Cm0DWd-3.cjs");
-const require_generators = require("./generators-BELLqi5J.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 let node_path = require("node:path");
-node_path = require_components.__toESM(node_path);
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_oas = require("@kubb/plugin-oas");
+node_path = __toESM(node_path);
+let _kubb_ast = require("@kubb/ast");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let _kubb_react_fabric = require("@kubb/react-fabric");
+let _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
+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;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* 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) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/**
+	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+	*/
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
+	* ```
+	*/
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	*
+	* @example
+	* ```ts
+	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+	* new URLPath('/pet/{petId}').isURL                       // false
+	* ```
+	*/
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').object
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	* ```
+	*/
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
+	* new URLPath('/pet').params         // undefined
+	* ```
+	*/
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	}
+	/**
+	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	*/
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		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;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* ```
+	*/
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/components/Request.tsx
+const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function getParams({ paramsType, pathParamsType, paramsCasing, resolver, node }) {
+	const paramsNode = (0, _kubb_ast.createOperationParams)(node, {
+		paramsType,
+		pathParamsType,
+		paramsCasing,
+		resolver,
+		extraParams: [(0, _kubb_ast.createFunctionParameter)({
+			name: "options",
+			type: (0, _kubb_ast.createTypeNode)({
+				variant: "reference",
+				name: "Partial<Cypress.RequestOptions>"
+			}),
+			default: "{}"
+		})]
+	});
+	return declarationPrinter.print(paramsNode) ?? "";
+}
+function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }) {
+	const paramsSignature = getParams({
+		paramsType,
+		pathParamsType,
+		paramsCasing,
+		resolver,
+		node
+	});
+	const responseType = resolver.resolveResponseName(node);
+	const returnType = dataReturnType === "data" ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`;
+	const casedPathParams = (0, _kubb_ast.caseParams)(node.parameters.filter((p) => p.in === "path"), paramsCasing);
+	const pathParamNameMap = new Map(casedPathParams.map((p) => [camelCase(p.name), p.name]));
+	const urlTemplate = new URLPath(node.path, { casing: paramsCasing }).toTemplateString({
+		prefix: baseURL,
+		replacer: (param) => pathParamNameMap.get(camelCase(param)) ?? param
+	});
+	const requestOptions = [`method: '${node.method}'`, `url: ${urlTemplate}`];
+	const queryParams = node.parameters.filter((p) => p.in === "query");
+	if (queryParams.length > 0) {
+		const casedQueryParams = (0, _kubb_ast.caseParams)(queryParams, paramsCasing);
+		if (casedQueryParams.some((p, i) => p.name !== queryParams[i].name)) {
+			const pairs = queryParams.map((orig, i) => `${orig.name}: params.${casedQueryParams[i].name}`).join(", ");
+			requestOptions.push(`qs: params ? { ${pairs} } : undefined`);
+		} else requestOptions.push("qs: params");
+	}
+	const headerParams = node.parameters.filter((p) => p.in === "header");
+	if (headerParams.length > 0) {
+		const casedHeaderParams = (0, _kubb_ast.caseParams)(headerParams, paramsCasing);
+		if (casedHeaderParams.some((p, i) => p.name !== headerParams[i].name)) {
+			const pairs = headerParams.map((orig, i) => `'${orig.name}': headers.${casedHeaderParams[i].name}`).join(", ");
+			requestOptions.push(`headers: headers ? { ${pairs} } : undefined`);
+		} else requestOptions.push("headers");
+	}
+	if (node.requestBody?.schema) requestOptions.push("body: data");
+	requestOptions.push("...options");
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			returnType,
+			children: dataReturnType === "data" ? `return cy.request<${responseType}>({
+  ${requestOptions.join(",\n  ")}
+}).then((res) => res.body)` : `return cy.request<${responseType}>({
+  ${requestOptions.join(",\n  ")}
+})`
+		})
+	});
+}
+Request.getParams = getParams;
+//#endregion
+//#region src/generators/cypressGenerator.tsx
+const cypressGenerator = (0, _kubb_core.defineGenerator)({
+	name: "cypress",
+	type: "react",
+	Operation({ node, adapter, options, config, driver, resolver }) {
+		const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = options;
+		const root = node_path.default.resolve(config.root, config.output.path);
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const file = resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output,
+			group
+		});
+		const tsFile = pluginTs.resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output: pluginTs.options?.output ?? output,
+			group: pluginTs.options?.group
+		});
+		const name = resolver.resolveName(node.operationId);
+		const casedParams = (0, _kubb_ast.caseParams)(node.parameters, paramsCasing);
+		const tsResolver = pluginTs.resolver;
+		const pathParams = casedParams.filter((p) => p.in === "path");
+		const queryParams = casedParams.filter((p) => p.in === "query");
+		const headerParams = casedParams.filter((p) => p.in === "header");
+		const importedTypeNames = [
+			...pathParams.length && tsResolver.resolvePathParamsName ? pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)) : pathParams.map((p) => tsResolver.resolveParamName(node, p)),
+			...queryParams.length && tsResolver.resolveQueryParamsName ? queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)) : queryParams.map((p) => tsResolver.resolveParamName(node, p)),
+			...headerParams.length && tsResolver.resolveHeaderParamsName ? headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)) : headerParams.map((p) => tsResolver.resolveParamName(node, p)),
+			node.requestBody?.schema ? tsResolver.resolveDataName(node) : void 0,
+			tsResolver.resolveResponseName(node)
+		].filter(Boolean);
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [tsFile && importedTypeNames.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: Array.from(new Set(importedTypeNames)),
+				root: file.path,
+				path: tsFile.path,
+				isTypeOnly: true
+			}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Request, {
+				name,
+				node,
+				resolver: tsResolver,
+				dataReturnType,
+				paramsCasing,
+				paramsType,
+				pathParamsType,
+				baseURL
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverCypress.ts
+/**
+* Resolver for `@kubb/plugin-cypress` that provides the default naming
+* and path-resolution helpers used by the plugin.
+*
+* @example
+* ```ts
+* import { resolverCypress } from '@kubb/plugin-cypress'
+*
+* resolverCypress.default('list pets', 'function') // -> 'listPets'
+* resolverCypress.resolveName('show pet by id')    // -> 'showPetById'
+* ```
+*/
+const resolverCypress = (0, _kubb_core.defineResolver)(() => ({
+	name: "default",
+	pluginName: "plugin-cypress",
+	default(name, type) {
+		return camelCase(name, { isFile: type === "file" });
+	},
+	resolveName(name) {
+		return this.default(name, "function");
+	}
+}));
+//#endregion
+//#region src/presets.ts
+/**
+* Built-in preset registry for `@kubb/plugin-cypress`.
+*
+* - `default` — uses `resolverCypress` and `cypressGenerator`.
+* - `kubbV4`  — uses `resolverCypress` and `cypressGenerator`.
+*/
+const presets = (0, _kubb_core.definePresets)({
+	default: {
+		name: "default",
+		resolvers: [resolverCypress],
+		generators: [cypressGenerator]
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolvers: [resolverCypress],
+		generators: [cypressGenerator]
+	}
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-cypress`, used to identify the plugin
+* in driver lookups and warnings.
+*/
 const pluginCypressName = "plugin-cypress";
+/**
+* The `@kubb/plugin-cypress` plugin factory.
+*
+* Generates Cypress `cy.request()` test functions from an OpenAPI/AST `RootNode`.
+* Walks operations, delegates rendering to the active generators,
+* and writes barrel files based on `output.barrelType`.
+*
+* @example
+* ```ts
+* import { pluginCypress } from '@kubb/plugin-cypress'
+*
+* export default defineConfig({
+*   plugins: [pluginCypress({ output: { path: 'cypress' } })],
+* })
+* ```
+*/
 const pluginCypress = (0, _kubb_core.createPlugin)((options) => {
 	const { output = {
 		path: "cypress",
 		barrelType: "named"
-	}, group, dataReturnType = "data", exclude = [], include, override = [], transformers = {}, generators = [require_generators.cypressGenerator].filter(Boolean), contentType, baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline" } = options;
+	}, group, dataReturnType = "data", exclude = [], include, override = [], baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
+	const preset = (0, _kubb_core.getPreset)({
+		preset: compatibilityPreset,
+		presets,
+		resolvers: [resolverCypress, ...userResolvers],
+		transformers: userTransformers,
+		generators: userGenerators
+	});
 	return {
 		name: pluginCypressName,
-		options: {
-			output,
-			dataReturnType,
-			group,
-			baseURL,
-			paramsCasing,
-			paramsType,
-			pathParamsType
-		},
-		pre: [_kubb_plugin_oas.pluginOasName, _kubb_plugin_ts.pluginTsName].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? (0, _kubb_core.getMode)(node_path.default.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return node_path.default.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${require_components.camelCase(ctx.group)}Requests`;
-				};
-				return node_path.default.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return node_path.default.resolve(root, output.path, baseName);
+		get resolver() {
+			return preset.resolver;
 		},
-		resolveName(name, type) {
-			const resolvedName = require_components.camelCase(name, { isFile: type === "file" });
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
+		get options() {
+			return {
+				output,
+				dataReturnType,
+				group: group ? {
+					...options.group,
+					name: options.group?.name ? options.group.name : (ctx) => {
+						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+						return `${camelCase(ctx.group)}Requests`;
+					}
+				} : void 0,
+				baseURL,
+				paramsCasing,
+				paramsType,
+				pathParamsType,
+				resolver: preset.resolver,
+				transformers: preset.transformers
+			};
 		},
+		pre: [_kubb_plugin_ts.pluginTsName].filter(Boolean),
 		async install() {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			const mode = (0, _kubb_core.getMode)(node_path.default.resolve(root, output.path));
-			const oas = await this.getOas();
-			const files = await new _kubb_plugin_oas.OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				exclude,
-				include,
-				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
+			const { config, fabric, plugin, adapter, rootNode, driver } = this;
+			const root = node_path.default.resolve(config.root, config.output.path);
+			const resolver = preset.resolver;
+			if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+			await (0, _kubb_ast.walk)(rootNode, {
+				depth: "shallow",
+				async operation(operationNode) {
+					const writeTasks = preset.generators.map(async (generator) => {
+						if (generator.type === "react" && generator.version === "2") {
+							const resolvedOptions = resolver.resolveOptions(operationNode, {
+								options: plugin.options,
+								exclude,
+								include,
+								override
+							});
+							if (resolvedOptions === null) return;
+							await (0, _kubb_core.renderOperation)(operationNode, {
+								options: resolvedOptions,
+								adapter,
+								config,
+								fabric,
+								Component: generator.Operation,
+								plugin,
+								driver,
+								resolver
+							});
+						}
+					});
+					await Promise.all(writeTasks);
+				}
+			});
 			const barrelFiles = await (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
 				type: output.barrelType ?? "named",
 				root,
@@ -75,7 +529,10 @@ const pluginCypress = (0, _kubb_core.createPlugin)((options) => {
 	};
 });
 //#endregion
+exports.Request = Request;
+exports.cypressGenerator = cypressGenerator;
 exports.pluginCypress = pluginCypress;
 exports.pluginCypressName = pluginCypressName;
+exports.resolverCypress = resolverCypress;
 
 //# sourceMappingURL=index.cjs.map