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

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["camelCase","camelCase","pluginTsName","pluginFakerName","mswGenerator","handlersGenerator"],"sources":["../src/resolvers/resolverMsw.ts","../src/plugin.ts"],"sourcesContent":["import { camelCase } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginMsw } from '../types.ts'\n\n/**\n * Naming convention resolver for MSW plugin.\n *\n * Provides default naming helpers using camelCase with a `handler` suffix.\n */\nexport const resolverMsw = defineResolver<PluginMsw>((_ctx) => ({\n  name: 'default',\n  pluginName: 'plugin-msw',\n  default(name, type) {\n    return camelCase(name, { isFile: type === 'file' })\n  },\n  resolveName(name) {\n    return camelCase(name, { suffix: 'handler' })\n  },\n}))\n","import { camelCase } from '@internals/utils'\nimport { definePlugin, type Group } from '@kubb/core'\nimport { pluginFakerName } from '@kubb/plugin-faker'\nimport { pluginTsName } from '@kubb/plugin-ts'\nimport { handlersGenerator, mswGenerator } from './generators'\nimport { resolverMsw } from './resolvers/resolverMsw.ts'\nimport type { PluginMsw } from './types.ts'\n\nexport const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']\n\nexport const pluginMsw = definePlugin<PluginMsw>((options) => {\n  const {\n    output = { path: 'handlers', barrelType: 'named' },\n    group,\n    exclude = [],\n    include,\n    override = [],\n    transformers = {},\n    handlers = false,\n    parser = 'data',\n    baseURL,\n    resolver: userResolver,\n    transformer: userTransformer,\n    generators: userGenerators = [],\n  } = options\n\n  const groupConfig = group\n    ? ({\n        ...group,\n        name: group.name\n          ? group.name\n          : (ctx: { group: string }) => {\n              if (group.type === 'path') {\n                return `${ctx.group.split('/')[1]}`\n              }\n              return `${camelCase(ctx.group)}Controller`\n            },\n      } satisfies Group)\n    : undefined\n\n  return {\n    name: pluginMswName,\n    options,\n    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : undefined].filter(Boolean),\n    hooks: {\n      'kubb:plugin:setup'(ctx) {\n        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw\n\n        ctx.setOptions({\n          output,\n          parser,\n          baseURL,\n          group: groupConfig,\n          exclude,\n          include,\n          override,\n          handlers,\n          transformers,\n          resolver,\n        })\n        ctx.setResolver(resolver)\n        if (userTransformer) {\n          ctx.setTransformer(userTransformer)\n        }\n\n        ctx.addGenerator(mswGenerator)\n        if (handlers) {\n          ctx.addGenerator(handlersGenerator)\n        }\n        for (const gen of userGenerators) {\n          ctx.addGenerator(gen)\n        }\n      },\n    },\n  }\n})\n\nexport default pluginMsw\n"],"mappings":";;;;;;;;;;;;;;;AASA,MAAa,eAAA,GAAA,WAAA,iBAAyC,UAAU;CAC9D,MAAM;CACN,YAAY;CACZ,QAAQ,MAAM,MAAM;AAClB,SAAOA,mBAAAA,UAAU,MAAM,EAAE,QAAQ,SAAS,QAAQ,CAAC;;CAErD,YAAY,MAAM;AAChB,SAAOA,mBAAAA,UAAU,MAAM,EAAE,QAAQ,WAAW,CAAC;;CAEhD,EAAE;;;ACVH,MAAa,gBAAgB;AAE7B,MAAa,aAAA,GAAA,WAAA,eAAqC,YAAY;CAC5D,MAAM,EACJ,SAAS;EAAE,MAAM;EAAY,YAAY;EAAS,EAClD,OACA,UAAU,EAAE,EACZ,SACA,WAAW,EAAE,EACb,eAAe,EAAE,EACjB,WAAW,OACX,SAAS,QACT,SACA,UAAU,cACV,aAAa,iBACb,YAAY,iBAAiB,EAAE,KAC7B;CAEJ,MAAM,cAAc,QACf;EACC,GAAG;EACH,MAAM,MAAM,OACR,MAAM,QACL,QAA2B;AAC1B,OAAI,MAAM,SAAS,OACjB,QAAO,GAAG,IAAI,MAAM,MAAM,IAAI,CAAC;AAEjC,UAAO,GAAGC,mBAAAA,UAAU,IAAI,MAAM,CAAC;;EAEtC,GACD,KAAA;AAEJ,QAAO;EACL,MAAM;EACN;EACA,cAAc,CAACC,gBAAAA,cAAc,WAAW,UAAUC,mBAAAA,kBAAkB,KAAA,EAAU,CAAC,OAAO,QAAQ;EAC9F,OAAO,EACL,oBAAoB,KAAK;GACvB,MAAM,WAAW,eAAe;IAAE,GAAG;IAAa,GAAG;IAAc,GAAG;AAEtE,OAAI,WAAW;IACb;IACA;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;AACF,OAAI,YAAY,SAAS;AACzB,OAAI,gBACF,KAAI,eAAe,gBAAgB;AAGrC,OAAI,aAAaC,mBAAAA,aAAa;AAC9B,OAAI,SACF,KAAI,aAAaC,mBAAAA,kBAAkB;AAErC,QAAK,MAAM,OAAO,eAChB,KAAI,aAAa,IAAI;KAG1B;EACF;EACD"}
+{"version":3,"file":"index.cjs","names":["camelCase","camelCase","camelCase","pluginTsName","pluginFakerName","mswGenerator","handlersGenerator"],"sources":["../../../internals/utils/src/fs.ts","../../../internals/shared/src/group.ts","../src/resolvers/resolverMsw.ts","../src/plugin.ts"],"sourcesContent":["import { posix } from 'node:path'\nimport { camelCase } from './casing.ts'\n\nfunction toSlash(p: string): string {\n  if (p.startsWith('\\\\\\\\?\\\\')) return p\n  return p.replaceAll('\\\\', '/')\n}\n\n/**\n * Returns the relative path from `rootDir` to `filePath`, always using forward slashes\n * and prefixed with `./` when not already traversing upward.\n *\n * @example\n * ```ts\n * getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'\n * getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'\n * ```\n */\nexport function getRelativePath(rootDir?: string | null, filePath?: string | null): string {\n  if (!rootDir || !filePath) {\n    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)\n  }\n\n  const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath))\n\n  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`\n}\n\n/**\n * Builds a nested file path from a dotted name. Splits on dots that precede a letter\n * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases\n * every earlier segment, applies `caseLast` to the final segment, and joins with `/`.\n *\n * Empty segments are dropped before joining. They arise when the name starts with a dot\n * followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to\n * an empty string). Without this a leading `/` would form, which `path.resolve` reads as an\n * absolute path, letting generated files escape the configured output directory.\n *\n * @example Nested path from a dotted name\n * `toFilePath('pet.petId') // 'pet/petId'`\n *\n * @example PascalCase the final segment\n * `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`\n *\n * @example Suffix applied to the final segment only\n * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`\n */\nexport function toFilePath(name: string, caseLast: (part: string) => string = camelCase): string {\n  const parts = name.split(/\\.(?=[a-zA-Z])/)\n  return parts\n    .map((part, i) => (i === parts.length - 1 ? caseLast(part) : camelCase(part)))\n    .filter(Boolean)\n    .join('/')\n}\n","import { camelCase } from '@internals/utils'\nimport type { Group } from '@kubb/core'\n\n/**\n * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the\n * shared default naming so every plugin groups output consistently:\n *\n * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).\n * - other groups use the camelCased group (`pet store` → `petStore`).\n *\n * A user-provided `group.name` always wins over the default namer, so callers stay in\n * control of their output folders. Returns `null` when grouping is disabled, matching the\n * per-plugin convention.\n *\n * @param group - The user-supplied group option, or `undefined` to disable grouping.\n *\n * @example\n * ```ts\n * createGroupConfig(group) // shared across every plugin\n * ```\n */\nexport function createGroupConfig(group: Group | undefined): Group | null {\n  if (!group) {\n    return null\n  }\n\n  const defaultName = (ctx: { group: string }): string => {\n    if (group.type === 'path') {\n      return `${ctx.group.split('/')[1]}`\n    }\n\n    return camelCase(ctx.group)\n  }\n\n  return {\n    ...group,\n    name: group.name ? group.name : defaultName,\n  } satisfies Group\n}\n","import { camelCase, toFilePath } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginMsw } from '../types.ts'\n\n/**\n * Default resolver used by `@kubb/plugin-msw`. Decides the names and file\n * paths for every generated MSW handler. Function names get a `Handler`\n * suffix; the aggregate export is always `handlers`.\n *\n * @example Resolve a handler name\n * ```ts\n * import { resolverMsw } from '@kubb/plugin-msw'\n *\n * resolverMsw.resolveName('addPet') // 'addPetHandler'\n * ```\n */\nexport const resolverMsw = defineResolver<PluginMsw>(() => ({\n  name: 'default',\n  pluginName: 'plugin-msw',\n  default(name, type) {\n    return type === 'file' ? toFilePath(name) : camelCase(name)\n  },\n  resolveName(name) {\n    return camelCase(name, { suffix: 'handler' })\n  },\n  resolvePathName(name, type) {\n    return this.default(name, type)\n  },\n  resolveHandlerName(node) {\n    return this.resolveName(node.operationId)\n  },\n  resolveHandlersName() {\n    return 'handlers'\n  },\n}))\n","import { createGroupConfig } from '@internals/shared'\nimport { definePlugin } from '@kubb/core'\nimport { pluginFakerName } from '@kubb/plugin-faker'\nimport { pluginTsName } from '@kubb/plugin-ts'\nimport { handlersGenerator, mswGenerator } from './generators'\nimport { resolverMsw } from './resolvers/resolverMsw.ts'\nimport type { PluginMsw } from './types.ts'\n\n/**\n * Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and\n * cross-plugin dependency references.\n */\nexport const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']\n\n/**\n * Generates MSW request handlers from an OpenAPI spec. Drop them into your\n * test setup or service worker to mock the API end-to-end. Request path,\n * method, status, and response body all stay in sync with the spec. Combine\n * with `@kubb/plugin-faker` (via `parser: 'faker'`) to seed handlers with\n * realistic data.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n * import { pluginMsw } from '@kubb/plugin-msw'\n *\n * export default defineConfig({\n *   input: { path: './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [\n *     pluginTs(),\n *     pluginMsw({\n *       output: { path: './handlers' },\n *       handlers: true,\n *     }),\n *   ],\n * })\n * ```\n */\nexport const pluginMsw = definePlugin<PluginMsw>((options) => {\n  const {\n    output = { path: 'handlers', barrel: { type: 'named' } },\n    group,\n    exclude = [],\n    include,\n    override = [],\n    handlers = false,\n    parser = 'data',\n    baseURL,\n    resolver: userResolver,\n    transformer: userTransformer,\n    generators: userGenerators = [],\n  } = options\n\n  const groupConfig = createGroupConfig(group)\n\n  return {\n    name: pluginMswName,\n    options,\n    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : null].filter((dependency): dependency is string => Boolean(dependency)),\n    hooks: {\n      'kubb:plugin:setup'(ctx) {\n        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw\n\n        ctx.setOptions({\n          output,\n          parser,\n          baseURL,\n          group: groupConfig,\n          exclude,\n          include,\n          override,\n          handlers,\n          resolver,\n        })\n        ctx.setResolver(resolver)\n        if (userTransformer) {\n          ctx.setTransformer(userTransformer)\n        }\n\n        ctx.addGenerator(mswGenerator)\n        if (handlers) {\n          ctx.addGenerator(handlersGenerator)\n        }\n        for (const gen of userGenerators) {\n          ctx.addGenerator(gen)\n        }\n      },\n    },\n  }\n})\n\nexport default pluginMsw\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,WAAW,MAAc,WAAqCA,mBAAAA,WAAmB;CAC/F,MAAM,QAAQ,KAAK,MAAM,gBAAgB;CACzC,OAAO,MACJ,KAAK,MAAM,MAAO,MAAM,MAAM,SAAS,IAAI,SAAS,IAAI,IAAIA,mBAAAA,UAAU,IAAI,CAAE,CAAC,CAC7E,OAAO,OAAO,CAAC,CACf,KAAK,GAAG;AACb;;;;;;;;;;;;;;;;;;;;;AChCA,SAAgB,kBAAkB,OAAwC;CACxE,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,eAAe,QAAmC;EACtD,IAAI,MAAM,SAAS,QACjB,OAAO,GAAG,IAAI,MAAM,MAAM,GAAG,CAAC,CAAC;EAGjC,OAAOC,mBAAAA,UAAU,IAAI,KAAK;CAC5B;CAEA,OAAO;EACL,GAAG;EACH,MAAM,MAAM,OAAO,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;;;;;ACtBA,MAAa,eAAA,GAAA,WAAA,eAAA,QAA+C;CAC1D,MAAM;CACN,YAAY;CACZ,QAAQ,MAAM,MAAM;EAClB,OAAO,SAAS,SAAS,WAAW,IAAI,IAAIC,mBAAAA,UAAU,IAAI;CAC5D;CACA,YAAY,MAAM;EAChB,OAAOA,mBAAAA,UAAU,MAAM,EAAE,QAAQ,UAAU,CAAC;CAC9C;CACA,gBAAgB,MAAM,MAAM;EAC1B,OAAO,KAAK,QAAQ,MAAM,IAAI;CAChC;CACA,mBAAmB,MAAM;EACvB,OAAO,KAAK,YAAY,KAAK,WAAW;CAC1C;CACA,sBAAsB;EACpB,OAAO;CACT;AACF,EAAE;;;;;;;ACtBF,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B7B,MAAa,aAAA,GAAA,WAAA,aAAA,EAAqC,YAAY;CAC5D,MAAM,EACJ,SAAS;EAAE,MAAM;EAAY,QAAQ,EAAE,MAAM,QAAQ;CAAE,GACvD,OACA,UAAU,CAAC,GACX,SACA,WAAW,CAAC,GACZ,WAAW,OACX,SAAS,QACT,SACA,UAAU,cACV,aAAa,iBACb,YAAY,iBAAiB,CAAC,MAC5B;CAEJ,MAAM,cAAc,kBAAkB,KAAK;CAE3C,OAAO;EACL,MAAM;EACN;EACA,cAAc,CAACC,gBAAAA,cAAc,WAAW,UAAUC,mBAAAA,kBAAkB,IAAI,CAAC,CAAC,QAAQ,eAAqC,QAAQ,UAAU,CAAC;EAC1I,OAAO,EACL,oBAAoB,KAAK;GACvB,MAAM,WAAW,eAAe;IAAE,GAAG;IAAa,GAAG;GAAa,IAAI;GAEtE,IAAI,WAAW;IACb;IACA;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA;GACF,CAAC;GACD,IAAI,YAAY,QAAQ;GACxB,IAAI,iBACF,IAAI,eAAe,eAAe;GAGpC,IAAI,aAAaC,mBAAAA,YAAY;GAC7B,IAAI,UACF,IAAI,aAAaC,mBAAAA,iBAAiB;GAEpC,KAAK,MAAM,OAAO,gBAChB,IAAI,aAAa,GAAG;EAExB,EACF;CACF;AACF,CAAC"}

package/dist/index.d.ts

@@ -1,10 +1,39 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginMsw, t as Options } from "./types-Dxu0KMQ4.js";
-import * as _$_kubb_core0 from "@kubb/core";
+import { t as __name } from "./chunk-C0LytTxp.js";
+import { n as PluginMsw, t as Options } from "./types-B1yTWOfj.js";
 
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
 declare const pluginMswName = "plugin-msw";
