@tanstack/lit-query 0.2.11 → 0.2.13

package/build/modern/index.js

@@ -0,0 +1,1545 @@
+import { InfiniteQueryObserver, MutationObserver, QueriesObserver, QueryObserver, replaceEqualDeep } from "@tanstack/query-core";
+import { ContextEvent, ContextProvider, createContext } from "@lit/context";
+import { LitElement, html } from "lit";
+export * from "@tanstack/query-core";
+//#region src/context.ts
+/**
+* Lit context key used by `QueryClientProvider` and host-bound APIs to share a
+* `QueryClient` through the DOM tree.
+*
+* Most applications use `QueryClientProvider` instead of interacting with this
+* context directly.
+*/
+const queryClientContext = createContext(Symbol.for("tanstack-query-client"));
+const missingQueryClientMessage = "No QueryClient available. Pass one explicitly or render within QueryClientProvider.";
+const ambiguousQueryClientMessage = "Multiple QueryClients are mounted. Pass one explicitly instead of relying on global QueryClient helpers.";
+const registeredClients = /* @__PURE__ */ new Map();
+let defaultClient;
+/**
+* Registers a `QueryClient` as a process-local fallback for APIs that resolve a
+* client without an explicit argument.
+*
+* `QueryClientProvider` calls this automatically while it is connected. Prefer
+* passing an explicit client or rendering under a provider when possible.
+*
+* @param client - The query client to register as the current default.
+*/
+function registerDefaultQueryClient(client) {
+	registeredClients.set(client, (registeredClients.get(client) ?? 0) + 1);
+	defaultClient = client;
+}
+/**
+* Unregisters a client previously registered with
+* `registerDefaultQueryClient`.
+*
+* `QueryClientProvider` calls this automatically when it disconnects.
+*
+* @param client - The query client registration to release.
+*/
+function unregisterDefaultQueryClient(client) {
+	const count = registeredClients.get(client);
+	if (count === void 0) return;
+	if (count > 1) {
+		registeredClients.set(client, count - 1);
+		return;
+	}
+	registeredClients.delete(client);
+	if (defaultClient !== client) return;
+	defaultClient = [...registeredClients.keys()].at(-1);
+}
+/**
+* Returns the registered default `QueryClient`, if exactly one default client is
+* available.
+*
+* @returns The default query client, or `undefined` when there is no registered
+* client or more than one registered client.
+*/
+function getDefaultQueryClient() {
+	if (registeredClients.size > 1) return;
+	return defaultClient;
+}
+function createMissingQueryClientError() {
+	return /* @__PURE__ */ new Error(missingQueryClientMessage);
+}
+function createAmbiguousQueryClientError() {
+	return /* @__PURE__ */ new Error(ambiguousQueryClientMessage);
+}
+/**
+* Resolves the current default `QueryClient` registered by a connected
+* `QueryClientProvider`.
+*
+* This helper is useful outside a Lit reactive controller when a single
+* provider is mounted. It throws if no client is registered or if multiple
+* clients are mounted and the default would be ambiguous.
+*
+* @returns The single registered query client.
+*/
+function useQueryClient() {
+	const client = getDefaultQueryClient();
+	if (client) return client;
+	if (registeredClients.size > 1) throw createAmbiguousQueryClientError();
+	throw createMissingQueryClientError();
+}
+/**
+* Resolves an explicit `QueryClient` or falls back to `useQueryClient`.
+*
+* @param explicit - Optional client supplied by the caller.
+* @returns The explicit client when provided, otherwise the current default
+* client.
+*/
+function resolveQueryClient(explicit) {
+	return explicit ?? useQueryClient();
+}
+//#endregion
+//#region src/QueryClientProvider.ts
+/**
+* Lit element that provides a `QueryClient` to descendant Lit Query
+* controllers through Lit context.
+*
+* The `client` is a property, not an attribute. When rendering this element in
+* a Lit template, bind it with property binding: `.client=${queryClient}`.
+* The provider throws if it connects without a client, or if an already
+* connected provider has its client cleared.
+*
+* This class is not registered as a custom element by the package. Applications
+* must register either a subclass or the class itself with
+* `customElements.define`.
+*
+* @example
+* ```ts
+* import { html, LitElement } from 'lit'
+* import { QueryClient, QueryClientProvider } from '@tanstack/lit-query'
+*
+* const queryClient = new QueryClient()
+*
+* class AppQueryProvider extends QueryClientProvider {
+*   constructor() {
+*     super()
+*     this.client = queryClient
+*   }
+* }
+*
+* customElements.define('app-query-provider', AppQueryProvider)
+*
+* class AppRoot extends LitElement {
+*   render() {
+*     return html`<app-query-provider><todos-view></todos-view></app-query-provider>`
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* import { html } from 'lit'
+* import { QueryClient, QueryClientProvider } from '@tanstack/lit-query'
+*
+* const queryClient = new QueryClient()
+*
+* customElements.define('query-client-provider', QueryClientProvider)
+*
+* const view = html`
+*   <query-client-provider .client=${queryClient}>
+*     <todos-view></todos-view>
+*   </query-client-provider>
+* `
+* ```
+*/
+var QueryClientProvider = class extends LitElement {
+	static {
+		this.properties = { client: { attribute: false } };
+	}
+	constructor() {
+		super();
+		this.contextProvider = new ContextProvider(this, { context: queryClientContext });
+	}
+	/** @internal */
+	connectedCallback() {
+		super.connectedCallback();
+		const client = this.requireClient();
+		this.contextProvider.setValue(client);
+		this.mountClient(client);
+	}
+	/** @internal */
+	disconnectedCallback() {
+		this.unmountClient(this.mountedClient);
+		super.disconnectedCallback();
+	}
+	/** @internal */
+	willUpdate(changedProperties) {
+		if (!changedProperties.has("client")) return;
+		const nextClient = this.client;
+		if (!nextClient) {
+			if (this.isConnected) {
+				this.unmountClient(this.mountedClient);
+				this.contextProvider.setValue(void 0);
+				throw createMissingQueryClientError();
+			}
+			return;
+		}
+		const previousClient = changedProperties.get("client");
+		if (previousClient && previousClient !== nextClient && this.isConnected) this.unmountClient(previousClient);
+		this.contextProvider.setValue(nextClient);
+		if (this.isConnected) this.mountClient(nextClient);
+	}
+	/** @internal */
+	render() {
+		return html`<slot></slot>`;
+	}
+	mountClient(client) {
+		if (this.mountedClient === client) return;
+		if (this.mountedClient) this.unmountClient(this.mountedClient);
+		client.mount();
+		registerDefaultQueryClient(client);
+		this.mountedClient = client;
+	}
+	unmountClient(client) {
+		if (!client) return;
+		client.unmount();
+		unregisterDefaultQueryClient(client);
+		if (this.mountedClient === client) this.mountedClient = void 0;
+	}
+	requireClient() {
+		if (!this.client) throw createMissingQueryClientError();
+		return this.client;
+	}
+};
+//#endregion
+//#region src/accessor.ts
+function readAccessor(value) {
+	return typeof value === "function" ? value() : value;
+}
+function createValueAccessor(getter) {
+	const accessor = (() => getter());
+	Object.defineProperty(accessor, "current", {
+		get: getter,
+		enumerable: true
+	});
+	return accessor;
+}
+//#endregion
+//#region src/controllers/BaseController.ts
+var BaseController = class {
+	constructor(host, initialResult, queryClient) {
+		this.host = host;
+		this.connected = false;
+		this.destroyed = false;
+		this.updateQueued = false;
+		this.clientChangeQueued = false;
+		this.connectionAttempt = 0;
+		this.isHostUpdating = false;
+		this.explicitClient = queryClient;
+		this.result = initialResult;
+		this.queryClientResolutionState = queryClient ? "bound" : "pre-connect";
+		host.addController(this);
+	}
+	hostConnected() {
+		if (this.connected || this.destroyed) return;
+		this.connected = true;
+		let contextResolutionAttempt;
+		if (this.explicitClient) this.queryClientResolutionState = "bound";
+		else {
+			contextResolutionAttempt = ++this.connectionAttempt;
+			this.beginContextResolution();
+		}
+		queueMicrotask(() => {
+			if (this.connected && !this.destroyed) this.onConnected();
+		});
+		if (contextResolutionAttempt !== void 0) this.queueContextResolution(contextResolutionAttempt);
+	}
+	hostDisconnected() {
+		if (!this.connected) return;
+		this.connected = false;
+		if (!this.explicitClient) {
+			this.connectionAttempt += 1;
+			this.clearContextClient();
+			this.updateQueryClientResolutionState("pre-connect");
+		}
+		this.onDisconnected();
+	}
+	hostUpdate() {
+		if (this.destroyed) return;
+		this.isHostUpdating = true;
+		try {
+			this.onHostUpdate();
+		} finally {
+			this.isHostUpdating = false;
+		}
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.connected = false;
+		this.connectionAttempt += 1;
+		this.clearContextClient();
+		this.queryClientResolutionState = this.explicitClient ? "bound" : "pre-connect";
+		this.onDisconnected();
+		if ("removeController" in this.host) this.host.removeController(this);
+	}
+	tryGetQueryClient() {
+		return this.explicitClient ?? this.contextClient;
+	}
+	getQueryClient() {
+		const client = this.tryGetQueryClient();
+		if (!client) throw createMissingQueryClientError();
+		return client;
+	}
+	setResult(next) {
+		if (Object.is(this.result, next)) return;
+		this.result = next;
+		if (!this.isHostUpdating) this.queueUpdate();
+	}
+	get current() {
+		if (this.queryClientResolutionState === "missing") throw createMissingQueryClientError();
+		return this.result;
+	}
+	get connectedState() {
+		return this.connected;
+	}
+	queueUpdate() {
+		if (this.updateQueued) return;
+		this.updateQueued = true;
+		queueMicrotask(() => {
+			this.updateQueued = false;
+			if (!this.destroyed) this.host.requestUpdate();
+		});
+	}
+	queueQueryClientChanged() {
+		if (this.clientChangeQueued) return;
+		this.clientChangeQueued = true;
+		queueMicrotask(() => {
+			this.clientChangeQueued = false;
+			if (!this.destroyed) this.onQueryClientChanged();
+		});
+	}
+	beginContextResolution() {
+		this.clearContextClient();
+		this.updateQueryClientResolutionState("awaiting-context");
+	}
+	queueContextResolution(attempt) {
+		queueMicrotask(() => {
+			if (this.destroyed || !this.connected || attempt !== this.connectionAttempt || this.queryClientResolutionState !== "awaiting-context") return;
+			this.dispatchContextRequest(attempt);
+			this.queueInitialContextResolutionCompletion(attempt);
+		});
+	}
+	dispatchContextRequest(attempt) {
+		if (!("dispatchEvent" in this.host)) return;
+		const contextTarget = this.host;
+		contextTarget.dispatchEvent(new ContextEvent(queryClientContext, contextTarget, (value, unsubscribe) => {
+			if (this.destroyed || !this.connected || attempt !== this.connectionAttempt) {
+				unsubscribe?.();
+				return;
+			}
+			if (this.contextUnsubscribe && this.contextUnsubscribe !== unsubscribe) this.contextUnsubscribe();
+			const resolutionChanged = this.updateQueryClientResolutionState(value === void 0 ? "missing" : "bound");
+			const clientChanged = this.contextClient !== value;
+			this.contextClient = value;
+			this.contextUnsubscribe = unsubscribe;
+			if (resolutionChanged || clientChanged) {
+				this.queueUpdate();
+				this.queueQueryClientChanged();
+			}
+		}, true));
+	}
+	queueInitialContextResolutionCompletion(attempt) {
+		queueMicrotask(() => {
+			if (this.destroyed || !this.connected || attempt !== this.connectionAttempt || this.queryClientResolutionState !== "awaiting-context") return;
+			if (this.updateQueryClientResolutionState("missing")) {
+				this.queueUpdate();
+				this.queueQueryClientChanged();
+			}
+		});
+	}
+	clearContextClient() {
+		this.contextUnsubscribe?.();
+		this.contextUnsubscribe = void 0;
+		this.contextClient = void 0;
+	}
+	updateQueryClientResolutionState(nextState) {
+		if (this.queryClientResolutionState === nextState) return false;
+		this.queryClientResolutionState = nextState;
+		return true;
+	}
+};
+//#endregion
+//#region src/queryObserverResultTracker.ts
+var QueryObserverResultTracker = class {
+	constructor() {
+		this.usesTracking = false;
+	}
+	reset() {
+		this.result = void 0;
+		this.usesTracking = false;
+	}
+	update(observer, result) {
+		const usesTracking = !!observer && !observer.options.notifyOnChangeProps;
+		if (Object.is(this.result, result) && this.usesTracking === usesTracking) return;
+		this.result = result;
+		this.usesTracking = usesTracking;
+		return usesTracking ? observer.trackResult(result) : result;
+	}
+};
+//#endregion
+//#region src/createInfiniteQueryController.ts
+function createPendingInfiniteQueryResult() {
+	return {
+		data: void 0,
+		dataUpdatedAt: 0,
+		error: null,
+		errorUpdatedAt: 0,
+		failureCount: 0,
+		failureReason: null,
+		errorUpdateCount: 0,
+		isError: false,
+		isFetched: false,
+		isFetchedAfterMount: false,
+		isFetching: false,
+		isInitialLoading: false,
+		isLoading: false,
+		isLoadingError: false,
+		isPaused: false,
+		isPending: true,
+		isPlaceholderData: false,
+		isRefetchError: false,
+		isRefetching: false,
+		isStale: true,
+		isEnabled: true,
+		isSuccess: false,
+		fetchStatus: "idle",
+		status: "pending",
+		refetch: (() => Promise.reject(createMissingQueryClientError())),
+		fetchNextPage: (() => Promise.reject(createMissingQueryClientError())),
+		fetchPreviousPage: (() => Promise.reject(createMissingQueryClientError())),
+		hasNextPage: false,
+		hasPreviousPage: false,
+		isFetchNextPageError: false,
+		isFetchingNextPage: false,
+		isFetchPreviousPageError: false,
+		isFetchingPreviousPage: false
+	};
+}
+var InfiniteQueryController = class extends BaseController {
+	constructor(host, options, queryClient) {
+		super(host, createPendingInfiniteQueryResult(), queryClient);
+		this.resultTracker = new QueryObserverResultTracker();
+		this.refetch = (...args) => {
+			if (!this.applyOptions() || !this.observer) return Promise.reject(createMissingQueryClientError());
+			return this.observer.refetch(...args);
+		};
+		this.fetchNextPage = (...args) => {
+			if (!this.applyOptions() || !this.observer) return Promise.reject(createMissingQueryClientError());
+			return this.observer.fetchNextPage(...args);
+		};
+		this.fetchPreviousPage = (...args) => {
+			if (!this.applyOptions() || !this.observer) return Promise.reject(createMissingQueryClientError());
+			return this.observer.fetchPreviousPage(...args);
+		};
+		this.options = options;
+		if (!queryClient) return;
+		if (typeof options === "function") return;
+		const defaulted = this.defaultOptions(queryClient);
+		const observer = new InfiniteQueryObserver(queryClient, defaulted);
+		this.queryClient = queryClient;
+		this.observer = observer;
+		this.assignObserverResult(observer.getOptimisticResult(defaulted));
+	}
+	onConnected() {
+		if (!this.syncClient()) return;
+		this.refreshOptions();
+		this.subscribe();
+		this.observer?.updateResult();
+		if (this.observer) this.setObserverResult(this.observer.getCurrentResult());
+	}
+	onDisconnected() {
+		this.unsubscribeObserver();
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (typeof this.options !== "function") return;
+		this.refreshOptions();
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient() || !this.connectedState) return;
+		this.refreshOptions();
+		this.subscribe();
+		this.observer?.updateResult();
+		if (this.observer) this.setObserverResult(this.observer.getCurrentResult());
+	}
+	readCurrent() {
+		if (this.observer) this.assignObserverResult(this.observer.getCurrentResult());
+		return this.current;
+	}
+	subscribe() {
+		if (!this.observer) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.observer.subscribe((next) => {
+			this.setObserverResult(next);
+		});
+	}
+	unsubscribeObserver() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribeObserver();
+			this.queryClient = void 0;
+			this.observer = void 0;
+			this.resultTracker.reset();
+			this.setResult(createPendingInfiniteQueryResult());
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribeObserver();
+		this.queryClient = nextClient;
+		const options = this.defaultOptions(this.queryClient);
+		this.observer = new InfiniteQueryObserver(this.queryClient, options);
+		this.setObserverResult(this.observer.getOptimisticResult(options));
+		return true;
+	}
+	applyOptions() {
+		if (!this.syncClient() || !this.observer || !this.queryClient) return false;
+		const options = this.defaultOptions(this.queryClient);
+		this.observer.setOptions(options);
+		return true;
+	}
+	refreshOptions() {
+		if (!this.applyOptions() || !this.observer) return false;
+		this.setObserverResult(this.observer.getCurrentResult());
+		return true;
+	}
+	assignObserverResult(result) {
+		const trackedResult = this.resultTracker.update(this.observer, result);
+		if (trackedResult) this.result = trackedResult;
+	}
+	setObserverResult(result) {
+		const trackedResult = this.resultTracker.update(this.observer, result);
+		if (trackedResult) this.setResult(trackedResult);
+	}
+	defaultOptions(client = this.queryClient) {
+		if (!client) throw createMissingQueryClientError();
+		const defaulted = client.defaultQueryOptions(readAccessor(this.options));
+		defaulted._optimisticResults = "optimistic";
+		return defaulted;
+	}
+};
+/**
+* Creates a Lit reactive controller that subscribes the host to an infinite
+* query.
+*
+* The returned accessor is callable and also exposes `current`, `refetch`,
+* `fetchNextPage`, `fetchPreviousPage`, and `destroy`. When `options` is a
+* function, it is re-read during host updates so query keys and options can
+* follow reactive host state.
+*
+* If `queryClient` is omitted, the controller resolves the client from the
+* nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the infinite query
+* subscription.
+* @param options - Infinite query observer options, or a getter that returns
+* options.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the latest infinite query result with page helper
+* methods.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { createInfiniteQueryController } from '@tanstack/lit-query'
+*
+* class ProjectsView extends LitElement {
+*   private readonly projects = createInfiniteQueryController(this, {
+*     queryKey: ['projects'],
+*     queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*     initialPageParam: 0,
+*     getNextPageParam: (lastPage) => lastPage.nextCursor,
+*   })
+*
+*   render() {
+*     const query = this.projects()
+*
+*     return html`
+*       <button ?disabled=${!query.hasNextPage} @click=${() => this.projects.fetchNextPage()}>
+*         Load more
+*       </button>
+*     `
+*   }
+* }
+* ```
+*/
+function createInfiniteQueryController(host, options, queryClient) {
+	const controller = new InfiniteQueryController(host, options, queryClient);
+	return Object.assign(createValueAccessor(() => controller.readCurrent()), {
+		refetch: controller.refetch,
+		fetchNextPage: controller.fetchNextPage,
+		fetchPreviousPage: controller.fetchPreviousPage,
+		destroy: () => controller.destroy()
+	});
+}
+//#endregion
+//#region src/createMutationController.ts
+function createIdleMutationResult() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isError: false,
+		isIdle: true,
+		isPending: false,
+		isPaused: false,
+		isSuccess: false,
+		status: "idle",
+		submittedAt: 0,
+		variables: void 0,
+		mutate: (() => Promise.reject(createMissingQueryClientError())),
+		reset: (() => void 0)
+	};
+}
+var MutationController = class extends BaseController {
+	constructor(host, options, queryClient) {
+		super(host, createIdleMutationResult(), queryClient);
+		this.mutate = (...args) => {
+			if (!this.syncClient() || !this.observer) throw createMissingQueryClientError();
+			this.observer.mutate(args[0], args[1]).catch(() => {});
+		};
+		this.mutateAsync = (...args) => {
+			if (!this.syncClient() || !this.observer) return Promise.reject(createMissingQueryClientError());
+			return this.observer.mutate(args[0], args[1]);
+		};
+		this.reset = () => {
+			if (!this.syncClient() || !this.observer) return;
+			this.observer.reset();
+			this.setResult(this.observer.getCurrentResult());
+		};
+		this.options = options;
+		if (!queryClient) return;
+		if (typeof options === "function") return;
+		const observer = new MutationObserver(queryClient, this.defaultOptions(queryClient));
+		this.queryClient = queryClient;
+		this.observer = observer;
+		this.result = observer.getCurrentResult();
+	}
+	onConnected() {
+		if (!this.syncClient()) return;
+		this.refreshOptions();
+		this.subscribe();
+		if (this.observer) this.setResult(this.observer.getCurrentResult());
+	}
+	onDisconnected() {
+		this.unsubscribeObserver();
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (typeof this.options !== "function") return;
+		this.refreshOptions();
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient() || !this.connectedState) return;
+		this.refreshOptions();
+		this.subscribe();
+		if (this.observer) this.setResult(this.observer.getCurrentResult());
+	}
+	subscribe() {
+		if (!this.observer) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.observer.subscribe((next) => {
+			this.setResult(next);
+		});
+	}
+	unsubscribeObserver() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribeObserver();
+			this.queryClient = void 0;
+			this.observer = void 0;
+			this.setResult(createIdleMutationResult());
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribeObserver();
+		this.queryClient = nextClient;
+		this.observer = new MutationObserver(this.queryClient, this.defaultOptions(this.queryClient));
+		this.setResult(this.observer.getCurrentResult());
+		return true;
+	}
+	refreshOptions() {
+		if (!this.syncClient() || !this.observer || !this.queryClient) return false;
+		this.observer.setOptions(this.defaultOptions());
+		this.setResult(this.observer.getCurrentResult());
+		return true;
+	}
+	defaultOptions(client = this.queryClient) {
+		if (!client) throw createMissingQueryClientError();
+		return client.defaultMutationOptions(readAccessor(this.options));
+	}
+};
+/**
+* Creates a Lit reactive controller that subscribes the host to a mutation.
+*
+* The returned accessor is callable and also exposes `current`, `mutate`,
+* `mutateAsync`, `reset`, and `destroy`. When `options` is a function, it is
+* re-read during host updates so mutation options can follow reactive host
+* state.
+*
+* If `queryClient` is omitted, the controller resolves the client from the
+* nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the mutation
+* subscription.
+* @param options - Mutation observer options, or a getter that returns options.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the latest mutation result with mutation helper
+* methods.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { createMutationController } from '@tanstack/lit-query'
+*
+* class AddTodoForm extends LitElement {
+*   private readonly addTodo = createMutationController(this, {
+*     mutationFn: (title: string) =>
+*       fetch('/api/todos', { method: 'POST', body: JSON.stringify({ title }) }),
+*   })
+*
+*   render() {
+*     const mutation = this.addTodo()
+*
+*     return html`
+*       <button ?disabled=${mutation.isPending} @click=${() => this.addTodo.mutate('Ship docs')}>
+*         Add todo
+*       </button>
+*     `
+*   }
+* }
+* ```
+*/
+function createMutationController(host, options, queryClient) {
+	const controller = new MutationController(host, options, queryClient);
+	return Object.assign(createValueAccessor(() => controller.current), {
+		mutate: controller.mutate,
+		mutateAsync: controller.mutateAsync,
+		reset: controller.reset,
+		destroy: () => controller.destroy()
+	});
+}
+//#endregion
+//#region src/createQueriesController.ts
+function createPendingQueryObserverResult() {
+	return {
+		data: void 0,
+		dataUpdatedAt: 0,
+		error: null,
+		errorUpdatedAt: 0,
+		failureCount: 0,
+		failureReason: null,
+		errorUpdateCount: 0,
+		isError: false,
+		isFetched: false,
+		isFetchedAfterMount: false,
+		isFetching: false,
+		isInitialLoading: false,
+		isLoading: false,
+		isLoadingError: false,
+		isPaused: false,
+		isPending: true,
+		isPlaceholderData: false,
+		isRefetchError: false,
+		isRefetching: false,
+		isStale: true,
+		isEnabled: true,
+		isSuccess: false,
+		fetchStatus: "idle",
+		status: "pending",
+		refetch: (() => Promise.reject(createMissingQueryClientError()))
+	};
+}
+function createPlaceholderQueryObserverResult(query) {
+	const initialData = typeof query.initialData === "function" ? query.initialData() : query.initialData;
+	if (initialData === void 0) return createPendingQueryObserverResult();
+	const data = query.select ? query.select(initialData) : initialData;
+	const initialDataUpdatedAt = typeof query.initialDataUpdatedAt === "function" ? query.initialDataUpdatedAt() : query.initialDataUpdatedAt;
+	return {
+		...createPendingQueryObserverResult(),
+		data,
+		dataUpdatedAt: initialDataUpdatedAt ?? Date.now(),
+		isPending: false,
+		isInitialLoading: false,
+		isLoading: false,
+		isSuccess: true,
+		status: "success"
+	};
+}
+function resolveQueriesOptions(optionsAccessor, client) {
+	const resolvedOptions = readAccessor(optionsAccessor);
+	const resolvedQueries = readAccessor(resolvedOptions.queries);
+	const combine = resolvedOptions.combine;
+	return {
+		queries: resolvedQueries.map((query) => {
+			const defaulted = client.defaultQueryOptions(query);
+			defaulted._optimisticResults = "optimistic";
+			return defaulted;
+		}),
+		combine
+	};
+}
+var QueriesController = class QueriesController extends BaseController {
+	constructor(host, options, queryClient) {
+		super(host, [], queryClient);
+		this.queries = [];
+		this.rawResult = [];
+		this.placeholderInitialized = false;
+		this.placeholderRetryableFailure = true;
+		this.options = options;
+		queueMicrotask(() => {
+			this.placeholderRetryableFailure = false;
+		});
+		if (!queryClient) return;
+		if (this.shouldRefreshOnHostUpdate()) return;
+		this.tryInitializeExplicitClient(queryClient);
+	}
+	onConnected() {
+		if (!this.syncClient()) return;
+		this.refreshOptions();
+		this.subscribe();
+	}
+	onDisconnected() {
+		this.unsubscribeObserver();
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (!this.shouldRefreshOnHostUpdate()) return;
+		if (!this.refreshOptions()) this.setPlaceholderResult();
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient() || !this.connectedState) return;
+		this.refreshOptions();
+		this.subscribe();
+	}
+	subscribe() {
+		if (!this.observer) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.observer.subscribe((next) => {
+			this.setObserverResult(next);
+		});
+	}
+	tryInitializeExplicitClient(queryClient) {
+		try {
+			const { queries, combine } = resolveQueriesOptions(this.options, queryClient);
+			this.queries = queries;
+			this.combine = combine;
+			const observer = new QueriesObserver(queryClient, this.queries, { combine: this.combine });
+			this.queryClient = queryClient;
+			this.observer = observer;
+			this.assignObserverResult(observer.getCurrentResult(), true);
+			this.explicitInitializationError = void 0;
+			this.placeholderInitialized = true;
+			return true;
+		} catch (error) {
+			this.explicitInitializationError = error;
+			this.queryClient = void 0;
+			this.observer = void 0;
+			return false;
+		}
+	}
+	retryExplicitInitializationIfNeeded() {
+		if (!this.explicitInitializationError || this.shouldRefreshOnHostUpdate()) return false;
+		const explicitClient = this.tryGetQueryClient();
+		if (!explicitClient) return false;
+		return this.tryInitializeExplicitClient(explicitClient);
+	}
+	unsubscribeObserver() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribeObserver();
+			this.queryClient = void 0;
+			this.observer = void 0;
+			this.queries = [];
+			this.combine = void 0;
+			this.combinedResult = void 0;
+			this.rawResult = [];
+			this.setPlaceholderResult();
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribeObserver();
+		this.queryClient = nextClient;
+		const { queries, combine } = this.readResolvedOptions();
+		this.queries = queries;
+		this.combine = combine;
+		this.observer = new QueriesObserver(this.queryClient, this.queries, { combine: this.combine });
+		this.setObserverResult(this.observer.getCurrentResult(), true);
+		this.placeholderInitialized = true;
+		return true;
+	}
+	refreshOptions() {
+		if (!this.syncClient() || !this.observer) return false;
+		const { queries, combine } = this.readResolvedOptions();
+		this.queries = queries;
+		this.combine = combine;
+		this.observer.setQueries(this.queries, { combine: this.combine });
+		this.setObserverResult(this.observer.getCurrentResult(), true);
+		return true;
+	}
+	readResolvedOptions(client = this.queryClient) {
+		if (!client) throw createMissingQueryClientError();
+		return resolveQueriesOptions(this.options, client);
+	}
+	shouldRefreshOnHostUpdate() {
+		if (typeof this.options === "function") return true;
+		return typeof this.options.queries === "function";
+	}
+	createResult(rawResult) {
+		const trackedResult = this.trackResult(rawResult);
+		const combine = this.combine;
+		if (!combine) return trackedResult;
+		this.combinedResult = replaceEqualDeep(this.combinedResult, combine(trackedResult));
+		return this.combinedResult;
+	}
+	assignObserverResult(rawResult, force = false) {
+		if (!force && this.hasObserverResult(rawResult)) return;
+		this.rawResult = rawResult;
+		this.result = this.createResult(rawResult);
+	}
+	setObserverResult(rawResult, force = false) {
+		if (!force && this.hasObserverResult(rawResult)) return;
+		this.rawResult = rawResult;
+		this.setResult(this.createResult(rawResult));
+	}
+	hasObserverResult(rawResult) {
+		return this.rawResult.length === rawResult.length && rawResult.every((result, index) => Object.is(this.rawResult[index], result));
+	}
+	getCurrentObserverResults() {
+		if (!this.observer) return [];
+		return this.observer.getObservers().map((observer) => observer.getCurrentResult());
+	}
+	trackResult(rawResult) {
+		if (!this.observer) return rawResult;
+		const observers = this.observer.getObservers();
+		return rawResult.map((result, index) => {
+			const observer = observers[index];
+			if (!observer || observer.options.notifyOnChangeProps) return result;
+			return observer.trackResult(result, (accessedProp) => {
+				observers.forEach((observer) => {
+					observer.trackProp(accessedProp);
+				});
+			});
+		});
+	}
+	static createPlaceholderResult(optionsAccessor) {
+		const resolvedOptions = readAccessor(optionsAccessor);
+		const placeholders = readAccessor(resolvedOptions.queries).map((query) => createPlaceholderQueryObserverResult(query));
+		return resolvedOptions.combine ? resolvedOptions.combine(placeholders) : placeholders;
+	}
+	readCurrent() {
+		if (this.retryExplicitInitializationIfNeeded()) return this.current;
+		if (this.explicitInitializationError && !this.placeholderRetryableFailure) throw this.explicitInitializationError;
+		if (!this.queryClient && !this.observer && !this.placeholderInitialized) try {
+			this.setPlaceholderResult();
+		} catch (error) {
+			if (!this.placeholderRetryableFailure) throw error;
+		}
+		if (this.observer) this.assignObserverResult(this.getCurrentObserverResults());
+		return this.current;
+	}
+	setPlaceholderResult() {
+		this.rawResult = [];
+		this.result = QueriesController.createPlaceholderResult(this.options);
+		this.placeholderInitialized = true;
+	}
+};
+/**
+* Creates a Lit reactive controller that subscribes the host to multiple
+* queries.
+*
+* The returned accessor is callable and also exposes `current` and `destroy`.
+* When `options` or `options.queries` is a function, it is re-read during host
+* updates so the query list can follow reactive host state.
+*
+* If `queryClient` is omitted, the controller resolves the client from the
+* nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the queries
+* subscription.
+* @param options - Queries controller options, or a getter that returns options.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the latest query results, or the value returned by
+* `combine`.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { createQueriesController } from '@tanstack/lit-query'
+*
+* class DashboardView extends LitElement {
+*   private readonly dashboard = createQueriesController(this, {
+*     queries: [
+*       { queryKey: ['stats'], queryFn: fetchStats },
+*       { queryKey: ['projects'], queryFn: fetchProjects },
+*     ],
+*     combine: ([stats, projects]) => ({
+*       stats: stats.data,
+*       projects: projects.data ?? [],
+*       isPending: stats.isPending || projects.isPending,
+*     }),
+*   })
+*
+*   render() {
+*     const dashboard = this.dashboard()
+*     return html`<p>Projects: ${dashboard.projects.length}</p>`
+*   }
+* }
+* ```
+*/
+function createQueriesController(host, options, queryClient) {
+	const controller = new QueriesController(host, options, queryClient);
+	return Object.assign(createValueAccessor(() => controller.readCurrent()), { destroy: () => controller.destroy() });
+}
+//#endregion
+//#region src/createQueryController.ts
+function createPendingQueryResult() {
+	return {
+		data: void 0,
+		dataUpdatedAt: 0,
+		error: null,
+		errorUpdatedAt: 0,
+		failureCount: 0,
+		failureReason: null,
+		errorUpdateCount: 0,
+		isError: false,
+		isFetched: false,
+		isFetchedAfterMount: false,
+		isFetching: false,
+		isInitialLoading: false,
+		isLoading: false,
+		isLoadingError: false,
+		isPaused: false,
+		isPending: true,
+		isPlaceholderData: false,
+		isRefetchError: false,
+		isRefetching: false,
+		isStale: true,
+		isEnabled: true,
+		isSuccess: false,
+		fetchStatus: "idle",
+		status: "pending",
+		refetch: (() => Promise.reject(createMissingQueryClientError()))
+	};
+}
+var QueryController = class extends BaseController {
+	constructor(host, options, queryClient) {
+		const initialClient = queryClient;
+		super(host, createPendingQueryResult(), queryClient);
+		this.resultTracker = new QueryObserverResultTracker();
+		this.refetch = (...args) => {
+			if (!this.applyOptions() || !this.observer) return Promise.reject(createMissingQueryClientError());
+			return this.observer.refetch(...args);
+		};
+		this.suspense = async () => {
+			if (!this.syncClient() || !this.observer || !this.queryClient) throw createMissingQueryClientError();
+			const options = this.defaultOptions(this.queryClient);
+			this.observer.setOptions(options);
+			const optimistic = this.observer.getOptimisticResult(options);
+			if (options.enabled !== false && optimistic.isStale) return this.observer.fetchOptimistic(options);
+			return optimistic;
+		};
+		this.options = options;
+		if (!initialClient) return;
+		if (typeof options === "function") return;
+		const defaulted = this.defaultOptions(initialClient);
+		const observer = new QueryObserver(initialClient, defaulted);
+		this.queryClient = initialClient;
+		this.observer = observer;
+		this.assignObserverResult(observer.getOptimisticResult(defaulted));
+	}
+	onConnected() {
+		if (!this.syncClient()) return;
+		this.refreshOptions();
+		this.subscribe();
+		this.observer?.updateResult();
+		if (this.observer) this.setObserverResult(this.observer.getCurrentResult());
+	}
+	onDisconnected() {
+		this.unsubscribeObserver();
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (typeof this.options !== "function") return;
+		this.refreshOptions();
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient()) return;
+		if (!this.connectedState) return;
+		this.refreshOptions();
+		this.subscribe();
+		this.observer?.updateResult();
+		if (this.observer) this.setObserverResult(this.observer.getCurrentResult());
+	}
+	readCurrent() {
+		if (this.observer) this.assignObserverResult(this.observer.getCurrentResult());
+		return this.current;
+	}
+	subscribe() {
+		if (!this.observer) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.observer.subscribe((next) => {
+			this.setObserverResult(next);
+		});
+	}
+	unsubscribeObserver() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribeObserver();
+			this.queryClient = void 0;
+			this.observer = void 0;
+			this.resultTracker.reset();
+			this.setResult(createPendingQueryResult());
+			return false;
+		}
+		if (nextClient === this.queryClient && this.observer) return true;
+		this.unsubscribeObserver();
+		this.queryClient = nextClient;
+		const options = this.defaultOptions();
+		this.observer = new QueryObserver(this.queryClient, options);
+		this.setObserverResult(this.observer.getOptimisticResult(options));
+		return true;
+	}
+	applyOptions() {
+		if (!this.syncClient() || !this.observer) return false;
+		const options = this.defaultOptions(this.queryClient);
+		this.observer.setOptions(options);
+		return true;
+	}
+	refreshOptions() {
+		if (!this.applyOptions() || !this.observer) return false;
+		this.setObserverResult(this.observer.getCurrentResult());
+		return true;
+	}
+	assignObserverResult(result) {
+		const trackedResult = this.resultTracker.update(this.observer, result);
+		if (trackedResult) this.result = trackedResult;
+	}
+	setObserverResult(result) {
+		const trackedResult = this.resultTracker.update(this.observer, result);
+		if (trackedResult) this.setResult(trackedResult);
+	}
+	defaultOptions(client = this.queryClient) {
+		const resolvedClient = client ?? this.tryGetQueryClient();
+		if (!resolvedClient) throw createMissingQueryClientError();
+		this.queryClient = resolvedClient;
+		const defaulted = resolvedClient.defaultQueryOptions(readAccessor(this.options));
+		defaulted._optimisticResults = "optimistic";
+		return defaulted;
+	}
+};
+/**
+* Creates a Lit reactive controller that subscribes the host to a single query.
+*
+* The returned accessor is callable and also exposes `current`, `refetch`,
+* `suspense`, and `destroy`. When `options` is a function, it is re-read during
+* host updates so query keys and options can follow reactive host state.
+*
+* If `queryClient` is omitted, the controller resolves the client from the
+* nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the query
+* subscription.
+* @param options - Query observer options, or a getter that returns options.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the latest query result with query helper methods.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { createQueryController } from '@tanstack/lit-query'
+*
+* class TodosView extends LitElement {
+*   private readonly todos = createQueryController(this, {
+*     queryKey: ['todos'],
+*     queryFn: async () => fetch('/api/todos').then((r) => r.json()),
+*   })
+*
+*   render() {
+*     const query = this.todos()
+*
+*     if (query.isPending) return html`Loading...`
+*     if (query.isError) return html`Error`
+*
+*     return html`<ul>${query.data.map((todo) => html`<li>${todo.title}</li>`)}</ul>`
+*   }
+* }
+* ```
+*/
+function createQueryController(host, options, queryClient) {
+	const controller = new QueryController(host, options, queryClient);
+	return Object.assign(createValueAccessor(() => controller.readCurrent()), {
+		refetch: controller.refetch,
+		suspense: controller.suspense,
+		destroy: () => controller.destroy()
+	});
+}
+//#endregion
+//#region src/useIsFetching.ts
+var IsFetchingController = class extends BaseController {
+	constructor(host, filters = {}, queryClient) {
+		super(host, 0, queryClient);
+		this.filters = filters;
+		if (!queryClient) return;
+		this.queryClient = queryClient;
+		this.result = this.computeValue();
+	}
+	onConnected() {
+		if (!this.syncClient()) {
+			this.setResult(0);
+			return;
+		}
+		this.subscribe();
+		this.setResult(this.computeValue());
+	}
+	onDisconnected() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (typeof this.filters !== "function") return;
+		this.setResult(this.syncClient() ? this.computeValue() : 0);
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient()) {
+			this.setResult(0);
+			return;
+		}
+		if (this.connectedState) {
+			this.subscribe();
+			this.setResult(this.computeValue());
+		}
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribe?.();
+			this.unsubscribe = void 0;
+			this.queryClient = void 0;
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.queryClient = nextClient;
+		return true;
+	}
+	subscribe() {
+		if (!this.queryClient) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.queryClient.getQueryCache().subscribe(() => {
+			this.setResult(this.computeValue());
+		});
+	}
+	computeValue() {
+		if (!this.queryClient) return 0;
+		return this.queryClient.isFetching(readAccessor(this.filters));
+	}
+};
+/**
+* Creates a Lit reactive controller that tracks how many matching queries are
+* currently fetching.
+*
+* When `filters` is a function, it is re-read during host updates so the count
+* can follow reactive host state. If `queryClient` is omitted, the controller
+* resolves the client from the nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the cache
+* subscription.
+* @param filters - Query filters, or a getter that returns query filters.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the current number of matching fetching queries.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { useIsFetching } from '@tanstack/lit-query'
+*
+* class TodosStatus extends LitElement {
+*   private readonly todosFetching = useIsFetching(this, {
+*     queryKey: ['todos'],
+*   })
+*
+*   render() {
+*     return html`<span>${this.todosFetching()} active todo fetches</span>`
+*   }
+* }
+* ```
+*/
+function useIsFetching(host, filters = {}, queryClient) {
+	const controller = new IsFetchingController(host, filters, queryClient);
+	return Object.assign(createValueAccessor(() => controller.current), { destroy: () => controller.destroy() });
+}
+//#endregion
+//#region src/useIsMutating.ts
+var IsMutatingController = class extends BaseController {
+	constructor(host, filters = {}, queryClient) {
+		super(host, 0, queryClient);
+		this.filters = filters;
+		if (!queryClient) return;
+		this.queryClient = queryClient;
+		this.result = this.computeValue();
+	}
+	onConnected() {
+		if (!this.syncClient()) {
+			this.setResult(0);
+			return;
+		}
+		this.subscribe();
+		this.setResult(this.computeValue());
+	}
+	onDisconnected() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (typeof this.filters !== "function") return;
+		this.setResult(this.syncClient() ? this.computeValue() : 0);
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient()) {
+			this.setResult(0);
+			return;
+		}
+		if (this.connectedState) {
+			this.subscribe();
+			this.setResult(this.computeValue());
+		}
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribe?.();
+			this.unsubscribe = void 0;
+			this.queryClient = void 0;
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.queryClient = nextClient;
+		return true;
+	}
+	subscribe() {
+		if (!this.queryClient) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.queryClient.getMutationCache().subscribe(() => {
+			this.setResult(this.computeValue());
+		});
+	}
+	computeValue() {
+		if (!this.queryClient) return 0;
+		return this.queryClient.isMutating(readAccessor(this.filters));
+	}
+};
+/**
+* Creates a Lit reactive controller that tracks how many matching mutations are
+* currently pending.
+*
+* When `filters` is a function, it is re-read during host updates so the count
+* can follow reactive host state. If `queryClient` is omitted, the controller
+* resolves the client from the nearest connected `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the cache
+* subscription.
+* @param filters - Mutation filters, or a getter that returns mutation filters.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the current number of matching pending mutations.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { useIsMutating } from '@tanstack/lit-query'
+*
+* class MutationStatus extends LitElement {
+*   private readonly savesPending = useIsMutating(this, {
+*     mutationKey: ['save-project'],
+*   })
+*
+*   render() {
+*     return html`<span>${this.savesPending()} saves pending</span>`
+*   }
+* }
+* ```
+*/
+function useIsMutating(host, filters = {}, queryClient) {
+	const controller = new IsMutatingController(host, filters, queryClient);
+	return Object.assign(createValueAccessor(() => controller.current), { destroy: () => controller.destroy() });
+}
+//#endregion
+//#region src/useMutationState.ts
+var MutationStateController = class extends BaseController {
+	constructor(host, options, queryClient) {
+		super(host, [], queryClient);
+		this.options = options;
+		if (!queryClient) return;
+		this.queryClient = queryClient;
+		this.result = this.computeState();
+	}
+	onConnected() {
+		if (!this.syncClient()) {
+			this.setMutationState([]);
+			return;
+		}
+		this.subscribe();
+		this.setMutationState(this.computeState());
+	}
+	onDisconnected() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.syncClient();
+	}
+	onHostUpdate() {
+		if (!this.shouldRefreshOnHostUpdate()) return;
+		this.setMutationState(this.syncClient() ? this.computeState() : []);
+	}
+	onQueryClientChanged() {
+		if (!this.syncClient()) {
+			this.setMutationState([]);
+			return;
+		}
+		if (this.connectedState) {
+			this.subscribe();
+			this.setMutationState(this.computeState());
+		}
+	}
+	syncClient() {
+		const nextClient = this.tryGetQueryClient();
+		if (!nextClient) {
+			this.unsubscribe?.();
+			this.unsubscribe = void 0;
+			this.queryClient = void 0;
+			return false;
+		}
+		if (nextClient === this.queryClient) return true;
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.queryClient = nextClient;
+		return true;
+	}
+	subscribe() {
+		if (!this.queryClient) return;
+		if (this.unsubscribe) return;
+		this.unsubscribe = this.queryClient.getMutationCache().subscribe(() => {
+			this.setMutationState(this.computeState());
+		});
+	}
+	setMutationState(next) {
+		this.setResult(replaceEqualDeep(this.result, next));
+	}
+	shouldRefreshOnHostUpdate() {
+		return typeof this.options.filters === "function" || typeof this.options.select === "function";
+	}
+	computeState() {
+		if (!this.queryClient) return [];
+		const filters = this.options.filters ? readAccessor(this.options.filters) : void 0;
+		const select = this.options.select;
+		return this.queryClient.getMutationCache().findAll(filters).map((mutation) => {
+			if (select) return select(mutation);
+			return mutation.state;
+		});
+	}
+};
+/**
+* Creates a Lit reactive controller that selects state from matching mutations
+* in the mutation cache.
+*
+* When `options.filters` is a function, it is re-read during host updates so
+* the selection can follow reactive host state. If `queryClient` is omitted,
+* the controller resolves the client from the nearest connected
+* `QueryClientProvider`.
+*
+* @param host - The Lit reactive controller host that owns the mutation cache
+* subscription.
+* @param options - Mutation state filters and optional selector.
+* @param queryClient - Optional explicit query client. Provide this for
+* controllers that should not resolve a client from Lit context.
+* @returns An accessor for the selected mutation state array.
+*
+* @example
+* ```ts
+* import { LitElement, html } from 'lit'
+* import { useMutationState } from '@tanstack/lit-query'
+*
+* class PendingUploads extends LitElement {
+*   private readonly uploads = useMutationState(this, {
+*     filters: { mutationKey: ['upload'], status: 'pending' },
+*     select: (mutation) => mutation.state.variables as File,
+*   })
+*
+*   render() {
+*     return html`<span>${this.uploads().length} uploads pending</span>`
+*   }
+* }
+* ```
+*/
+function useMutationState(host, options = {}, queryClient) {
+	const controller = new MutationStateController(host, options, queryClient);
+	return Object.assign(createValueAccessor(() => controller.current), { destroy: () => controller.destroy() });
+}
+//#endregion
+//#region src/queryOptions.ts
+function queryOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/mutationOptions.ts
+/**
+* Preserves and types mutation options for reuse across Lit Query APIs.
+*
+* @param options - Mutation options to preserve.
+* @returns The same options object.
+*
+* @example
+* ```ts
+* import { mutationOptions } from '@tanstack/lit-query'
+*
+* const addTodoOptions = mutationOptions({
+*   mutationKey: ['add-todo'],
+*   mutationFn: (title: string) => addTodo(title),
+* })
+* ```
+*/
+function mutationOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/index.ts
+/* istanbul ignore file */
+//#endregion
+export { QueryClientProvider, createInfiniteQueryController, createMutationController, createQueriesController, createQueryController, getDefaultQueryClient, infiniteQueryOptions, mutationOptions, queryClientContext, queryOptions, registerDefaultQueryClient, resolveQueryClient, unregisterDefaultQueryClient, useIsFetching, useIsMutating, useMutationState, useQueryClient };
+
+//# sourceMappingURL=index.js.map