@kubb/plugin-swr 5.4.0 → 5.4.1

package/dist/index.js

@@ -1,27 +1,9 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import "./rolldown-runtime-C0LytTxp.js";
+import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#region ../../internals/shared/src/params.ts
-/**
-* Drops parameters that share the same name, keeping the first.
-*
-* A malformed spec can declare the same parameter name twice within one `in` location. Both would
-* resolve to the same output property, so emitting both would yield an object type with a duplicate
-* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
-* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
-*/
-function dedupeParams(params) {
-	const seen = /* @__PURE__ */ new Set();
-	return params.filter((param) => {
-		if (seen.has(param.name)) return false;
-		seen.add(param.name);
-		return true;
-	});
-}
-//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -91,12 +73,12 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 function buildRequestConfigType(node) {
 	const request = getContentTypeInfo(node);
 	const response = getResponseContentTypeInfo(node);
-	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
-	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
+	return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join("; ")} } }` : requestConfigBaseType;
 }
 /**
 * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
@@ -105,7 +87,7 @@ function buildRequestConfigType(node) {
 * content type for.
 */
 function buildClientOptionType() {
-	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	return requestConfigBaseType;
 }
 /**
 * Which of the grouped request options an operation carries.
@@ -165,11 +147,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
-		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
-		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
-		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -312,7 +302,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.4.0";
+var version = "5.4.1";
 //#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
@@ -356,7 +346,7 @@ const contractPlugins = [
 * @example
 * ```ts
 * resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
