@kubb/plugin-msw 5.0.0-beta.56 → 5.0.0-beta.73

package/dist/index.js

@@ -1,9 +1,36 @@
-import "./chunk-C0LytTxp.js";
-import { s as camelCase } from "./components-Bi7cN-ws.js";
-import { n as handlersGenerator, t as mswGenerator } from "./generators-BnEvTy3q.js";
-import { definePlugin, defineResolver } from "@kubb/core";
+import "./rolldown-runtime-C0LytTxp.js";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 import { pluginFakerName } from "@kubb/plugin-faker";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
+import { jsx, jsxs } from "@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
@@ -29,6 +56,241 @@ function toFilePath(name, caseLast = camelCase) {
 	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
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -60,6 +322,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 = 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 ast.factory.createImport({
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			});
+		});
+		const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`);
+		return [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: [ast.factory.createSource({
+				name: handlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [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 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 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 = 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(createFunctionParameters({ params: [createFunctionParameter({
+		name: "data",
+		type: `${dataType} | ${callbackType}`,
+		optional: true
+	})] }));
+	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ 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 = 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(createFunctionParameters({ params: [createFunctionParameter({
+		name: "data",
+		type: `${typeName} | ${callbackType}`,
+		optional: true
+	})] }));
+	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ 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 = 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(createFunctionParameters({ params: [createFunctionParameter({
+		name: "data",
+		type: typeName,
+		optional: !hasResponseSchema(response)
+	})] }));
+	const responseName = `${name}Response${statusCode}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name: responseName,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ 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 = defineGenerator({
+	name: "msw",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!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(pluginFakerName) : null;
+		const faker = parser === "faker" && fakerPlugin ? resolveFakerMeta(node, {
+			root,
+			fakerResolver: driver.getResolver(pluginFakerName),
+			fakerOutput: fakerPlugin.options?.output ?? output,
+			fakerGroup: fakerPlugin.options?.group ?? null
+		}) : null;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(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__ */ jsxs(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__ */ jsx(File.Import, {
+					name: ["http"],
+					path: "msw"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["HttpResponseResolver"],
+					isTypeOnly: true,
+					path: "msw"
+				}),
+				/* @__PURE__ */ 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__ */ 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__ */ jsx(Response, {
+						typeName,
+						response,
+						name: mock.name
+					}, typeName);
+				}),
+				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ jsx(MockWithFaker, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					fakerName: faker.name,
+					node,
+					baseURL
+				}) : /* @__PURE__ */ 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
@@ -129,7 +757,7 @@ const pluginMsw = definePlugin((options) => {
 	const { output = {
 		path: "handlers",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMswName,
@@ -152,10 +780,9 @@ const pluginMsw = definePlugin((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(mswGenerator);
 			if (handlers) ctx.addGenerator(handlersGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });