@kubb/plugin-msw 5.0.0-alpha.8 → 5.0.0-beta.3

package/LICENSE

@@ -1,14 +1,21 @@
-Copyright (c) 2026 Stijn Van Hulle
+MIT License
 
-This repository contains software under two licenses:
+Copyright (c) 2026 Kubb Labs
 
-1. Most of the code in this repository is licensed under the
-   MIT License — see licenses/LICENSE-MIT for the full license text.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-2. The following components are licensed under the
-   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
-   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-   - packages/agent (published as @kubb/agent)
-
-Each package's own LICENSE file or package.json specifies its applicable license.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -4,12 +4,12 @@
     <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
   </a>
 
-
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
 [![Coverage][coverage-src]][coverage-href]
 [![License][license-src]][license-href]
 [![Sponsors][sponsors-src]][sponsors-href]
+
 <h4>
 <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/main//examples/typescript" target="_blank">View Demo</a>
 <span> · </span>
@@ -23,7 +23,6 @@
 
 Swagger integration to create mock data based on MSW
 
-
 ## Supporting Kubb
 
 Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
@@ -36,7 +35,6 @@ Kubb uses an MIT-licensed open source project with its ongoing development made
   </a>
 </p>
 
-
 <!-- Badges -->
 
 [npm-version-src]: https://img.shields.io/npm/v/@kubb/plugin-msw?flat&colorA=18181B&colorB=f58517

package/dist/components-CLQ77DVn.cjs

@@ -0,0 +1,584 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+let _kubb_core = require("@kubb/core");
+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;
+		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
+/**
+* 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/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/Handlers.tsx
+function Handlers({ name, handlers }) {
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: `export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, "")} as const`
+	});
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Applies a name transformer function to a name if configured, otherwise returns it unchanged.
+*/
+function transformName(name, type, transformers) {
+	return transformers?.name?.(name, type) || name;
+}
+/**
+* Filters responses to only those with 2xx status codes.
+*/
+function getSuccessResponses(node) {
+	return node.responses.filter((response) => {
+		const code = Number.parseInt(response.statusCode, 10);
+		return !Number.isNaN(code) && code >= 200 && code < 300;
+	});
+}
+/**
+* Returns the first 2xx response for an operation, if any.
+*/
+function getPrimarySuccessResponse(node) {
+	return getSuccessResponses(node)[0];
+}
+/**
+* Gets the content type from a response, defaulting to 'application/json' if a schema exists.
+*/
+function getContentType(response) {
+	return getResponseContentType(response) ?? (hasResponseSchema(response) ? "application/json" : void 0);
+}
+/**
+* Determines if a response has a schema that is not void or any.
+*/
+function hasResponseSchema(response) {
+	return !!getResponseContentType(response) || !!response?.schema && response.schema.type !== "void" && response.schema.type !== "any";
+}
+function getResponseContentType(response) {
+	const contentType = response;
+	const value = contentType?.mediaType ?? contentType?.contentType;
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* Maps all operation responses to their type names, including status code or 'default' for default responses.
+*/
+function getResponseTypes(node, tsResolver) {
+	const types = [];
+	for (const response of node.responses) {
+		if (response.statusCode === "default") {
+			types.push(["default", tsResolver.resolveResponseName(node)]);
+			continue;
+		}
+		const code = Number.parseInt(response.statusCode, 10);
+		if (Number.isNaN(code)) continue;
+		if (code >= 200 && code < 300) {
+			types.push([code, tsResolver.resolveResponseName(node)]);
+			continue;
+		}
+		types.push([code, tsResolver.resolveResponseStatusName(node, response.statusCode)]);
+	}
+	return types;
+}
+/**
+* Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post').
+*/
+function getMswMethod(node) {
+	return node.method.toLowerCase();
+}
+/**
+* Converts an OpenAPI-style path to an Express/MSW-style path by replacing `{param}` with `:param`.
+*/
+function getMswUrl(node) {
+	return 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
+		})
+	};
+}
+//#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 = new URLPath(getMswUrl(node)).toURLPath();
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : void 0].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(_kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+		name: "data",
+		type: _kubb_core.ast.createParamsType({
+			variant: "reference",
+			name: `${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 = new URLPath(getMswUrl(node)).toURLPath();
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : void 0].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(_kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+		name: "data",
+		type: _kubb_core.ast.createParamsType({
+			variant: "reference",
+			name: `${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}'` : void 0].filter(Boolean);
+	const params = declarationPrinter.print(_kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+		name: "data",
+		type: _kubb_core.ast.createParamsType({
+			variant: "reference",
+			name: 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
+Object.defineProperty(exports, "Handlers", {
+	enumerable: true,
+	get: function() {
+		return Handlers;
+	}
+});
+Object.defineProperty(exports, "Mock", {
+	enumerable: true,
+	get: function() {
+		return Mock;
+	}
+});
+Object.defineProperty(exports, "MockWithFaker", {
+	enumerable: true,
+	get: function() {
+		return MockWithFaker;
+	}
+});
+Object.defineProperty(exports, "Response", {
+	enumerable: true,
+	get: function() {
+		return Response;
+	}
+});
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: function() {
+		return camelCase;
+	}
+});
+Object.defineProperty(exports, "getResponseTypes", {
+	enumerable: true,
+	get: function() {
+		return getResponseTypes;
+	}
+});
+Object.defineProperty(exports, "getSuccessResponses", {
+	enumerable: true,
+	get: function() {
+		return getSuccessResponses;
+	}
+});
+Object.defineProperty(exports, "resolveFakerMeta", {
+	enumerable: true,
+	get: function() {
+		return resolveFakerMeta;
+	}
+});
+Object.defineProperty(exports, "transformName", {
+	enumerable: true,
+	get: function() {
+		return transformName;
+	}
+});
+
+//# sourceMappingURL=components-CLQ77DVn.cjs.map