-* // { kind: 'error', message: 'No client plugin is registered…' }
+* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
 * ```
 */
 function resolveClient(options) {
@@ -366,7 +356,9 @@ function resolveClient(options) {
 		const pluginName = selectorToPlugin[client];
 		if (!has(pluginName)) return {
 			kind: "error",
-			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
 		};
 		return {
 			kind: "contract",
@@ -375,7 +367,9 @@ function resolveClient(options) {
 	}
 	if (client !== void 0) return {
 		kind: "error",
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'. Drop \`client\` to use the registered client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
 	};
 	const registered = contractPlugins.filter(has);
 	if (registered.length === 1) return {
@@ -384,25 +378,40 @@ function resolveClient(options) {
 	};
 	if (registered.length > 1) return {
 		kind: "error",
-		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios' | 'client'\` to choose which client the hooks call, or register a single client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
 	};
 	return {
 		kind: "error",
-		message: "No client plugin is registered. Add `@kubb/plugin-axios`, `@kubb/plugin-fetch`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
 	};
 }
 /**
-* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
-* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
-* misconfiguration so every consumer fails fast with the same message.
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
 */
 function resolveContractClient(options) {
-	const { client, plugins = [] } = options;
+	const { plugin, client, plugins = [] } = options;
 	const resolved = resolveClient({
 		client,
 		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
 	});
-	if (resolved.kind === "error") throw new Error(resolved.message);
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
 	return resolved;
 }
 //#endregion
@@ -466,6 +475,95 @@ function resolveClientOperation(options) {
 	});
 }
 //#endregion
+//#region ../../internals/tanstack-query/src/components/HookFile.tsx
+/**
+* Resolves what every TanStack hook file shares: its file, the `@kubb/plugin-ts` file and type names, banner and footer.
+*/
+function resolveHookFile(node, ctx, options) {
+	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [] } = options;
+	const { config, root, resolver } = ctx;
+	const pluginTs = ctx.requirePlugin(pluginTsName);
+	const tsResolver = ctx.driver.getResolver(pluginTsName);
+	const file = resolver.file({
+		...operationFileEntry(node, name),
+		root,
+		output,
+		group: group ?? void 0
+	});
+	const fileTs = resolveDependencyOperationFile({
+		cache: ctx.cache,
+		node,
+		resolver: tsResolver,
+		root,
+		output: pluginTs.options?.output ?? output,
+		group: pluginTs.options?.group
+	});
+	const importedTypeNames = [
+		tsResolver.response.options(node),
+		...extraTypeNames,
+		...resolveOperationTypeNames(node, tsResolver, {
+			exclude: keyTypeName ? [keyTypeName] : void 0,
+			order: "body-response-first",
+			includeParams: false
+		})
+	].filter((typeName) => Boolean(typeName));
+	const fileMeta = {
+		path: file.path,
+		baseName: file.baseName
+	};
+	return {
+		file,
+		fileTs,
+		tsResolver,
+		contractOp,
+		importedTypeNames,
+		banner: resolver.default.banner(ctx.meta, {
+			output,
+			config,
+			file: fileMeta
+		}),
+		footer: resolver.default.footer(ctx.meta, {
+			output,
+			config,
+			file: fileMeta
+		})
+	};
+}
+/**
+* The `<File>` shell shared by the TanStack hook generators; renders `children` after the imports.
+*/
+function HookFile({ hook, imports, children }) {
+	const { file, fileTs, contractOp, importedTypeNames, banner, footer } = hook;
+	return /* @__PURE__ */ jsxs(File, {
+		baseName: file.baseName,
+		path: file.path,
+		meta: file.meta,
+		banner,
+		footer,
+		children: [
+			/* @__PURE__ */ jsx(File.Import, {
+				name: [contractOp.name],
+				root: file.path,
+				path: contractOp.path
+			}),
+			/* @__PURE__ */ jsx(File.Import, {
+				name: ["RequestConfig", "ResponseErrorConfig"],
+				root: contractOp.clientPathIsFile ? file.path : void 0,
+				path: contractOp.clientPath,
+				isTypeOnly: true
+			}),
+			imports,
+			fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+				name: Array.from(new Set(importedTypeNames)),
+				root: file.path,
+				path: fileTs.path,
+				isTypeOnly: true
+			}),
+			children
+		]
+	});
+}
+//#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
 * The grouped request options, ordered for both the destructured signature and the
@@ -588,6 +686,19 @@ function buildCallResultBody(call, options = {}) {
 	return `return ${call}.unwrap()`;
 }
 /**
+* Builds the `TData` / `TError` type expressions shared by every generated hook, joining the resolved
+* success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
+*/
+function buildResponseTypes(node, resolver) {
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	return {
+		TData: responseName,
+		TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
+	};
+}
+/**
 * Applies the shared query defaults during plugin setup: `false` disables query generation, and an
 * object merges over `methods: ['GET', 'QUERY']` and the plugin's runtime `importPath`. QUERY
 * (RFC 10008) is a safe, idempotent read that carries its input in the body, so it is a query too.
@@ -647,13 +758,30 @@ const queryKeyGroupOrder = [
 * grouped `path`/`query`/`body` bindings.
 */
 function buildQueryKeyParams(node, options) {
-	const { resolver } = options;
+	const { resolver, memberTypeWrapper } = options;
 	const groupedParam = buildGroupedRequestParam(node, {
 		resolver,
-		keys: queryKeyGroupOrder
+		keys: queryKeyGroupOrder,
+		memberTypeWrapper
 	});
 	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
 }
+/**
+* Builds the hook parameter list: the grouped request param (omitted when `withRequest` is `false`) then `options` typed as `optionsType`.
+*/
+function buildHookParams(node, options) {
+	const { resolver, optionsType, memberTypeWrapper, withRequest = true } = options;
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: optionsType,
+		default: "{}"
+	});
+	const groupedParam = withRequest ? buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}) : null;
+	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
+}
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
@@ -661,7 +789,7 @@ const mutationKeyTransformer = ({ node }) => {
 	if (!node.path) return [];
 	return [`{ url: '${Url.toPath(node.path)}' }`];
 };
-function MutationKey$1({ name, node, transformer }) {
+function MutationKey({ name, node, transformer, typeName }) {
 	const paramsNode = createFunctionParameters({ params: [] });
 	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
@@ -669,7 +797,7 @@ function MutationKey$1({ name, node, transformer }) {
 		casing: "camelcase",
 		variant: "mutation"
 	});
-	return /* @__PURE__ */ jsx(File.Source, {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
 		isIndexable: true,
@@ -680,9 +808,18 @@ function MutationKey$1({ name, node, transformer }) {
 			singleLine: true,
 			children: `[${keys.join(", ")}] as const`
 		})
-	});
+	}), typeName && /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			export: true,
+			name: typeName,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
 }
-__name(MutationKey$1, "MutationKey");
 //#endregion
 //#region ../../internals/tanstack-query/src/resolver.ts
 /**
@@ -751,8 +888,11 @@ const queryKeyTransformer = ({ node, variant }) => {
 	if (node.requestBody?.content?.[0]?.schema) result.push("...(body !== undefined ? [body] : [])");
 	return result;
 };
-function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query" }) {
-	const paramsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query", memberTypeWrapper, exportType }) {
+	const paramsNode = buildQueryKeyParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper
+	});
 	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
 	const keys = (transformer ?? queryKeyTransformer)({
 		node,
@@ -772,9 +912,12 @@ function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "qu
 		})
 	}), /* @__PURE__ */ jsx(File.Source, {
 		name: typeName,
+		isExportable: exportType,
+		isIndexable: exportType,
 		isTypeOnly: true,
 		children: /* @__PURE__ */ jsx(Type, {
 			name: typeName,
+			export: exportType,
 			children: `ReturnType<typeof ${name}>`
 		})
 	})] });
@@ -785,11 +928,7 @@ const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
 	const { mutationKeyTypeName, mutationArgTypeName, resolver } = options;
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
-	const errorNames = resolveErrorNames(node, resolver);
-	const TData = responseName;
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const { TData, TError } = buildResponseTypes(node, resolver);
 	return createFunctionParameters({ params: [createFunctionParameter({
 		name: "options",
 		type: `{
@@ -801,11 +940,7 @@ function buildMutationParamsNode(node, options) {
 	})] });
 }
 function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, mutationArgTypeName, node, tsResolver, returnType = "full" }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.response.response(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = responseName;
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
 	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
@@ -862,62 +997,99 @@ function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, muta
 	})] });
 }
 //#endregion
