@kubb/plugin-faker 5.0.0-beta.95 → 5.0.0-beta.99

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 import { KubbReactNode } from "kubb/jsx";
-
 //#region src/types.d.ts
 /**
  * Resolver for Faker that provides naming methods for mock functions.
@@ -234,15 +233,7 @@ type Props = {
   description?: string;
   canOverride: boolean;
 };
-declare function Faker({
-  node,
-  description,
-  name,
-  typeName,
-  printer,
-  seed,
-  canOverride
-}: Props): KubbReactNode;
+declare function Faker({ node, description, name, typeName, printer, seed, canOverride }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/fakerGenerator.d.ts
 /**

package/dist/index.js

@@ -628,39 +628,19 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 }
 //#endregion
 //#region ../../internals/shared/src/params.ts
-const caseParamsCache = /* @__PURE__ */ new WeakMap();
 /**
-* Applies camelCase to parameter names and returns a new array without mutating the input.
+* Drops parameters that share the same name, keeping the first.
 *
-* Run it before handing parameters to schema builders so output property keys get the right casing
-* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
-* original array is returned unchanged. Results are cached per input array.
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
 */
-function caseParams(params, casing) {
-	if (!casing) return params;
-	const cached = caseParamsCache.get(params);
-	if (cached) return cached;
-	const result = params.map((param) => ({
-		...param,
-		name: camelCase(param.name)
-	}));
-	caseParamsCache.set(params, result);
-	return result;
-}
-/**
-* Drops parameters that collapse to the same property identity once camelCased, keeping the first.
-*
-* Some specs declare the same parameter twice under different casings (for example AWS S3 lists both
-* `max-uploads` and `MaxUploads`). Both resolve to one output property, so emitting both would yield
-* an object type with a duplicate member, which TypeScript rejects. De-duplicate by the camelCased
-* identity so the resulting group is collision-free regardless of the names each caller carries.
-*/
-function dedupeByCasedName(params) {
+function dedupeParams(params) {
 	const seen = /* @__PURE__ */ new Set();
 	return params.filter((param) => {
-		const key = camelCase(param.name);
-		if (seen.has(key)) return false;
-		seen.add(key);
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
 		return true;
 	});
 }
@@ -714,13 +694,15 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+function getOperationParameters(node) {
 	return {
-		path: dedupeByCasedName(params.filter((param) => param.in === "path")),
-		query: dedupeByCasedName(params.filter((param) => param.in === "query")),
-		header: dedupeByCasedName(params.filter((param) => param.in === "header")),
-		cookie: dedupeByCasedName(params.filter((param) => param.in === "cookie"))
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
+			...param,
+			name: camelCase(param.name)
+		})),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
 }
 //#endregion
@@ -830,6 +812,28 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* 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)
+	}));
+}
+//#endregion
 //#region src/printers/printerFaker.ts
 const fakerKeywordMapper = {
 	any: () => "undefined",
@@ -981,12 +985,15 @@ const printerFaker = ast.createPrinter((options) => {
 			union(node) {
 				const { discriminatorPropertyName } = node;
 				const baseTypeName = this.options.typeName;
-				const items = ast.mapSchemaMembers(node, (member) => {
+				const items = mapSchemaMembers(node, (member) => {
 					const value = discriminatorPropertyName ? getDiscriminatorValue(member, discriminatorPropertyName) : void 0;
-					if (baseTypeName && value !== void 0) return printNested(member, {
-						typeName: `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`,
-						nestedInObject: true
-					});
+					if (baseTypeName && value !== void 0) {
+						const typeName = `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`;
+						return printNested(member, {
+							typeName,
+							nestedInObject: true
+						});
+					}
 					return printNested(member, {
 						typeName: baseTypeName,
 						nestedInObject: true,
@@ -996,11 +1003,11 @@ const printerFaker = ast.createPrinter((options) => {
 				return fakerKeywordMapper.union(items);
 			},
 			intersection(node) {
-				const items = ast.mapSchemaMembers(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
+				const items = mapSchemaMembers(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
 				return fakerKeywordMapper.and(items);
 			},
 			array(node) {
-				const items = ast.mapSchemaItems(node, (member) => printNested(member, {
+				const items = mapSchemaItems(node, (member) => printNested(member, {
 					typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : void 0,
 					nestedInObject: true
 				})).map(({ output }) => output).filter((item) => Boolean(item));
@@ -1169,11 +1176,7 @@ const fakerGenerator = defineGenerator({
 		const pluginTs = ctx.driver.getPlugin(pluginTsName);
 		if (!pluginTs) return;
 		const tsResolver = ctx.driver.getResolver(pluginTsName);
-		const params = caseParams(node.parameters, "camelcase");
-		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters({
-			...node,
-			parameters: params
-		}, { paramsCasing: "original" });
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 		const paramGroups = [
 			{
 				params: pathParams,