-declare const pluginMsw: (options?: Options | undefined) => _$_kubb_core0.Plugin<PluginMsw>;
+/**
+ * Generates MSW request handlers from an OpenAPI spec. Drop them into your
+ * test setup or service worker to mock the API end-to-end. Request path,
+ * method, status, and response body all stay in sync with the spec. Combine
+ * with `@kubb/plugin-faker` (via `parser: 'faker'`) to seed handlers with
+ * realistic data.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginMsw } from '@kubb/plugin-msw'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginMsw({
+ *       output: { path: './handlers' },
+ *       handlers: true,
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare const pluginMsw: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginMsw>;
 //#endregion
 export { type PluginMsw, pluginMsw as default, pluginMsw, pluginMswName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,44 +1,140 @@
-import "./chunk--u3MIqq1.js";
-import { l as camelCase } from "./components-vO0FIb2i.js";
-import { n as handlersGenerator, t as mswGenerator } from "./generators-BPJCs1x1.js";
+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 { pluginFakerName } from "@kubb/plugin-faker";
 import { pluginTsName } from "@kubb/plugin-ts";
+//#region ../../internals/utils/src/fs.ts
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
 //#region src/resolvers/resolverMsw.ts
 /**
-* Naming convention resolver for MSW plugin.
+* Default resolver used by `@kubb/plugin-msw`. Decides the names and file
+* paths for every generated MSW handler. Function names get a `Handler`
+* suffix; the aggregate export is always `handlers`.
+*
+* @example Resolve a handler name
+* ```ts
+* import { resolverMsw } from '@kubb/plugin-msw'
 *
-* Provides default naming helpers using camelCase with a `handler` suffix.
+* resolverMsw.resolveName('addPet') // 'addPetHandler'
+* ```
 */