-//#region src/components/MutationKey.tsx
-function MutationKey({ name, typeName, node, transformer }) {
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MutationKey$1, {
-		name,
-		node,
-		transformer
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			export: true,
-			name: typeName,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
+//#region src/generators/mutationGenerator.tsx
+/**
+* Built-in generator for `useSWRMutation` hooks. Emits one `useFooMutation` hook
+* per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
+* the matching `fooMutationKey` helper.
+*/
+const mutationGenerator = defineGenerator({
+	name: "swr-mutation",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { driver, resolver, root } = ctx;
+		const { output, query, mutation, client, group } = ctx.options;
+		const { isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isMutation) return null;
+		const importPath = mutation ? mutation.importPath : "swr/mutation";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output,
+			cache: ctx.cache
+		});
+		if (!contractOp) return null;
+		const mutationHookName = resolver.mutation.name(node);
+		const mutationKeyName = resolver.mutation.keyName(node);
+		const mutationKeyTypeName = resolver.mutation.keyTypeName(node);
+		const mutationArgTypeName = resolver.mutation.argTypeName(node);
+		const hook = resolveHookFile(node, ctx, {
+			name: mutationHookName,
+			output,
+			group,
+			contractOp
+		});
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
+			children: [/* @__PURE__ */ jsx(MutationKey, {
+				name: mutationKeyName,
+				typeName: mutationKeyTypeName,
+				node,
+				transformer: ctx.options.mutationKey
+			}), mutation && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: "useSWRMutation",
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["SWRMutationConfiguration"],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(Mutation, {
+					name: mutationHookName,
+					clientName: contractOp.name,
+					mutationKeyName,
+					mutationKeyTypeName,
+					mutationArgTypeName,
+					node,
+					tsResolver: hook.tsResolver,
+					returnType: contractOp.returnType
+				})
+			] })]
+		});
+	}
+});
 //#endregion
 //#region src/components/Query.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
