@kubb/plugin-msw 5.0.0-beta.64 → 5.0.0-beta.74

package/dist/index.cjs

@@ -2,11 +2,39 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_components = require("./components-BZ9KakZO.cjs");
-const require_generators = require("./generators-CkGOweF4.cjs");
+//#endregion
 let _kubb_core = require("@kubb/core");
 let _kubb_plugin_faker = require("@kubb/plugin-faker");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
+let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
+//#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);
+}
+//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Builds a nested file path from a dotted name. Splits on dots that precede a letter
@@ -27,9 +55,244 @@ let _kubb_plugin_ts = require("@kubb/plugin-ts");
 * @example Suffix applied to the final segment only
 * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function toFilePath(name, caseLast = require_components.camelCase) {
+function toFilePath(name, caseLast = camelCase) {
 	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : require_components.camelCase(part)).filter(Boolean).join("/");
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = 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 /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		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 {
+	/**
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
+	*
+	* @example
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
+	*/
+	static canParse(url, base) {
+		return URL.canParse(url, base);
+	}
+	/**
+	* 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, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
+	*/
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
+	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
+	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		return Url.toTemplateString(path, {
+			prefix,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
+	* 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, casing } = {}) {
+		const object = {
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
+		};
+		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 ../../internals/shared/src/operation.ts
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function resolveResponseTypes(node, resolver) {
+	const types = [];
+	for (const response of node.responses) {
+		if (response.statusCode === "default") {
+			types.push(["default", resolver.resolveResponseName(node)]);
+			continue;
+		}
+		const code = getStatusCodeNumber(response.statusCode);
+		if (code === null) continue;
+		types.push([code, isSuccessStatusCode(code) ? resolver.resolveResponseName(node) : resolver.resolveResponseStatusName(node, response.statusCode)]);
+	}
+	return types;
 }
 //#endregion
 //#region ../../internals/shared/src/group.ts
@@ -55,7 +318,7 @@ function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return require_components.camelCase(ctx.group);
+		return camelCase(ctx.group);
 	};
 	return {
 		...group,
@@ -63,6 +326,372 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region src/generators/handlersGenerator.ts
+/**
+* Aggregate generator enabled by `pluginMsw({ handlers: true })`. Emits a
+* `handlers.ts` file that re-exports every generated handler grouped by HTTP
+* method, ready to spread into `setupServer(...handlers)` or
+* `setupWorker(...handlers)`.
+*/
+const handlersGenerator = (0, _kubb_core.defineGenerator)({
+	name: "plugin-msw",
+	operations(nodes, ctx) {
+		const { resolver, config, root } = ctx;
+		const { output, group } = ctx.options;
+		const handlersName = resolver.resolveHandlersName();
+		const file = resolver.resolveFile({
+			name: resolver.resolvePathName(handlersName, "file"),
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const imports = nodes.map((node) => {
+			const operationName = resolver.resolveHandlerName(node);
+			const operationFile = resolver.resolveFile({
+				name: resolver.resolveName(node.operationId),
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			});
+			return _kubb_core.ast.factory.createImport({
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			});
+		});
+		const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`);
+		return [_kubb_core.ast.factory.createFile({
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			imports,
+			sources: [_kubb_core.ast.factory.createSource({
+				name: handlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [_kubb_core.ast.factory.createText(`export const ${handlersName} = ${JSON.stringify(handlers).replaceAll("\"", "")} as const`)]
+			})]
+		})];
+	}
+});
+//#endregion
+//#region src/utils.ts
+/**
+* Gets the content type from a response, defaulting to 'application/json' if a schema exists.
+*/
+function getContentType(response) {
+	if (!hasResponseSchema(response)) return null;
+	return getResponseContentType(response) ?? "application/json";
+}
+/**
+* Determines if a response has a schema that is not void or any.
+*/
+function hasResponseSchema(response) {
+	const schema = response?.content?.find((entry) => entry.schema)?.schema;
+	return !!schema && schema.type !== "void" && schema.type !== "any";
+}
+/**
+* Picks the content type used for the mocked response header. When a response declares multiple
+* content types, JSON is preferred (the faker mock body is JSON), otherwise the first declared type.
+*/
+function getResponseContentType(response) {
+	const contents = response?.content ?? [];
+	const value = (contents.find((entry) => {
+		const baseType = entry.contentType?.split(";")[0]?.trim().toLowerCase();
+		return baseType === "application/json" || baseType?.endsWith("+json");
+	}) ?? contents[0])?.contentType;
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+/**
+* Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post').
+*/
+function getMswMethod(node) {
+	return _kubb_core.ast.isHttpOperationNode(node) ? node.method.toLowerCase() : "";
+}
+/**
+* Converts an OpenAPI-style path to an Express/MSW-style path by replacing `{param}` with `:param`.
+*/
+function getMswUrl(node) {
+	return _kubb_core.ast.isHttpOperationNode(node) ? node.path.replaceAll("{", ":").replaceAll("}", "") : "";
+}
+/**
+* Resolves faker metadata for an MSW operation, including response name and file path.
+*/
+function resolveFakerMeta(node, options) {
+	const { root, fakerResolver, fakerOutput, fakerGroup } = options;
+	const tag = node.tags[0] ?? "default";
+	return {
+		name: fakerResolver.resolveResponseName(node),
+		file: fakerResolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag,
+			path: node.path
+		}, {
+			root,
+			output: fakerOutput,
+			group: fakerGroup ?? void 0
+		})
+	};
+}
+//#endregion
+//#region src/components/Mock.tsx
+const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function Mock({ baseURL = "", name, typeName, requestTypeName, node }) {
+	const method = getMswMethod(node);
+	const successResponse = getPrimarySuccessResponse(node);
+	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
+	const contentType = getContentType(successResponse);
+	const url = Url.toPath(getMswUrl(node));
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const dataType = hasResponseSchema(successResponse) ? typeName : "string | number | boolean | null | object";
+	const callbackType = requestTypeName ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`;
+	const params = declarationPrinter$2.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "data",
+		type: `${dataType} | ${callbackType}`,
+		optional: true
+	})] }));
+	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`;
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
+			name,
+			export: true,
+			params: params ?? "",
+			children: `return ${httpCall}(\`${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}\`, function handler(info) {
+    if(typeof data === 'function') return data(info)
+
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })
+  })`
+		})
+	});
+}
+//#endregion
+//#region src/components/MockWithFaker.tsx
+const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function MockWithFaker({ baseURL = "", name, fakerName, typeName, requestTypeName, node }) {
+	const method = getMswMethod(node);
+	const successResponse = getPrimarySuccessResponse(node);
+	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
+	const contentType = getContentType(successResponse);
+	const url = Url.toPath(getMswUrl(node));
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const callbackType = requestTypeName ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`;
+	const params = declarationPrinter$1.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "data",
+		type: `${typeName} | ${callbackType}`,
+		optional: true
+	})] }));
+	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`;
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
+			name,
+			export: true,
+			params: params ?? "",
+			children: `return ${httpCall}('${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}', function handler(info) {
+    if(typeof data === 'function') return data(info)
+
+    return new Response(JSON.stringify(data || ${fakerName}(data)), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })
+  })`
+		})
+	});
+}
+//#endregion
+//#region src/components/Response.tsx
+const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function Response({ name, typeName, response }) {
+	const statusCode = Number(response.statusCode);
+	const contentType = getContentType(response);
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const params = declarationPrinter.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "data",
+		type: typeName,
+		optional: !hasResponseSchema(response)
+	})] }));
+	const responseName = `${name}Response${statusCode}`;
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		name: responseName,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
+			name: responseName,
+			export: true,
+			params: params ?? "",
+			children: `
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })`
+		})
+	});
+}
+//#endregion
+//#region src/generators/mswGenerator.tsx
+/**
+* Built-in operation generator for `@kubb/plugin-msw`. Emits one MSW handler
+* per OpenAPI operation. With `parser: 'faker'` the handler returns a value
+* from `@kubb/plugin-faker`; with `parser: 'data'` it returns a typed empty
+* payload for tests to fill in.
+*/
+const mswGenerator = (0, _kubb_core.defineGenerator)({
+	name: "msw",
+	renderer: _kubb_renderer_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!_kubb_core.ast.isHttpOperationNode(node)) return null;
+		const { driver, resolver, config, root } = ctx;
+		const { output, parser, baseURL, group } = ctx.options;
+		const fileName = resolver.resolveName(node.operationId);
+		const mock = {
+			name: resolver.resolveHandlerName(node),
+			file: resolver.resolveFile({
+				name: fileName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			})
+		};
+		const fakerPlugin = parser === "faker" ? driver.getPlugin(_kubb_plugin_faker.pluginFakerName) : null;
+		const faker = parser === "faker" && fakerPlugin ? resolveFakerMeta(node, {
+			root,
+			fakerResolver: driver.getResolver(_kubb_plugin_faker.pluginFakerName),
+			fakerOutput: fakerPlugin.options?.output ?? output,
+			fakerGroup: fakerPlugin.options?.group ?? null
+		}) : null;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const type = {
+			file: tsResolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			}),
+			responseName: tsResolver.resolveResponseName(node)
+		};
+		const types = resolveResponseTypes(node, tsResolver);
+		const hasSuccessSchema = getOperationSuccessResponses(node).some((response) => !!response.content?.[0]?.schema);
+		const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
+		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+			baseName: mock.file.baseName,
+			path: mock.file.path,
+			meta: mock.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: mock.file.path,
+					baseName: mock.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: mock.file.path,
+					baseName: mock.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+					name: ["http"],
+					path: "msw"
+				}),
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+					name: ["HttpResponseResolver"],
+					isTypeOnly: true,
+					path: "msw"
+				}),
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+					name: Array.from(new Set([
+						type.responseName,
+						...types.map((t) => t[1]),
+						...requestName ? [requestName] : []
+					])),
+					path: type.file.path,
+					root: mock.file.path,
+					isTypeOnly: true
+				}),
+				parser === "faker" && faker && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+					name: [faker.name],
+					root: mock.file.path,
+					path: faker.file.path
+				}),
+				types.filter(([code]) => code !== "default").map(([code, typeName]) => {
+					const response = node.responses.find((item) => item.statusCode === String(code));
+					if (!response) return null;
+					return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Response, {
+						typeName,
+						response,
+						name: mock.name
+					}, typeName);
+				}),
+				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(MockWithFaker, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					fakerName: faker.name,
+					node,
+					baseURL
+				}) : /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Mock, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					node,
+					baseURL
+				})
+			]
+		});
+	}
+});
+//#endregion
 //#region src/resolvers/resolverMsw.ts
 /**
 * Default resolver used by `@kubb/plugin-msw`. Decides the names and file
@@ -80,10 +709,10 @@ const resolverMsw = (0, _kubb_core.defineResolver)(() => ({
 	name: "default",
 	pluginName: "plugin-msw",
 	default(name, type) {
-		return type === "file" ? toFilePath(name) : require_components.camelCase(name);
+		return type === "file" ? toFilePath(name) : camelCase(name);
 	},
 	resolveName(name) {
-		return require_components.camelCase(name, { suffix: "handler" });
+		return camelCase(name, { suffix: "handler" });
 	},
 	resolvePathName(name, type) {
 		return this.default(name, type);
@@ -132,7 +761,7 @@ const pluginMsw = (0, _kubb_core.definePlugin)((options) => {
 	const { output = {
 		path: "handlers",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
+	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMswName,
@@ -156,9 +785,8 @@ const pluginMsw = (0, _kubb_core.definePlugin)((options) => {
 			});
 			ctx.setResolver(resolver);
 			if (userMacros?.length) ctx.setMacros(userMacros);
-			ctx.addGenerator(require_generators.mswGenerator);
-			if (handlers) ctx.addGenerator(require_generators.handlersGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
+			ctx.addGenerator(mswGenerator);
+			if (handlers) ctx.addGenerator(handlersGenerator);
 		} }
 	};
 });