@rozenite/tanstack-query-plugin 1.5.1 → 1.7.0-rc.0

package/dist/react-native/chunks/useTanStackQueryDevTools.require.js

@@ -0,0 +1,862 @@
+import { useRozeniteDevToolsClient as R } from "@rozenite/plugin-bridge";
+import { useEffect as S, useRef as k, useMemo as M } from "react";
+import { onlineManager as g } from "@tanstack/react-query";
+import D from "fast-deep-equal";
+import { useRozenitePluginAgentTool as i } from "@rozenite/agent-bridge";
+const w = (e) => {
+  S(() => {
+    if (!e)
+      return;
+    const r = g.subscribe((a) => {
+      e.send("online-status-changed", { online: a });
+    }), t = e.onMessage(
+      "online-status-changed",
+      ({ online: a }) => {
+        g.setOnline(a);
+      }
+    );
+    return () => {
+      r(), t.remove();
+    };
+  }, [e]);
+}, m = (e, r) => {
+  if (!r)
+    throw new Error("queryHash is required for this TanStack Query action.");
+  const t = e.getQueryCache().get(r);
+  if (!t)
+    throw new Error(`No active query found for hash: ${r}`);
+  return t;
+}, p = async (e, r) => {
+  switch (r.type) {
+    case "CLEAR_QUERY_CACHE": {
+      const t = e.getQueryCache().getAll().length;
+      return e.getQueryCache().clear(), {
+        applied: !0,
+        action: r.type,
+        cleared: !0,
+        queryCountBefore: t,
+        queryCountAfter: e.getQueryCache().getAll().length
+      };
+    }
+    case "CLEAR_MUTATION_CACHE": {
+      const t = e.getMutationCache().getAll().length;
+      return e.getMutationCache().clear(), {
+        applied: !0,
+        action: r.type,
+        cleared: !0,
+        mutationCountBefore: t,
+        mutationCountAfter: e.getMutationCache().getAll().length
+      };
+    }
+    case "TRIGGER_ERROR": {
+      const t = m(e, r.queryHash), a = t.options, n = new Error("Unknown error from devtools");
+      return t.setState({
+        status: "error",
+        error: n,
+        fetchMeta: {
+          ...t.state.fetchMeta,
+          // @ts-expect-error This does exist
+          __previousQueryOptions: a
+        }
+      }), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "RESTORE_ERROR": {
+      const t = m(e, r.queryHash);
+      return await e.resetQueries(t), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "TRIGGER_LOADING": {
+      const t = m(e, r.queryHash), a = t.options;
+      return t.fetch({
+        ...a,
+        queryFn: () => new Promise(() => {
+        }),
+        gcTime: -1
+      }), t.setState({
+        data: void 0,
+        status: "pending",
+        fetchMeta: {
+          ...t.state.fetchMeta,
+          // @ts-expect-error This does exist
+          __previousQueryOptions: a
+        }
+      }), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "RESTORE_LOADING": {
+      const t = m(e, r.queryHash), a = t.state, n = t.state.fetchMeta ? t.state.fetchMeta.__previousQueryOptions : null;
+      return t.cancel({ silent: !0 }), t.setState({
+        ...a,
+        fetchStatus: "idle",
+        fetchMeta: null
+      }), n && t.fetch(n), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "RESET": {
+      const t = m(e, r.queryHash);
+      return await e.resetQueries(t), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "REMOVE": {
+      const t = m(e, r.queryHash);
+      return e.removeQueries(t), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "REFETCH": {
+      const t = m(e, r.queryHash);
+      return await t.fetch().catch(() => {
+      }), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+    case "INVALIDATE": {
+      const t = m(e, r.queryHash);
+      return await e.invalidateQueries(t), {
+        applied: !0,
+        action: r.type,
+        queryHash: t.queryHash
+      };
+    }
+  }
+}, C = (e, r) => {
+  S(() => {
+    if (!r)
+      return;
+    const t = r.onMessage(
+      "devtools-action",
+      ({ type: a, queryHash: n }) => {
+        p(e, { type: a, queryHash: n }).catch((d) => {
+          const h = d instanceof Error ? d.message : String(d);
+          console.warn(
+            `[Rozenite, tanstack-query-plugin] Failed to apply devtools action "${a}": ${h}`
+          );
+        });
+      }
+    );
+    return () => {
+      t.remove();
+    };
+  }, [r]);
+}, E = (e) => e.observers.map((r) => ({
+  queryHash: e.queryHash,
+  options: r.options
+})), q = (e) => {
+  const r = E(e);
+  return {
+    state: e.state,
+    queryKey: e.queryKey,
+    queryHash: e.queryHash,
+    observers: r
+  };
+}, O = (e) => ({
+  mutationId: e.mutationId,
+  state: e.state,
+  options: e.options
+}), U = (e) => ({
+  queries: e.getQueryCache().getAll().map(q),
+  mutations: e.getMutationCache().getAll().map(O)
+}), _ = (e, r) => {
+  const t = k(
+    /* @__PURE__ */ new Map()
+  ), a = M(() => (n) => {
+    if (!r || n.type === "observerResultsUpdated")
+      return;
+    if ("query" in n) {
+      const { query: s, type: y } = n;
+      if (y === "added" || y === "removed") {
+        y === "removed" && t.current.delete(s.queryHash);
+        const l = q(s);
+        r.send("sync-query-event", { type: y, data: l });
+        return;
+      }
+      if (y === "updated" && "action" in n) {
+        const l = n.action;
+        switch (l.type) {
+          case "fetch": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                status: s.state.status,
+                fetchStatus: s.state.fetchStatus,
+                fetchMeta: s.state.fetchMeta,
+                dataUpdatedAt: s.state.dataUpdatedAt,
+                errorUpdatedAt: s.state.errorUpdatedAt
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "fetch",
+              data: u
+            });
+            break;
+          }
+          case "success": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                status: s.state.status,
+                data: s.state.data,
+                dataUpdatedAt: s.state.dataUpdatedAt,
+                error: s.state.error,
+                errorUpdatedAt: s.state.errorUpdatedAt,
+                fetchStatus: s.state.fetchStatus
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "success",
+              data: u
+            });
+            break;
+          }
+          case "error": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                status: s.state.status,
+                error: s.state.error,
+                errorUpdatedAt: s.state.errorUpdatedAt,
+                fetchStatus: s.state.fetchStatus
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "error",
+              data: u
+            });
+            break;
+          }
+          case "setState": {
+            const u = {
+              queryHash: s.queryHash,
+              state: l.state
+              // Only the changed state parts
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "setState",
+              data: u
+            });
+            break;
+          }
+          case "invalidate": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                isInvalidated: s.state.isInvalidated
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "invalidate",
+              data: u
+            });
+            break;
+          }
+          case "pause": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                fetchStatus: s.state.fetchStatus
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "pause",
+              data: u
+            });
+            break;
+          }
+          case "continue": {
+            const u = {
+              queryHash: s.queryHash,
+              state: {
+                fetchStatus: s.state.fetchStatus
+              }
+            };
+            r.send("sync-query-event", {
+              type: "updated",
+              action: "continue",
+              data: u
+            });
+            break;
+          }
+          default: {
+            const u = q(s);
+            r.send("sync-query-event", { type: y, data: u });
+          }
+        }
+        return;
+      }
+      if (y === "observerAdded" || y === "observerRemoved" || y === "observerOptionsUpdated") {
+        const l = E(s), u = t.current.get(
+          s.queryHash
+        );
+        if (y === "observerOptionsUpdated" && u && D(u, l))
+          return;
+        t.current.set(
+          s.queryHash,
+          l
+        ), r.send("sync-query-event", {
+          type: y,
+          data: {
+            queryHash: s.queryHash,
+            observers: l
+          }
+        });
+        return;
+      }
+    }
+    const { mutation: d, type: h } = n;
+    if (d) {
+      const s = O(d);
+      r.send("sync-mutation-event", {
+        type: h,
+        data: s
+      });
+    }
+  }, [r]);
+  S(() => {
+    if (!r)
+      return;
+    const n = e.getMutationCache().subscribe(a), d = e.getQueryCache().subscribe(a);
+    return () => {
+      n(), d();
+    };
+  }, [r, e, a]);
+}, G = (e, r) => {
+  S(() => {
+    if (!r)
+      return;
+    const t = r.onMessage("request-initial-data", () => {
+      const a = U(e);
+      r.send("sync-data", { data: a });
+    });
+    return () => {
+      t.remove();
+    };
+  }, [r, e]);
+}, j = "@rozenite/tanstack-query-plugin", N = 20, L = 100, F = (e) => !!e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype, o = (e, r = /* @__PURE__ */ new WeakSet()) => {
+  if (e == null)
+    return null;
+  if (typeof e == "string" || typeof e == "boolean")
+    return e;
+  if (typeof e == "number")
+    return Number.isFinite(e) ? e : String(e);
+  if (typeof e == "bigint")
+    return e.toString();
+  if (typeof e == "function" || typeof e == "symbol")
+    return `[non-serializable:${typeof e}]`;
+  if (e instanceof Date)
+    return e.toISOString();
+  if (e instanceof Error)
+    return {
+      name: e.name,
+      message: e.message,
+      stack: e.stack ?? null,
+      cause: o(
+        e.cause,
+        r
+      )
+    };
+  if (Array.isArray(e))
+    return e.map((t) => o(t, r));
+  if (ArrayBuffer.isView(e))
+    return Array.from(e).map(
+      (t) => typeof t == "number" ? t : Number(t)
+    );
+  if (e instanceof ArrayBuffer)
+    return Array.from(new Uint8Array(e));
+  if (typeof e == "object") {
+    if (r.has(e))
+      return "[circular]";
+    if (r.add(e), !F(e))
+      return `[non-serializable:${e.constructor?.name ?? "Object"}]`;
+    const t = Object.entries(e).map(([a, n]) => [
+      a,
+      o(n, r)
+    ]);
+    return Object.fromEntries(t);
+  }
+  return String(e);
+}, P = (e) => typeof e != "number" || !Number.isFinite(e) || !Number.isInteger(e) || e < 1 ? N : Math.min(e, L), $ = (e, r, t) => `${e}:${r}:${t}`, K = (e, r, t) => {
+  const [a, n, d] = e.split(":", 3);
+  if (a !== r || !n || !d)
+    throw new Error(
+      "Cursor does not match the requested listing. Run the command again."
+    );
+  const h = Number(n), s = Number(d);
+  if (!Number.isInteger(h) || h !== t)
+    throw new Error(
+      "Cursor does not match the requested listing. Run the command again."
+    );
+  if (!Number.isInteger(s) || s < 0)
+    throw new Error("Cursor is invalid. Run the command again.");
+  return s;
+}, A = (e, r, t, a) => {
+  const n = P(a.limit), d = a.cursor ? K(a.cursor, r, t) : 0, h = Math.min(d + n, e.length), s = h < e.length;
+  return {
+    items: e.slice(d, h),
+    page: {
+      limit: n,
+      hasMore: s,
+      ...s ? { nextCursor: $(r, t, h) } : {}
+    }
+  };
+}, f = {
+  queryHash: {
+    type: "string",
+    description: "TanStack Query queryHash identifying the query."
+  }
+}, x = {
+  mutationId: {
+    type: "number",
+    description: "TanStack Query mutationId identifying the mutation."
+  }
+}, I = {
+  limit: {
+    type: "number",
+    description: "Maximum number of items to return. Defaults to 20. Maximum 100."
+  },
+  cursor: {
+    type: "string",
+    description: "Opaque pagination cursor from a previous list call."
+  }
+}, Q = {
+  type: "object",
+  properties: {}
+}, z = {
+  name: "get-cache-summary",
+  description: "Return aggregate TanStack Query cache health and count information.",
+  inputSchema: Q
+}, V = {
+  name: "get-online-status",
+  description: "Return the current TanStack Query onlineManager status.",
+  inputSchema: Q
+}, B = {
+  name: "set-online-status",
+  description: "Set the TanStack Query onlineManager status for testing offline/online behavior.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      online: {
+        type: "boolean",
+        description: "Whether the TanStack Query onlineManager should be online."
+      }
+    },
+    required: ["online"]
+  }
+}, W = {
+  name: "list-queries",
+  description: "List TanStack Query query summaries using cursor pagination.",
+  inputSchema: {
+    type: "object",
+    properties: I
+  }
+}, Y = {
+  name: "get-query-details",
+  description: "Return a JSON-safe TanStack Query query snapshot and observer summary.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash"]
+  }
+}, J = {
+  name: "refetch-query",
+  description: "Refetch a TanStack Query query by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash"]
+  }
+}, X = {
+  name: "set-query-loading",
+  description: "Enable or disable TanStack Query loading-state simulation for a query by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash", "enabled"]
+  }
+}, Z = {
+  name: "set-query-error",
+  description: "Enable or disable TanStack Query error-state simulation for a query by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash", "enabled"]
+  }
+}, ee = {
+  name: "invalidate-query",
+  description: "Invalidate a TanStack Query query by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash"]
+  }
+}, te = {
+  name: "reset-query",
+  description: "Reset a TanStack Query query by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash"]
+  }
+}, re = {
+  name: "remove-query",
+  description: "Remove a TanStack Query query from the cache by queryHash.",
+  inputSchema: {
+    type: "object",
+    properties: f,
+    required: ["queryHash"]
+  }
+}, ae = {
+  name: "clear-query-cache",
+  description: "Clear the full TanStack Query query cache.",
+  inputSchema: Q
+}, se = {
+  name: "list-mutations",
+  description: "List TanStack Query mutation summaries using cursor pagination.",
+  inputSchema: {
+    type: "object",
+    properties: I
+  }
+}, ne = {
+  name: "get-mutation-details",
+  description: "Return a JSON-safe TanStack Query mutation snapshot for a mutationId.",
+  inputSchema: {
+    type: "object",
+    properties: x,
+    required: ["mutationId"]
+  }
+}, oe = {
+  name: "clear-mutation-cache",
+  description: "Clear the full TanStack Query mutation cache.",
+  inputSchema: Q
+}, ue = (e) => e ? {
+  enabled: o(e.enabled),
+  networkMode: o(e.networkMode),
+  staleTime: o(e.staleTime),
+  gcTime: o(e.gcTime),
+  retry: o(e.retry),
+  retryDelay: o(e.retryDelay),
+  refetchInterval: o(e.refetchInterval),
+  refetchOnMount: o(e.refetchOnMount),
+  refetchOnReconnect: o(e.refetchOnReconnect),
+  refetchOnWindowFocus: o(e.refetchOnWindowFocus),
+  subscribed: o(e.subscribed),
+  meta: o(e.meta),
+  hasQueryFn: typeof e.queryFn == "function",
+  hasSelect: typeof e.select == "function",
+  hasPlaceholderData: "placeholderData" in e,
+  hasInitialData: "initialData" in e
+} : null, ie = (e) => ({
+  mutationKey: o(e.mutationKey),
+  networkMode: o(e.networkMode),
+  gcTime: o(e.gcTime),
+  retry: o(e.retry),
+  retryDelay: o(e.retryDelay),
+  meta: o(e.meta),
+  scope: o(e.scope),
+  hasMutationFn: typeof e.mutationFn == "function",
+  hasOnMutate: typeof e.onMutate == "function",
+  hasOnSuccess: typeof e.onSuccess == "function",
+  hasOnError: typeof e.onError == "function",
+  hasOnSettled: typeof e.onSettled == "function"
+}), T = (e) => Math.max(e.state.dataUpdatedAt, e.state.errorUpdatedAt), ce = (e, r) => T(r) - T(e) || r.getObserversCount() - e.getObserversCount() || String(r.queryHash).localeCompare(String(e.queryHash)), de = (e, r) => r.state.submittedAt - e.state.submittedAt || r.mutationId - e.mutationId, H = (e) => ({
+  queryHash: e.queryHash,
+  queryKey: o(e.queryKey),
+  status: e.state.status,
+  fetchStatus: e.state.fetchStatus,
+  observersCount: e.getObserversCount(),
+  isInvalidated: e.state.isInvalidated,
+  dataUpdatedAt: e.state.dataUpdatedAt,
+  errorUpdatedAt: e.state.errorUpdatedAt,
+  hasData: e.state.data !== void 0,
+  hasError: e.state.error != null
+}), ye = (e) => e.status, v = (e) => ({
+  mutationId: e.mutationId,
+  mutationKey: o(e.options.mutationKey),
+  status: ye(e.state),
+  isPaused: e.state.isPaused,
+  submittedAt: e.state.submittedAt,
+  failureCount: e.state.failureCount,
+  hasData: e.state.data !== void 0,
+  hasError: e.state.error != null
+}), he = (e, r) => {
+  const t = e.getQueryCache().get(r);
+  if (!t) {
+    const a = e.getQueryCache().getAll().map((n) => n.queryHash).join(", ");
+    throw new Error(
+      `Unknown queryHash "${r}". Available: ${a || "(none)"}`
+    );
+  }
+  return t;
+}, pe = (e, r) => {
+  const t = e.getMutationCache().getAll().find((a) => a.mutationId === r);
+  if (!t) {
+    const a = e.getMutationCache().getAll().map((n) => n.mutationId).join(", ");
+    throw new Error(
+      `Unknown mutationId "${r}". Available: ${a || "(none)"}`
+    );
+  }
+  return t;
+}, b = (e) => {
+  const r = e.getQueryCache().getAll(), t = e.getMutationCache().getAll();
+  return {
+    online: g.isOnline(),
+    queries: {
+      total: r.length,
+      active: r.filter((a) => a.getObserversCount() > 0).length,
+      fetching: r.filter(
+        (a) => a.state.fetchStatus === "fetching"
+      ).length,
+      pending: r.filter((a) => a.state.status === "pending").length,
+      success: r.filter((a) => a.state.status === "success").length,
+      error: r.filter((a) => a.state.status === "error").length,
+      invalidated: r.filter((a) => a.state.isInvalidated).length
+    },
+    mutations: {
+      total: t.length,
+      pending: t.filter(
+        (a) => a.state.status === "pending"
+      ).length,
+      success: t.filter(
+        (a) => a.state.status === "success"
+      ).length,
+      error: t.filter((a) => a.state.status === "error").length,
+      paused: t.filter((a) => a.state.isPaused).length
+    }
+  };
+}, le = (e) => {
+  const r = {
+    queriesGeneration: 0,
+    mutationsGeneration: 0
+  };
+  return {
+    handleQueryCacheEvent(t) {
+      (t.type === "added" || t.type === "removed") && (r.queriesGeneration += 1);
+    },
+    handleMutationCacheEvent(t) {
+      (t.type === "added" || t.type === "removed") && (r.mutationsGeneration += 1);
+    },
+    getCacheSummary() {
+      return b(e);
+    },
+    getOnlineStatus() {
+      return {
+        online: g.isOnline()
+      };
+    },
+    setOnlineStatus({ online: t }) {
+      return g.setOnline(t), {
+        online: g.isOnline()
+      };
+    },
+    listQueries(t = {}) {
+      const a = [...e.getQueryCache().getAll()].sort(ce);
+      return {
+        ...b(e),
+        total: a.length,
+        ...A(
+          a.map(H),
+          "queries",
+          r.queriesGeneration,
+          t
+        )
+      };
+    },
+    getQueryDetails({ queryHash: t }) {
+      const a = he(e, t);
+      return {
+        summary: b(e),
+        query: {
+          ...H(a),
+          data: o(a.state.data),
+          error: o(a.state.error),
+          observers: a.observers.map((n) => ({
+            queryHash: a.queryHash,
+            options: ue(
+              n.options
+            )
+          }))
+        }
+      };
+    },
+    async refetchQuery({ queryHash: t }) {
+      return p(e, {
+        type: "REFETCH",
+        queryHash: t
+      });
+    },
+    async setQueryLoading({ queryHash: t, enabled: a }) {
+      return p(e, {
+        type: a ? "TRIGGER_LOADING" : "RESTORE_LOADING",
+        queryHash: t
+      });
+    },
+    async setQueryError({ queryHash: t, enabled: a }) {
+      return p(e, {
+        type: a ? "TRIGGER_ERROR" : "RESTORE_ERROR",
+        queryHash: t
+      });
+    },
+    async invalidateQuery({ queryHash: t }) {
+      return p(e, {
+        type: "INVALIDATE",
+        queryHash: t
+      });
+    },
+    async resetQuery({ queryHash: t }) {
+      return p(e, {
+        type: "RESET",
+        queryHash: t
+      });
+    },
+    async removeQuery({ queryHash: t }) {
+      return p(e, {
+        type: "REMOVE",
+        queryHash: t
+      });
+    },
+    async clearQueryCache() {
+      return p(e, {
+        type: "CLEAR_QUERY_CACHE"
+      });
+    },
+    listMutations(t = {}) {
+      const a = [...e.getMutationCache().getAll()].sort(
+        de
+      );
+      return {
+        ...b(e),
+        total: a.length,
+        ...A(
+          a.map(v),
+          "mutations",
+          r.mutationsGeneration,
+          t
+        )
+      };
+    },
+    getMutationDetails({ mutationId: t }) {
+      const a = pe(e, t);
+      return {
+        summary: b(e),
+        mutation: {
+          ...v(a),
+          variables: o(a.state.variables),
+          data: o(a.state.data),
+          error: o(a.state.error),
+          context: o(a.state.context),
+          failureReason: o(a.state.failureReason),
+          options: ie(a.options)
+        }
+      };
+    },
+    async clearMutationCache() {
+      return p(e, {
+        type: "CLEAR_MUTATION_CACHE"
+      });
+    }
+  };
+}, c = j, me = (e) => {
+  const r = M(
+    () => le(e),
+    [e]
+  );
+  S(() => {
+    const t = e.getQueryCache().subscribe((n) => r.handleQueryCacheEvent(n)), a = e.getMutationCache().subscribe((n) => r.handleMutationCacheEvent(n));
+    return () => {
+      t(), a();
+    };
+  }, [r, e]), i({
+    pluginId: c,
+    tool: z,
+    handler: () => r.getCacheSummary()
+  }), i({
+    pluginId: c,
+    tool: V,
+    handler: () => r.getOnlineStatus()
+  }), i({
+    pluginId: c,
+    tool: B,
+    handler: (t) => r.setOnlineStatus(t)
+  }), i({
+    pluginId: c,
+    tool: W,
+    handler: (t = {}) => r.listQueries(t)
+  }), i({
+    pluginId: c,
+    tool: Y,
+    handler: (t) => r.getQueryDetails(t)
+  }), i({
+    pluginId: c,
+    tool: J,
+    handler: (t) => r.refetchQuery(t)
+  }), i({
+    pluginId: c,
+    tool: X,
+    handler: (t) => r.setQueryLoading(t)
+  }), i({
+    pluginId: c,
+    tool: Z,
+    handler: (t) => r.setQueryError(t)
+  }), i({
+    pluginId: c,
+    tool: ee,
+    handler: (t) => r.invalidateQuery(t)
+  }), i({
+    pluginId: c,
+    tool: te,
+    handler: (t) => r.resetQuery(t)
+  }), i({
+    pluginId: c,
+    tool: re,
+    handler: (t) => r.removeQuery(t)
+  }), i({
+    pluginId: c,
+    tool: ae,
+    handler: () => r.clearQueryCache()
+  }), i({
+    pluginId: c,
+    tool: se,
+    handler: (t = {}) => r.listMutations(t)
+  }), i({
+    pluginId: c,
+    tool: ne,
+    handler: (t) => r.getMutationDetails(t)
+  }), i({
+    pluginId: c,
+    tool: oe,
+    handler: () => r.clearMutationCache()
+  });
+}, qe = (e) => {
+  const r = R({
+    pluginId: "@rozenite/tanstack-query-plugin"
+  });
+  w(r), C(e, r), _(e, r), G(e, r), me(e);
+};
+export {
+  qe as useTanStackQueryDevTools
+};