-function buildQueryParamsNode(node, options) {
-	const { resolver } = options;
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
-	const errorNames = resolveErrorNames(node, resolver);
-	const TData = responseName;
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: SWRConfiguration<${[TData, TError].join(", ")}>,
-  client?: ${buildClientOptionType()},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}`,
-		default: "{}"
-	});
-	const groupedParam = buildGroupedRequestParam(node, { resolver });
-	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
-}
 function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.response.response(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
 	const generics = [
-		responseName,
-		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		TData,
+		TError,
 		`${queryKeyTypeName} | null`
 	];
 	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
 	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
 	const queryOptionsParamsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
 	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
+	const paramsNode = buildHookParams(node, {
+		resolver: tsResolver,
+		optionsType: `{
+  query?: SWRConfiguration<${[TData, TError].join(", ")}>,
+  client?: ${buildClientOptionType()},
+  shouldFetch?: boolean,
+  immutable?: boolean
+}`
+	});
 	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -978,134 +1150,6 @@ function QueryOptions({ name, clientName, node, tsResolver, returnType = "full"
 	});
 }
 //#endregion
-//#region src/generators/mutationGenerator.tsx
-/**
-* Built-in generator for `useSWRMutation` hooks. Emits one `useFooMutation` hook
-* per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
-* the matching `fooMutationKey` helper.
-*/
-const mutationGenerator = defineGenerator({
-	name: "swr-mutation",
-	renderer: jsxRenderer,
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, query, mutation, client, group } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
-		const { isMutation } = classifyOperation(node, {
-			query,
-			mutation
-		});
-		if (!isMutation) return null;
-		const importPath = mutation ? mutation.importPath : "swr/mutation";
-		const contractOp = resolveClientOperation({
-			clientPlugin: { pluginName: client.pluginName },
-			driver,
-			node,
-			root,
-			output,
-			cache: ctx.cache
-		});
-		if (!contractOp) return null;
-		const mutationHookName = resolver.mutation.name(node);
-		const mutationKeyName = resolver.mutation.keyName(node);
-		const mutationKeyTypeName = resolver.mutation.keyTypeName(node);
-		const mutationArgTypeName = resolver.mutation.argTypeName(node);
-		const meta = {
-			file: resolver.file({
-				name: mutationHookName,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
-				root,
-				output,
-				group
-			}),
-			fileTs: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
-			order: "body-response-first",
-			includeParams: false
-		})].filter((name) => Boolean(name));
-		const calledClientName = contractOp.name;
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: meta.file.baseName,
-			path: meta.file.path,
-			meta: meta.file.meta,
-			banner: resolver.default.banner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			footer: resolver.default.footer(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			children: [
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(MutationKey, {
-					name: mutationKeyName,
-					typeName: mutationKeyTypeName,
-					node,
-					transformer: ctx.options.mutationKey
-				}),
-				mutation && /* @__PURE__ */ jsxs(Fragment, { children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: "useSWRMutation",
-						path: importPath
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["SWRMutationConfiguration"],
-						path: importPath,
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ jsx(Mutation, {
-						name: mutationHookName,
-						clientName: calledClientName,
-						mutationKeyName,
-						mutationKeyTypeName,
-						mutationArgTypeName,
-						node,
-						tsResolver,
-						returnType: contractOp.returnType
-					})
-				] })
-			]
-		});
-	}
-});
-//#endregion
 //#region src/generators/queryGenerator.tsx
 /**
 * Built-in generator for `useSWR` hooks. Emits one `useFoo` hook per read operation plus the
@@ -1116,10 +1160,8 @@ const queryGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
+		const { driver, resolver, root } = ctx;
 		const { output, query, mutation, client, group } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
 		const { isQuery } = classifyOperation(node, {
 			query,
 			mutation
@@ -1139,69 +1181,17 @@ const queryGenerator = defineGenerator({
 		const queryOptionsName = resolver.query.optionsName(node);
 		const queryKeyName = resolver.query.keyName(node);
 		const queryKeyTypeName = resolver.query.keyTypeName(node);
-		const meta = {
-			file: resolver.file({
-				name: queryName,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
-				root,
-				output,
-				group
-			}),
-			fileTs: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
-			exclude: [queryKeyTypeName],
-			order: "body-response-first",
-			includeParams: false
-		})].filter((name) => Boolean(name));
-		const calledClientName = contractOp.name;
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: meta.file.baseName,
-			path: meta.file.path,
-			meta: meta.file.meta,
-			banner: resolver.default.banner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			footer: resolver.default.footer(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
+		const hook = resolveHookFile(node, ctx, {
+			name: queryName,
+			output,
+			group,
+			contractOp,
+			keyTypeName: queryKeyTypeName
+		});
+		const { tsResolver } = hook;
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
 			children: [
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
 				/* @__PURE__ */ jsx(QueryKey, {
 					name: queryKeyName,
 					typeName: queryKeyTypeName,
@@ -1212,7 +1202,7 @@ const queryGenerator = defineGenerator({
 				}),
 				/* @__PURE__ */ jsx(QueryOptions, {
 					name: queryOptionsName,
-					clientName: calledClientName,
+					clientName: contractOp.name,
 					node,
 					tsResolver,
 					returnType: contractOp.returnType
@@ -1319,6 +1309,7 @@ const pluginSwr = defineExtension({
 		return {
 			output,
 			client: resolveContractClient({
+				plugin: pluginSwrName,
 				client,
 				plugins: useConfig().plugins
 			}),