-const resolverMsw = defineResolver((_ctx) => ({
+const resolverMsw = defineResolver(() => ({
 	name: "default",
 	pluginName: "plugin-msw",
 	default(name, type) {
-		return camelCase(name, { isFile: type === "file" });
+		return type === "file" ? toFilePath(name) : camelCase(name);
 	},
 	resolveName(name) {
 		return camelCase(name, { suffix: "handler" });
+	},
+	resolvePathName(name, type) {
+		return this.default(name, type);
+	},
+	resolveHandlerName(node) {
+		return this.resolveName(node.operationId);
+	},
+	resolveHandlersName() {
+		return "handlers";
 	}
 }));
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
 const pluginMswName = "plugin-msw";
+/**
+* Generates MSW request handlers from an OpenAPI spec. Drop them into your
+* test setup or service worker to mock the API end-to-end. Request path,
+* method, status, and response body all stay in sync with the spec. Combine
+* with `@kubb/plugin-faker` (via `parser: 'faker'`) to seed handlers with
+* realistic data.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginMsw } from '@kubb/plugin-msw'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginMsw({
+*       output: { path: './handlers' },
+*       handlers: true,
+*     }),
+*   ],
+* })
+* ```
+*/
 const pluginMsw = definePlugin((options) => {
 	const { output = {
 		path: "handlers",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, handlers = false, parser = "data", baseURL, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: group.name ? group.name : (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMswName,
 		options,
-		dependencies: [pluginTsName, parser === "faker" ? pluginFakerName : void 0].filter(Boolean),
+		dependencies: [pluginTsName, parser === "faker" ? pluginFakerName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
 			const resolver = userResolver ? {
 				...resolverMsw,
@@ -53,7 +149,6 @@ const pluginMsw = definePlugin((options) => {
 				include,
 				override,
 				handlers,
-				transformers,
 				resolver
 			});
 			ctx.setResolver(resolver);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/resolvers/resolverMsw.ts","../src/plugin.ts"],"sourcesContent":["import { camelCase } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginMsw } from '../types.ts'\n\n/**\n * Naming convention resolver for MSW plugin.\n *\n * Provides default naming helpers using camelCase with a `handler` suffix.\n */\nexport const resolverMsw = defineResolver<PluginMsw>((_ctx) => ({\n  name: 'default',\n  pluginName: 'plugin-msw',\n  default(name, type) {\n    return camelCase(name, { isFile: type === 'file' })\n  },\n  resolveName(name) {\n    return camelCase(name, { suffix: 'handler' })\n  },\n}))\n","import { camelCase } from '@internals/utils'\nimport { definePlugin, type Group } from '@kubb/core'\nimport { pluginFakerName } from '@kubb/plugin-faker'\nimport { pluginTsName } from '@kubb/plugin-ts'\nimport { handlersGenerator, mswGenerator } from './generators'\nimport { resolverMsw } from './resolvers/resolverMsw.ts'\nimport type { PluginMsw } from './types.ts'\n\nexport const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']\n\nexport const pluginMsw = definePlugin<PluginMsw>((options) => {\n  const {\n    output = { path: 'handlers', barrelType: 'named' },\n    group,\n    exclude = [],\n    include,\n    override = [],\n    transformers = {},\n    handlers = false,\n    parser = 'data',\n    baseURL,\n    resolver: userResolver,\n    transformer: userTransformer,\n    generators: userGenerators = [],\n  } = options\n\n  const groupConfig = group\n    ? ({\n        ...group,\n        name: group.name\n          ? group.name\n          : (ctx: { group: string }) => {\n              if (group.type === 'path') {\n                return `${ctx.group.split('/')[1]}`\n              }\n              return `${camelCase(ctx.group)}Controller`\n            },\n      } satisfies Group)\n    : undefined\n\n  return {\n    name: pluginMswName,\n    options,\n    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : undefined].filter(Boolean),\n    hooks: {\n      'kubb:plugin:setup'(ctx) {\n        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw\n\n        ctx.setOptions({\n          output,\n          parser,\n          baseURL,\n          group: groupConfig,\n          exclude,\n          include,\n          override,\n          handlers,\n          transformers,\n          resolver,\n        })\n        ctx.setResolver(resolver)\n        if (userTransformer) {\n          ctx.setTransformer(userTransformer)\n        }\n\n        ctx.addGenerator(mswGenerator)\n        if (handlers) {\n          ctx.addGenerator(handlersGenerator)\n        }\n        for (const gen of userGenerators) {\n          ctx.addGenerator(gen)\n        }\n      },\n    },\n  }\n})\n\nexport default pluginMsw\n"],"mappings":";;;;;;;;;;;;AASA,MAAa,cAAc,gBAA2B,UAAU;CAC9D,MAAM;CACN,YAAY;CACZ,QAAQ,MAAM,MAAM;AAClB,SAAO,UAAU,MAAM,EAAE,QAAQ,SAAS,QAAQ,CAAC;;CAErD,YAAY,MAAM;AAChB,SAAO,UAAU,MAAM,EAAE,QAAQ,WAAW,CAAC;;CAEhD,EAAE;;;ACVH,MAAa,gBAAgB;AAE7B,MAAa,YAAY,cAAyB,YAAY;CAC5D,MAAM,EACJ,SAAS;EAAE,MAAM;EAAY,YAAY;EAAS,EAClD,OACA,UAAU,EAAE,EACZ,SACA,WAAW,EAAE,EACb,eAAe,EAAE,EACjB,WAAW,OACX,SAAS,QACT,SACA,UAAU,cACV,aAAa,iBACb,YAAY,iBAAiB,EAAE,KAC7B;CAEJ,MAAM,cAAc,QACf;EACC,GAAG;EACH,MAAM,MAAM,OACR,MAAM,QACL,QAA2B;AAC1B,OAAI,MAAM,SAAS,OACjB,QAAO,GAAG,IAAI,MAAM,MAAM,IAAI,CAAC;AAEjC,UAAO,GAAG,UAAU,IAAI,MAAM,CAAC;;EAEtC,GACD,KAAA;AAEJ,QAAO;EACL,MAAM;EACN;EACA,cAAc,CAAC,cAAc,WAAW,UAAU,kBAAkB,KAAA,EAAU,CAAC,OAAO,QAAQ;EAC9F,OAAO,EACL,oBAAoB,KAAK;GACvB,MAAM,WAAW,eAAe;IAAE,GAAG;IAAa,GAAG;IAAc,GAAG;AAEtE,OAAI,WAAW;IACb;IACA;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;AACF,OAAI,YAAY,SAAS;AACzB,OAAI,gBACF,KAAI,eAAe,gBAAgB;AAGrC,OAAI,aAAa,aAAa;AAC9B,OAAI,SACF,KAAI,aAAa,kBAAkB;AAErC,QAAK,MAAM,OAAO,eAChB,KAAI,aAAa,IAAI;KAG1B;EACF;EACD"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../internals/utils/src/fs.ts","../../../internals/shared/src/group.ts","../src/resolvers/resolverMsw.ts","../src/plugin.ts"],"sourcesContent":["import { posix } from 'node:path'\nimport { camelCase } from './casing.ts'\n\nfunction toSlash(p: string): string {\n  if (p.startsWith('\\\\\\\\?\\\\')) return p\n  return p.replaceAll('\\\\', '/')\n}\n\n/**\n * Returns the relative path from `rootDir` to `filePath`, always using forward slashes\n * and prefixed with `./` when not already traversing upward.\n *\n * @example\n * ```ts\n * getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'\n * getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'\n * ```\n */\nexport function getRelativePath(rootDir?: string | null, filePath?: string | null): string {\n  if (!rootDir || !filePath) {\n    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)\n  }\n\n  const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath))\n\n  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`\n}\n\n/**\n * Builds a nested file path from a dotted name. Splits on dots that precede a letter\n * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases\n * every earlier segment, applies `caseLast` to the final segment, and joins with `/`.\n *\n * Empty segments are dropped before joining. They arise when the name starts with a dot\n * followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to\n * an empty string). Without this a leading `/` would form, which `path.resolve` reads as an\n * absolute path, letting generated files escape the configured output directory.\n *\n * @example Nested path from a dotted name\n * `toFilePath('pet.petId') // 'pet/petId'`\n *\n * @example PascalCase the final segment\n * `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`\n *\n * @example Suffix applied to the final segment only\n * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`\n */\nexport function toFilePath(name: string, caseLast: (part: string) => string = camelCase): string {\n  const parts = name.split(/\\.(?=[a-zA-Z])/)\n  return parts\n    .map((part, i) => (i === parts.length - 1 ? caseLast(part) : camelCase(part)))\n    .filter(Boolean)\n    .join('/')\n}\n","import { camelCase } from '@internals/utils'\nimport type { Group } from '@kubb/core'\n\n/**\n * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the\n * shared default naming so every plugin groups output consistently:\n *\n * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).\n * - other groups use the camelCased group (`pet store` → `petStore`).\n *\n * A user-provided `group.name` always wins over the default namer, so callers stay in\n * control of their output folders. Returns `null` when grouping is disabled, matching the\n * per-plugin convention.\n *\n * @param group - The user-supplied group option, or `undefined` to disable grouping.\n *\n * @example\n * ```ts\n * createGroupConfig(group) // shared across every plugin\n * ```\n */\nexport function createGroupConfig(group: Group | undefined): Group | null {\n  if (!group) {\n    return null\n  }\n\n  const defaultName = (ctx: { group: string }): string => {\n    if (group.type === 'path') {\n      return `${ctx.group.split('/')[1]}`\n    }\n\n    return camelCase(ctx.group)\n  }\n\n  return {\n    ...group,\n    name: group.name ? group.name : defaultName,\n  } satisfies Group\n}\n","import { camelCase, toFilePath } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginMsw } from '../types.ts'\n\n/**\n * Default resolver used by `@kubb/plugin-msw`. Decides the names and file\n * paths for every generated MSW handler. Function names get a `Handler`\n * suffix; the aggregate export is always `handlers`.\n *\n * @example Resolve a handler name\n * ```ts\n * import { resolverMsw } from '@kubb/plugin-msw'\n *\n * resolverMsw.resolveName('addPet') // 'addPetHandler'\n * ```\n */\nexport const resolverMsw = defineResolver<PluginMsw>(() => ({\n  name: 'default',\n  pluginName: 'plugin-msw',\n  default(name, type) {\n    return type === 'file' ? toFilePath(name) : camelCase(name)\n  },\n  resolveName(name) {\n    return camelCase(name, { suffix: 'handler' })\n  },\n  resolvePathName(name, type) {\n    return this.default(name, type)\n  },\n  resolveHandlerName(node) {\n    return this.resolveName(node.operationId)\n  },\n  resolveHandlersName() {\n    return 'handlers'\n  },\n}))\n","import { createGroupConfig } from '@internals/shared'\nimport { definePlugin } from '@kubb/core'\nimport { pluginFakerName } from '@kubb/plugin-faker'\nimport { pluginTsName } from '@kubb/plugin-ts'\nimport { handlersGenerator, mswGenerator } from './generators'\nimport { resolverMsw } from './resolvers/resolverMsw.ts'\nimport type { PluginMsw } from './types.ts'\n\n/**\n * Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and\n * cross-plugin dependency references.\n */\nexport const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']\n\n/**\n * Generates MSW request handlers from an OpenAPI spec. Drop them into your\n * test setup or service worker to mock the API end-to-end. Request path,\n * method, status, and response body all stay in sync with the spec. Combine\n * with `@kubb/plugin-faker` (via `parser: 'faker'`) to seed handlers with\n * realistic data.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n * import { pluginMsw } from '@kubb/plugin-msw'\n *\n * export default defineConfig({\n *   input: { path: './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [\n *     pluginTs(),\n *     pluginMsw({\n *       output: { path: './handlers' },\n *       handlers: true,\n *     }),\n *   ],\n * })\n * ```\n */\nexport const pluginMsw = definePlugin<PluginMsw>((options) => {\n  const {\n    output = { path: 'handlers', barrel: { type: 'named' } },\n    group,\n    exclude = [],\n    include,\n    override = [],\n    handlers = false,\n    parser = 'data',\n    baseURL,\n    resolver: userResolver,\n    transformer: userTransformer,\n    generators: userGenerators = [],\n  } = options\n\n  const groupConfig = createGroupConfig(group)\n\n  return {\n    name: pluginMswName,\n    options,\n    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : null].filter((dependency): dependency is string => Boolean(dependency)),\n    hooks: {\n      'kubb:plugin:setup'(ctx) {\n        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw\n\n        ctx.setOptions({\n          output,\n          parser,\n          baseURL,\n          group: groupConfig,\n          exclude,\n          include,\n          override,\n          handlers,\n          resolver,\n        })\n        ctx.setResolver(resolver)\n        if (userTransformer) {\n          ctx.setTransformer(userTransformer)\n        }\n\n        ctx.addGenerator(mswGenerator)\n        if (handlers) {\n          ctx.addGenerator(handlersGenerator)\n        }\n        for (const gen of userGenerators) {\n          ctx.addGenerator(gen)\n        }\n      },\n    },\n  }\n})\n\nexport default pluginMsw\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,WAAW,MAAc,WAAqC,WAAmB;CAC/F,MAAM,QAAQ,KAAK,MAAM,gBAAgB;CACzC,OAAO,MACJ,KAAK,MAAM,MAAO,MAAM,MAAM,SAAS,IAAI,SAAS,IAAI,IAAI,UAAU,IAAI,CAAE,CAAC,CAC7E,OAAO,OAAO,CAAC,CACf,KAAK,GAAG;AACb;;;;;;;;;;;;;;;;;;;;;AChCA,SAAgB,kBAAkB,OAAwC;CACxE,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,eAAe,QAAmC;EACtD,IAAI,MAAM,SAAS,QACjB,OAAO,GAAG,IAAI,MAAM,MAAM,GAAG,CAAC,CAAC;EAGjC,OAAO,UAAU,IAAI,KAAK;CAC5B;CAEA,OAAO;EACL,GAAG;EACH,MAAM,MAAM,OAAO,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;;;;;ACtBA,MAAa,cAAc,sBAAiC;CAC1D,MAAM;CACN,YAAY;CACZ,QAAQ,MAAM,MAAM;EAClB,OAAO,SAAS,SAAS,WAAW,IAAI,IAAI,UAAU,IAAI;CAC5D;CACA,YAAY,MAAM;EAChB,OAAO,UAAU,MAAM,EAAE,QAAQ,UAAU,CAAC;CAC9C;CACA,gBAAgB,MAAM,MAAM;EAC1B,OAAO,KAAK,QAAQ,MAAM,IAAI;CAChC;CACA,mBAAmB,MAAM;EACvB,OAAO,KAAK,YAAY,KAAK,WAAW;CAC1C;CACA,sBAAsB;EACpB,OAAO;CACT;AACF,EAAE;;;;;;;ACtBF,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B7B,MAAa,YAAY,cAAyB,YAAY;CAC5D,MAAM,EACJ,SAAS;EAAE,MAAM;EAAY,QAAQ,EAAE,MAAM,QAAQ;CAAE,GACvD,OACA,UAAU,CAAC,GACX,SACA,WAAW,CAAC,GACZ,WAAW,OACX,SAAS,QACT,SACA,UAAU,cACV,aAAa,iBACb,YAAY,iBAAiB,CAAC,MAC5B;CAEJ,MAAM,cAAc,kBAAkB,KAAK;CAE3C,OAAO;EACL,MAAM;EACN;EACA,cAAc,CAAC,cAAc,WAAW,UAAU,kBAAkB,IAAI,CAAC,CAAC,QAAQ,eAAqC,QAAQ,UAAU,CAAC;EAC1I,OAAO,EACL,oBAAoB,KAAK;GACvB,MAAM,WAAW,eAAe;IAAE,GAAG;IAAa,GAAG;GAAa,IAAI;GAEtE,IAAI,WAAW;IACb;IACA;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA;GACF,CAAC;GACD,IAAI,YAAY,QAAQ;GACxB,IAAI,iBACF,IAAI,eAAe,eAAe;GAGpC,IAAI,aAAa,YAAY;GAC7B,IAAI,UACF,IAAI,aAAa,iBAAiB;GAEpC,KAAK,MAAM,OAAO,gBAChB,IAAI,aAAa,GAAG;EAExB,EACF;CACF;AACF,CAAC"}

package/dist/types-B1yTWOfj.d.ts

@@ -0,0 +1,99 @@
+import { t as __name } from "./chunk-C0LytTxp.js";
+import { Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
+
+//#region src/types.d.ts
+/**
+ * Resolver for MSW that provides naming methods for handler functions.
+ */
+type ResolverMsw = Resolver & {
+  /**
+   * Resolves the base handler function name for an operation.
+   */
+  resolveName(this: ResolverMsw, name: string): string;
+  /**
+   * Resolves the output file name for an MSW handler module.
+   */
+  resolvePathName(this: ResolverMsw, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
+  /**
+   * Resolves the handler function name for an operation.
+   */
+  resolveHandlerName(this: ResolverMsw, node: ast.OperationNode): string;
+  /**
+   * Resolves the exported handlers collection name.
+   */
+  resolveHandlersName(this: ResolverMsw): string;
+};
+/**
+ * Where the generated MSW handlers are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'handlers', barrel: { type: 'named' } }
+ */
+type Options = OutputOptions & {
+  /**
+   * Base URL prepended to every handler's request URL. When omitted, falls back
+   * to the adapter's server URL (typically `servers[0].url`).
+   */
+  baseURL?: string;
+  /**
+   * Skip operations matching at least one entry in the list.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Restrict generation to operations matching at least one entry in the list.
+   */
+  include?: Array<Include>;
+  /**
+   * Apply a different options object to operations matching a pattern.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Override how handler names and file paths are built.
+   */
+  resolver?: Partial<ResolverMsw> & ThisType<ResolverMsw>;
+  /**
+   * AST visitor applied to operation nodes before printing.
+   */
+  transformer?: ast.Visitor;
+  /**
+   * Emit a `handlers.ts` file that re-exports every handler grouped by HTTP method.
+   * Drop the file into `setupServer(...handlers)` or `setupWorker(...handlers)`.
+   *
+   * @default false
+   */
+  handlers?: boolean;
+  /**
+   * Source of the response body returned by each generated handler.
+   * - `'data'` — typed empty/example payload, ready for you to fill in from tests.
+   * - `'faker'` — value produced by `@kubb/plugin-faker`.
+   *
+   * @default 'data'
+   */
+  parser?: 'data' | 'faker';
+  /**
+   * Custom generators that run alongside the built-in MSW generators.
+   */
+  generators?: Array<Generator<PluginMsw>>;
+};
+type ResolvedOptions = {
+  output: Output;
+  group: Group | null;
+  exclude: NonNullable<Options['exclude']>;
+  include: Options['include'];
+  override: NonNullable<Options['override']>;
+  parser: NonNullable<Options['parser']>;
+  baseURL: Options['baseURL'] | undefined;
+  handlers: boolean;
+  resolver: ResolverMsw;
+};
+type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, ResolverMsw>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-msw': PluginMsw;
+    }
+  }
+}
+//#endregion
+export { PluginMsw as n, Options as t };
+//# sourceMappingURL=types-B1yTWOfj.d.ts.map

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "@kubb/plugin-msw",
-  "version": "5.0.0-beta.4",
-  "description": "Mock Service Worker (MSW) handlers generator plugin for Kubb, creating API mocks from OpenAPI specifications for frontend development and testing.",
+  "version": "5.0.0-beta.56",
+  "description": "Generate Mock Service Worker (MSW) request handlers from your OpenAPI specification. Intercept HTTP requests in the browser or Node.js for seamless frontend development and testing.",
   "keywords": [
     "api-mocking",
-    "code-generator",
+    "code-generation",
     "codegen",
-    "development",
-    "interceptor",
     "kubb",
     "mock-service-worker",
     "mocking",
     "mocks",
     "msw",
-    "oas",
     "openapi",
-    "plugins",
+    "service-worker",
     "swagger",
-    "testing",
     "typescript"
   ],
   "license": "MIT",
@@ -30,7 +26,6 @@
   "files": [
     "src",
     "dist",
-    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -76,34 +71,29 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.4",
-    "@kubb/renderer-jsx": "5.0.0-beta.4",
-    "@kubb/plugin-faker": "5.0.0-beta.4",
-    "@kubb/plugin-ts": "5.0.0-beta.4"
+    "@kubb/core": "5.0.0-beta.55",
+    "@kubb/renderer-jsx": "5.0.0-beta.55",
+    "@kubb/plugin-faker": "5.0.0-beta.56",
+    "@kubb/plugin-ts": "5.0.0-beta.56"
   },
   "devDependencies": {
+    "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.4"
+    "@kubb/renderer-jsx": "5.0.0-beta.55"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsdown && size-limit",
-    "clean": "npx rimraf ./dist",
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "release:stage": "pnpm stage publish --no-git-check",
     "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/components/Mock.tsx

@@ -1,15 +1,16 @@
-import { URLPath } from '@internals/utils'
+import { getPrimarySuccessResponse } from '@internals/shared'
+import { Url } from '@internals/utils'
 import { ast } from '@kubb/core'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { getContentType, getMswMethod, getMswUrl, getPrimarySuccessResponse, hasResponseSchema } from '../utils.ts'
+import { getContentType, getMswMethod, getMswUrl, hasResponseSchema } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  requestTypeName?: string
-  baseURL: string | undefined
+  requestTypeName?: string | null
+  baseURL: string | null | undefined
   node: ast.OperationNode
 }
 
@@ -20,9 +21,9 @@ export function Mock({ baseURL = '', name, typeName, requestTypeName, node }: Pr
   const successResponse = getPrimarySuccessResponse(node)
   const statusCode = successResponse ? Number(successResponse.statusCode) : 200
   const contentType = getContentType(successResponse)
-  const url = new URLPath(getMswUrl(node)).toURLPath()
+  const url = Url.toPath(getMswUrl(node))
 
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
   const responseHasSchema = hasResponseSchema(successResponse)
   const dataType = responseHasSchema ? typeName : 'string | number | boolean | null | object'
 

package/src/components/MockWithFaker.tsx

@@ -1,16 +1,17 @@
-import { URLPath } from '@internals/utils'
+import { getPrimarySuccessResponse } from '@internals/shared'
+import { Url } from '@internals/utils'
 import { ast } from '@kubb/core'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { getContentType, getMswMethod, getMswUrl, getPrimarySuccessResponse } from '../utils.ts'
+import { getContentType, getMswMethod, getMswUrl } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  requestTypeName?: string
+  requestTypeName?: string | null
   fakerName: string
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   node: ast.OperationNode
 }
 
@@ -21,9 +22,9 @@ export function MockWithFaker({ baseURL = '', name, fakerName, typeName, request
   const successResponse = getPrimarySuccessResponse(node)
   const statusCode = successResponse ? Number(successResponse.statusCode) : 200
   const contentType = getContentType(successResponse)
-  const url = new URLPath(getMswUrl(node)).toURLPath()
+  const url = Url.toPath(getMswUrl(node))
 
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
 
   const callbackType = requestTypeName
     ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>`

package/src/components/Response.tsx

@@ -16,7 +16,7 @@ const declarationPrinter = functionPrinter({ mode: 'declaration' })
 export function Response({ name, typeName, response }: Props): KubbReactNode {
   const statusCode = Number(response.statusCode)
   const contentType = getContentType(response)
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
 
   const params = declarationPrinter.print(
     ast.createFunctionParameters({

package/src/components/index.ts

@@ -1,4 +1,3 @@
-export { Handlers } from './Handlers.tsx'
 export { Mock } from './Mock.tsx'
 export { MockWithFaker } from './MockWithFaker.tsx'
 export { Response } from './Response.tsx'

package/src/generators/handlersGenerator.ts

@@ -0,0 +1,49 @@
+import { ast, defineGenerator } from '@kubb/core'
+import type { PluginMsw } from '../types'
+
+/**
+ * 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)`.
+ */
+export const handlersGenerator = defineGenerator<PluginMsw>({
+  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 ?? undefined })
+
+    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 ?? undefined },
+      )
+      return ast.createImport({ name: [operationName], root: file.path, path: operationFile.path })
+    })
+
+    const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`)
+
+    return [
+      ast.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.createSource({
+            name: handlersName,
+            isIndexable: true,
+            isExportable: true,
+            nodes: [ast.createText(`export const ${handlersName} = ${JSON.stringify(handlers).replaceAll('"', '')} as const`)],
+          }),
+        ],
+      }),
+    ]
+  },
+})

package/src/generators/index.ts

@@ -1,2 +1,2 @@
-export { handlersGenerator } from './handlersGenerator.tsx'
+export { handlersGenerator } from './handlersGenerator.ts'
 export { mswGenerator } from './mswGenerator.tsx'