@rozenite/tanstack-query-plugin 2.1.0 → 2.3.0

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

@@ -1,895 +0,0 @@
-import { useRozeniteDevToolsClient as w } from "@rozenite/plugin-bridge";
-import { useEffect as A, useRef as C, useMemo as R } from "react";
-import { onlineManager as S } from "@tanstack/react-query";
-import U from "fast-deep-equal";
-import { useRozenitePluginAgentTool as i } from "@rozenite/agent-bridge";
-import { defineAgentToolContract as y, definePaginatedAgentToolContract as v } from "@rozenite/agent-shared";
-const _ = (e) => {
-  A(() => {
-    if (!e)
-      return;
-    const r = S.subscribe((a) => {
-      e.send("online-status-changed", { online: a });
-    }), t = e.onMessage("online-status-changed", ({ online: a }) => {
-      S.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;
-}, f = 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 "SET_QUERY_DATA": {
-      const t = m(e, r.queryHash);
-      return e.setQueryData(t.queryKey, r.metadata?.data), {
-        applied: !0,
-        action: r.type,
-        queryHash: t.queryHash
-      };
-    }
-    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
-      };
-    }
-  }
-}, G = (e, r) => {
-  A(() => {
-    if (!r)
-      return;
-    const t = r.onMessage("devtools-action", ({ type: a, queryHash: n, metadata: h }) => {
-      f(e, {
-        type: a,
-        queryHash: n,
-        metadata: h
-      }).catch((p) => {
-        const s = p instanceof Error ? p.message : String(p);
-        console.warn(
-          `[Rozenite, tanstack-query-plugin] Failed to apply devtools action "${a}": ${s}`
-        );
-      });
-    });
-    return () => {
-      t.remove();
-    };
-  }, [r]);
-}, k = (e) => e.observers.map((r) => ({
-  queryHash: e.queryHash,
-  options: r.options
-})), H = (e) => {
-  const r = k(e);
-  return {
-    state: e.state,
-    queryKey: e.queryKey,
-    queryHash: e.queryHash,
-    observers: r
-  };
-}, D = (e) => ({
-  mutationId: e.mutationId,
-  state: e.state,
-  options: e.options
-}), j = (e) => ({
-  queries: e.getQueryCache().getAll().map(H),
-  mutations: e.getMutationCache().getAll().map(D)
-}), N = (e, r) => {
-  const t = C(/* @__PURE__ */ new Map()), a = R(() => (n) => {
-    if (!r || n.type === "observerResultsUpdated")
-      return;
-    if ("query" in n) {
-      const { query: s, type: l } = n;
-      if (l === "added" || l === "removed") {
-        l === "removed" && t.current.delete(s.queryHash);
-        const g = H(s);
-        r.send("sync-query-event", { type: l, data: g });
-        return;
-      }
-      if (l === "updated" && "action" in n) {
-        const g = n.action;
-        switch (g.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: g.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 = H(s);
-            r.send("sync-query-event", { type: l, data: u });
-          }
-        }
-        return;
-      }
-      if (l === "observerAdded" || l === "observerRemoved" || l === "observerOptionsUpdated") {
-        const g = k(s), u = t.current.get(s.queryHash);
-        if (l === "observerOptionsUpdated" && u && U(u, g))
-          return;
-        t.current.set(s.queryHash, g), r.send("sync-query-event", {
-          type: l,
-          data: {
-            queryHash: s.queryHash,
-            observers: g
-          }
-        });
-        return;
-      }
-    }
-    const { mutation: h, type: p } = n;
-    if (h) {
-      const s = D(h);
-      r.send("sync-mutation-event", {
-        type: p,
-        data: s
-      });
-    }
-  }, [r]);
-  A(() => {
-    if (!r)
-      return;
-    const n = e.getMutationCache().subscribe(a), h = e.getQueryCache().subscribe(a);
-    return () => {
-      n(), h();
-    };
-  }, [r, e, a]);
-}, L = (e, r) => {
-  A(() => {
-    if (!r)
-      return;
-    const t = r.onMessage("request-initial-data", () => {
-      const a = j(e);
-      r.send("sync-data", { data: a });
-    });
-    return r.send("device-ready", {}), () => {
-      t.remove();
-    };
-  }, [r, e]);
-}, c = "@rozenite/tanstack-query-plugin", b = {
-  queryHash: {
-    type: "string",
-    description: "TanStack Query queryHash identifying the query."
-  }
-}, F = {
-  mutationId: {
-    type: "number",
-    description: "TanStack Query mutationId identifying the mutation."
-  }
-}, E = {
-  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: {}
-}, d = {
-  getCacheSummary: y({
-    name: "get-cache-summary",
-    description: "Return aggregate TanStack Query cache health and count information.",
-    inputSchema: q
-  }),
-  getOnlineStatus: y({
-    name: "get-online-status",
-    description: "Return the current TanStack Query onlineManager status.",
-    inputSchema: q
-  }),
-  setOnlineStatus: y({
-    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"]
-    }
-  }),
-  listQueries: v({
-    name: "list-queries",
-    description: "List TanStack Query query summaries using cursor pagination.",
-    inputSchema: {
-      type: "object",
-      properties: E
-    },
-    pagination: {
-      kind: "cursor",
-      fields: [
-        "queryHash",
-        "queryKey",
-        "status",
-        "fetchStatus",
-        "observersCount",
-        "isInvalidated",
-        "dataUpdatedAt",
-        "errorUpdatedAt",
-        "hasData",
-        "hasError"
-      ],
-      defaultFields: ["queryHash", "queryKey", "status", "fetchStatus", "hasError"]
-    }
-  }),
-  getQueryDetails: y({
-    name: "get-query-details",
-    description: "Return a JSON-safe TanStack Query query snapshot and observer summary.",
-    inputSchema: {
-      type: "object",
-      properties: b,
-      required: ["queryHash"]
-    }
-  }),
-  refetchQuery: y({
-    name: "refetch-query",
-    description: "Refetch a TanStack Query query by queryHash.",
-    inputSchema: {
-      type: "object",
-      properties: b,
-      required: ["queryHash"]
-    }
-  }),
-  setQueryLoading: y({
-    name: "set-query-loading",
-    description: "Enable or disable TanStack Query loading-state simulation for a query by queryHash.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        ...b,
-        enabled: {
-          type: "boolean",
-          description: "Whether the loading-state simulation should be enabled."
-        }
-      },
-      required: ["queryHash", "enabled"]
-    }
-  }),
-  setQueryError: y(
-    {
-      name: "set-query-error",
-      description: "Enable or disable TanStack Query error-state simulation for a query by queryHash.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          ...b,
-          enabled: {
-            type: "boolean",
-            description: "Whether the error-state simulation should be enabled."
-          }
-        },
-        required: ["queryHash", "enabled"]
-      }
-    }
-  ),
-  invalidateQuery: y({
-    name: "invalidate-query",
-    description: "Invalidate a TanStack Query query by queryHash.",
-    inputSchema: {
-      type: "object",
-      properties: b,
-      required: ["queryHash"]
-    }
-  }),
-  resetQuery: y({
-    name: "reset-query",
-    description: "Reset a TanStack Query query by queryHash.",
-    inputSchema: {
-      type: "object",
-      properties: b,
-      required: ["queryHash"]
-    }
-  }),
-  removeQuery: y({
-    name: "remove-query",
-    description: "Remove a TanStack Query query from the cache by queryHash.",
-    inputSchema: {
-      type: "object",
-      properties: b,
-      required: ["queryHash"]
-    }
-  }),
-  clearQueryCache: y({
-    name: "clear-query-cache",
-    description: "Clear the full TanStack Query query cache.",
-    inputSchema: q
-  }),
-  listMutations: v({
-    name: "list-mutations",
-    description: "List TanStack Query mutation summaries using cursor pagination.",
-    inputSchema: {
-      type: "object",
-      properties: E
-    },
-    pagination: {
-      kind: "cursor",
-      fields: [
-        "mutationId",
-        "mutationKey",
-        "status",
-        "isPaused",
-        "submittedAt",
-        "failureCount",
-        "hasData",
-        "hasError"
-      ],
-      defaultFields: ["mutationId", "mutationKey", "status", "hasError"]
-    }
-  }),
-  getMutationDetails: y({
-    name: "get-mutation-details",
-    description: "Return a JSON-safe TanStack Query mutation snapshot for a mutationId.",
-    inputSchema: {
-      type: "object",
-      properties: F,
-      required: ["mutationId"]
-    }
-  }),
-  clearMutationCache: y({
-    name: "clear-mutation-cache",
-    description: "Clear the full TanStack Query mutation cache.",
-    inputSchema: q
-  })
-}, P = 20, K = 100, $ = (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), !$(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);
-}, x = (e) => typeof e != "number" || !Number.isFinite(e) || !Number.isInteger(e) || e < 1 ? P : Math.min(e, K), z = (e, r, t) => `${e}:${r}:${t}`, W = (e, r, t) => {
-  const [a, n, h] = e.split(":", 3);
-  if (a !== r || !n || !h)
-    throw new Error("Cursor does not match the requested listing. Run the command again.");
-  const p = Number(n), s = Number(h);
-  if (!Number.isInteger(p) || p !== 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;
-}, M = (e, r, t, a) => {
-  const n = x(a.limit), h = a.cursor ? W(a.cursor, r, t) : 0, p = Math.min(h + n, e.length), s = p < e.length;
-  return {
-    items: e.slice(h, p),
-    page: {
-      limit: n,
-      hasMore: s,
-      ...s ? { nextCursor: z(r, t, p) } : {}
-    }
-  };
-}, V = (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, B = (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"
-}), O = (e) => Math.max(e.state.dataUpdatedAt, e.state.errorUpdatedAt), Y = (e, r) => O(r) - O(e) || r.getObserversCount() - e.getObserversCount() || String(r.queryHash).localeCompare(String(e.queryHash)), J = (e, r) => r.state.submittedAt - e.state.submittedAt || r.mutationId - e.mutationId, I = (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
-}), X = (e) => e.status, T = (e) => ({
-  mutationId: e.mutationId,
-  mutationKey: o(e.options.mutationKey),
-  status: X(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
-}), Z = (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;
-}, ee = (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;
-}, Q = (e) => {
-  const r = e.getQueryCache().getAll(), t = e.getMutationCache().getAll();
-  return {
-    online: S.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
-    }
-  };
-}, te = (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 Q(e);
-    },
-    getOnlineStatus() {
-      return {
-        online: S.isOnline()
-      };
-    },
-    setOnlineStatus({ online: t }) {
-      return S.setOnline(t), {
-        online: S.isOnline()
-      };
-    },
-    listQueries(t = {}) {
-      const a = [...e.getQueryCache().getAll()].sort(Y);
-      return {
-        ...Q(e),
-        total: a.length,
-        ...M(a.map(I), "queries", r.queriesGeneration, t)
-      };
-    },
-    getQueryDetails({ queryHash: t }) {
-      const a = Z(e, t);
-      return {
-        summary: Q(e),
-        query: {
-          ...I(a),
-          data: o(a.state.data),
-          error: o(a.state.error),
-          observers: a.observers.map((n) => ({
-            queryHash: a.queryHash,
-            options: V(
-              n.options
-            )
-          }))
-        }
-      };
-    },
-    async refetchQuery({ queryHash: t }) {
-      return f(e, {
-        type: "REFETCH",
-        queryHash: t
-      });
-    },
-    async setQueryLoading({ queryHash: t, enabled: a }) {
-      return f(e, {
-        type: a ? "TRIGGER_LOADING" : "RESTORE_LOADING",
-        queryHash: t
-      });
-    },
-    async setQueryError({ queryHash: t, enabled: a }) {
-      return f(e, {
-        type: a ? "TRIGGER_ERROR" : "RESTORE_ERROR",
-        queryHash: t
-      });
-    },
-    async invalidateQuery({ queryHash: t }) {
-      return f(e, {
-        type: "INVALIDATE",
-        queryHash: t
-      });
-    },
-    async resetQuery({ queryHash: t }) {
-      return f(e, {
-        type: "RESET",
-        queryHash: t
-      });
-    },
-    async removeQuery({ queryHash: t }) {
-      return f(e, {
-        type: "REMOVE",
-        queryHash: t
-      });
-    },
-    async clearQueryCache() {
-      return f(e, {
-        type: "CLEAR_QUERY_CACHE"
-      });
-    },
-    listMutations(t = {}) {
-      const a = [...e.getMutationCache().getAll()].sort(J);
-      return {
-        ...Q(e),
-        total: a.length,
-        ...M(
-          a.map(T),
-          "mutations",
-          r.mutationsGeneration,
-          t
-        )
-      };
-    },
-    getMutationDetails({ mutationId: t }) {
-      const a = ee(e, t);
-      return {
-        summary: Q(e),
-        mutation: {
-          ...T(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: B(a.options)
-        }
-      };
-    },
-    async clearMutationCache() {
-      return f(e, {
-        type: "CLEAR_MUTATION_CACHE"
-      });
-    }
-  };
-}, re = (e) => {
-  const r = R(() => te(e), [e]);
-  A(() => {
-    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: d.getCacheSummary,
-    handler: () => r.getCacheSummary()
-  }), i({
-    pluginId: c,
-    tool: d.getOnlineStatus,
-    handler: () => r.getOnlineStatus()
-  }), i({
-    pluginId: c,
-    tool: d.setOnlineStatus,
-    handler: (t) => r.setOnlineStatus(t)
-  }), i({
-    pluginId: c,
-    tool: d.listQueries,
-    handler: (t = {}) => r.listQueries(t)
-  }), i({
-    pluginId: c,
-    tool: d.getQueryDetails,
-    handler: (t) => r.getQueryDetails(t)
-  }), i({
-    pluginId: c,
-    tool: d.refetchQuery,
-    handler: (t) => r.refetchQuery(t)
-  }), i({
-    pluginId: c,
-    tool: d.setQueryLoading,
-    handler: (t) => r.setQueryLoading(t)
-  }), i({
-    pluginId: c,
-    tool: d.setQueryError,
-    handler: (t) => r.setQueryError(t)
-  }), i({
-    pluginId: c,
-    tool: d.invalidateQuery,
-    handler: (t) => r.invalidateQuery(t)
-  }), i({
-    pluginId: c,
-    tool: d.resetQuery,
-    handler: (t) => r.resetQuery(t)
-  }), i({
-    pluginId: c,
-    tool: d.removeQuery,
-    handler: (t) => r.removeQuery(t)
-  }), i({
-    pluginId: c,
-    tool: d.clearQueryCache,
-    handler: () => r.clearQueryCache()
-  }), i({
-    pluginId: c,
-    tool: d.listMutations,
-    handler: (t = {}) => r.listMutations(t)
-  }), i({
-    pluginId: c,
-    tool: d.getMutationDetails,
-    handler: (t) => r.getMutationDetails(t)
-  }), i({
-    pluginId: c,
-    tool: d.clearMutationCache,
-    handler: () => r.clearMutationCache()
-  });
-}, ce = (e) => {
-  const r = w({
-    pluginId: "@rozenite/tanstack-query-plugin"
-  });
-  _(r), G(e, r), N(e, r), L(e, r), re(e);
-};
-export {
-  ce as useTanStackQueryDevTools
-};