@rozenite/tanstack-query-plugin 1.7.0-rc.2 → 1.8.0

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

@@ -1,18 +1,19 @@
-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 { useRozeniteDevToolsClient as D } from "@rozenite/plugin-bridge";
+import { useEffect as A, useRef as w, useMemo as I } from "react";
+import { onlineManager as S } from "@tanstack/react-query";
+import C from "fast-deep-equal";
 import { useRozenitePluginAgentTool as i } from "@rozenite/agent-bridge";
-const w = (e) => {
-  S(() => {
+import { defineAgentToolContract as c } from "@rozenite/agent-shared";
+const _ = (e) => {
+  A(() => {
     if (!e)
       return;
-    const r = g.subscribe((a) => {
+    const r = S.subscribe((a) => {
       e.send("online-status-changed", { online: a });
     }), t = e.onMessage(
       "online-status-changed",
       ({ online: a }) => {
-        g.setOnline(a);
+        S.setOnline(a);
       }
     );
     return () => {
@@ -26,7 +27,7 @@ const w = (e) => {
   if (!t)
     throw new Error(`No active query found for hash: ${r}`);
   return t;
-}, p = async (e, r) => {
+}, f = async (e, r) => {
   switch (r.type) {
     case "CLEAR_QUERY_CACHE": {
       const t = e.getQueryCache().getAll().length;
@@ -48,6 +49,14 @@ const w = (e) => {
         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({
@@ -139,17 +148,21 @@ const w = (e) => {
       };
     }
   }
-}, C = (e, r) => {
-  S(() => {
+}, U = (e, r) => {
+  A(() => {
     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);
+      ({ 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}": ${h}`
+            `[Rozenite, tanstack-query-plugin] Failed to apply devtools action "${a}": ${s}`
           );
         });
       }
@@ -158,41 +171,41 @@ const w = (e) => {
       t.remove();
     };
   }, [r]);
-}, E = (e) => e.observers.map((r) => ({
+}, R = (e) => e.observers.map((r) => ({
   queryHash: e.queryHash,
   options: r.options
-})), q = (e) => {
-  const r = E(e);
+})), H = (e) => {
+  const r = R(e);
   return {
     state: e.state,
     queryKey: e.queryKey,
     queryHash: e.queryHash,
     observers: r
   };
-}, O = (e) => ({
+}, k = (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(
+}), G = (e) => ({
+  queries: e.getQueryCache().getAll().map(H),
+  mutations: e.getMutationCache().getAll().map(k)
+}), j = (e, r) => {
+  const t = w(
     /* @__PURE__ */ new Map()
-  ), a = M(() => (n) => {
+  ), a = I(() => (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 });
+      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 (y === "updated" && "action" in n) {
-        const l = n.action;
-        switch (l.type) {
+      if (l === "updated" && "action" in n) {
+        const g = n.action;
+        switch (g.type) {
           case "fetch": {
             const u = {
               queryHash: s.queryHash,
@@ -250,7 +263,7 @@ const w = (e) => {
           case "setState": {
             const u = {
               queryHash: s.queryHash,
-              state: l.state
+              state: g.state
               // Only the changed state parts
             };
             r.send("sync-query-event", {
@@ -303,61 +316,218 @@ const w = (e) => {
             break;
           }
           default: {
-            const u = q(s);
-            r.send("sync-query-event", { type: y, data: u });
+            const u = H(s);
+            r.send("sync-query-event", { type: l, data: u });
           }
         }
         return;
       }
-      if (y === "observerAdded" || y === "observerRemoved" || y === "observerOptionsUpdated") {
-        const l = E(s), u = t.current.get(
+      if (l === "observerAdded" || l === "observerRemoved" || l === "observerOptionsUpdated") {
+        const g = R(s), u = t.current.get(
           s.queryHash
         );
-        if (y === "observerOptionsUpdated" && u && D(u, l))
+        if (l === "observerOptionsUpdated" && u && C(u, g))
           return;
         t.current.set(
           s.queryHash,
-          l
+          g
         ), r.send("sync-query-event", {
-          type: y,
+          type: l,
           data: {
             queryHash: s.queryHash,
-            observers: l
+            observers: g
           }
         });
         return;
       }
     }
-    const { mutation: d, type: h } = n;
-    if (d) {
-      const s = O(d);
+    const { mutation: h, type: p } = n;
+    if (h) {
+      const s = k(h);
       r.send("sync-mutation-event", {
-        type: h,
+        type: p,
         data: s
       });
     }
   }, [r]);
-  S(() => {
+  A(() => {
     if (!r)
       return;
-    const n = e.getMutationCache().subscribe(a), d = e.getQueryCache().subscribe(a);
+    const n = e.getMutationCache().subscribe(a), h = e.getQueryCache().subscribe(a);
     return () => {
-      n(), d();
+      n(), h();
     };
   }, [r, e, a]);
-}, G = (e, r) => {
-  S(() => {
+}, N = (e, r) => {
+  A(() => {
     if (!r)
       return;
     const t = r.onMessage("request-initial-data", () => {
-      const a = U(e);
+      const a = G(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()) => {
+}, d = "@rozenite/tanstack-query-plugin", b = {
+  queryHash: {
+    type: "string",
+    description: "TanStack Query queryHash identifying the query."
+  }
+}, L = {
+  mutationId: {
+    type: "number",
+    description: "TanStack Query mutationId identifying the mutation."
+  }
+}, v = {
+  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: {}
+}, y = {
+  getCacheSummary: c({
+    name: "get-cache-summary",
+    description: "Return aggregate TanStack Query cache health and count information.",
+    inputSchema: q
+  }),
+  getOnlineStatus: c({
+    name: "get-online-status",
+    description: "Return the current TanStack Query onlineManager status.",
+    inputSchema: q
+  }),
+  setOnlineStatus: c({
+    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: c({
+    name: "list-queries",
+    description: "List TanStack Query query summaries using cursor pagination.",
+    inputSchema: {
+      type: "object",
+      properties: v
+    }
+  }),
+  getQueryDetails: c({
+    name: "get-query-details",
+    description: "Return a JSON-safe TanStack Query query snapshot and observer summary.",
+    inputSchema: {
+      type: "object",
+      properties: b,
+      required: ["queryHash"]
+    }
+  }),
+  refetchQuery: c({
+    name: "refetch-query",
+    description: "Refetch a TanStack Query query by queryHash.",
+    inputSchema: {
+      type: "object",
+      properties: b,
+      required: ["queryHash"]
+    }
+  }),
+  setQueryLoading: c({
+    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: c({
+    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: c({
+    name: "invalidate-query",
+    description: "Invalidate a TanStack Query query by queryHash.",
+    inputSchema: {
+      type: "object",
+      properties: b,
+      required: ["queryHash"]
+    }
+  }),
+  resetQuery: c({
+    name: "reset-query",
+    description: "Reset a TanStack Query query by queryHash.",
+    inputSchema: {
+      type: "object",
+      properties: b,
+      required: ["queryHash"]
+    }
+  }),
+  removeQuery: c({
+    name: "remove-query",
+    description: "Remove a TanStack Query query from the cache by queryHash.",
+    inputSchema: {
+      type: "object",
+      properties: b,
+      required: ["queryHash"]
+    }
+  }),
+  clearQueryCache: c({
+    name: "clear-query-cache",
+    description: "Clear the full TanStack Query query cache.",
+    inputSchema: q
+  }),
+  listMutations: c({
+    name: "list-mutations",
+    description: "List TanStack Query mutation summaries using cursor pagination.",
+    inputSchema: {
+      type: "object",
+      properties: v
+    }
+  }),
+  getMutationDetails: c({
+    name: "get-mutation-details",
+    description: "Return a JSON-safe TanStack Query mutation snapshot for a mutationId.",
+    inputSchema: {
+      type: "object",
+      properties: L,
+      required: ["mutationId"]
+    }
+  }),
+  clearMutationCache: c({
+    name: "clear-mutation-cache",
+    description: "Clear the full TanStack Query mutation cache.",
+    inputSchema: q
+  })
+}, F = 20, P = 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")
@@ -391,7 +561,7 @@ const w = (e) => {
   if (typeof e == "object") {
     if (r.has(e))
       return "[circular]";
-    if (r.add(e), !F(e))
+    if (r.add(e), !$(e))
       return `[non-serializable:${e.constructor?.name ?? "Object"}]`;
     const t = Object.entries(e).map(([a, n]) => [
       a,
@@ -400,160 +570,31 @@ const w = (e) => {
     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)
+}, K = (e) => typeof e != "number" || !Number.isFinite(e) || !Number.isInteger(e) || e < 1 ? F : Math.min(e, P), x = (e, r, t) => `${e}:${r}:${t}`, z = (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 h = Number(n), s = Number(d);
-  if (!Number.isInteger(h) || h !== t)
+  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;
-}, 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;
+}, M = (e, r, t, a) => {
+  const n = K(a.limit), h = a.cursor ? z(a.cursor, r, t) : 0, p = Math.min(h + n, e.length), s = p < e.length;
   return {
-    items: e.slice(d, h),
+    items: e.slice(h, p),
     page: {
       limit: n,
       hasMore: s,
-      ...s ? { nextCursor: $(r, t, h) } : {}
+      ...s ? { nextCursor: x(r, t, p) } : {}
     }
   };
-}, 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 ? {
+}, W = (e) => e ? {
   enabled: o(e.enabled),
   networkMode: o(e.networkMode),
   staleTime: o(e.staleTime),
@@ -570,7 +611,7 @@ const w = (e) => {
   hasSelect: typeof e.select == "function",
   hasPlaceholderData: "placeholderData" in e,
   hasInitialData: "initialData" in e
-} : null, ie = (e) => ({
+} : null, V = (e) => ({
   mutationKey: o(e.mutationKey),
   networkMode: o(e.networkMode),
   gcTime: o(e.gcTime),
@@ -583,7 +624,7 @@ const w = (e) => {
   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) => ({
+}), E = (e) => Math.max(e.state.dataUpdatedAt, e.state.errorUpdatedAt), B = (e, r) => E(r) - E(e) || r.getObserversCount() - e.getObserversCount() || String(r.queryHash).localeCompare(String(e.queryHash)), Y = (e, r) => r.state.submittedAt - e.state.submittedAt || r.mutationId - e.mutationId, O = (e) => ({
   queryHash: e.queryHash,
   queryKey: o(e.queryKey),
   status: e.state.status,
@@ -594,16 +635,16 @@ const w = (e) => {
   errorUpdatedAt: e.state.errorUpdatedAt,
   hasData: e.state.data !== void 0,
   hasError: e.state.error != null
-}), ye = (e) => e.status, v = (e) => ({
+}), J = (e) => e.status, T = (e) => ({
   mutationId: e.mutationId,
   mutationKey: o(e.options.mutationKey),
-  status: ye(e.state),
+  status: J(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) => {
+}), X = (e, r) => {
   const t = e.getQueryCache().get(r);
   if (!t) {
     const a = e.getQueryCache().getAll().map((n) => n.queryHash).join(", ");
@@ -612,7 +653,7 @@ const w = (e) => {
     );
   }
   return t;
-}, pe = (e, r) => {
+}, Z = (e, r) => {
   const t = e.getMutationCache().getAll().find((a) => a.mutationId === r);
   if (!t) {
     const a = e.getMutationCache().getAll().map((n) => n.mutationId).join(", ");
@@ -621,10 +662,10 @@ const w = (e) => {
     );
   }
   return t;
-}, b = (e) => {
+}, Q = (e) => {
   const r = e.getQueryCache().getAll(), t = e.getMutationCache().getAll();
   return {
-    online: g.isOnline(),
+    online: S.isOnline(),
     queries: {
       total: r.length,
       active: r.filter((a) => a.getObserversCount() > 0).length,
@@ -648,7 +689,7 @@ const w = (e) => {
       paused: t.filter((a) => a.state.isPaused).length
     }
   };
-}, le = (e) => {
+}, ee = (e) => {
   const r = {
     queriesGeneration: 0,
     mutationsGeneration: 0
@@ -661,25 +702,25 @@ const w = (e) => {
       (t.type === "added" || t.type === "removed") && (r.mutationsGeneration += 1);
     },
     getCacheSummary() {
-      return b(e);
+      return Q(e);
     },
     getOnlineStatus() {
       return {
-        online: g.isOnline()
+        online: S.isOnline()
       };
     },
     setOnlineStatus({ online: t }) {
-      return g.setOnline(t), {
-        online: g.isOnline()
+      return S.setOnline(t), {
+        online: S.isOnline()
       };
     },
     listQueries(t = {}) {
-      const a = [...e.getQueryCache().getAll()].sort(ce);
+      const a = [...e.getQueryCache().getAll()].sort(B);
       return {
-        ...b(e),
+        ...Q(e),
         total: a.length,
-        ...A(
-          a.map(H),
+        ...M(
+          a.map(O),
           "queries",
           r.queriesGeneration,
           t
@@ -687,16 +728,16 @@ const w = (e) => {
       };
     },
     getQueryDetails({ queryHash: t }) {
-      const a = he(e, t);
+      const a = X(e, t);
       return {
-        summary: b(e),
+        summary: Q(e),
         query: {
-          ...H(a),
+          ...O(a),
           data: o(a.state.data),
           error: o(a.state.error),
           observers: a.observers.map((n) => ({
             queryHash: a.queryHash,
-            options: ue(
+            options: W(
               n.options
             )
           }))
@@ -704,55 +745,55 @@ const w = (e) => {
       };
     },
     async refetchQuery({ queryHash: t }) {
-      return p(e, {
+      return f(e, {
         type: "REFETCH",
         queryHash: t
       });
     },
     async setQueryLoading({ queryHash: t, enabled: a }) {
-      return p(e, {
+      return f(e, {
         type: a ? "TRIGGER_LOADING" : "RESTORE_LOADING",
         queryHash: t
       });
     },
     async setQueryError({ queryHash: t, enabled: a }) {
-      return p(e, {
+      return f(e, {
         type: a ? "TRIGGER_ERROR" : "RESTORE_ERROR",
         queryHash: t
       });
     },
     async invalidateQuery({ queryHash: t }) {
-      return p(e, {
+      return f(e, {
         type: "INVALIDATE",
         queryHash: t
       });
     },
     async resetQuery({ queryHash: t }) {
-      return p(e, {
+      return f(e, {
         type: "RESET",
         queryHash: t
       });
     },
     async removeQuery({ queryHash: t }) {
-      return p(e, {
+      return f(e, {
         type: "REMOVE",
         queryHash: t
       });
     },
     async clearQueryCache() {
-      return p(e, {
+      return f(e, {
         type: "CLEAR_QUERY_CACHE"
       });
     },
     listMutations(t = {}) {
       const a = [...e.getMutationCache().getAll()].sort(
-        de
+        Y
       );
       return {
-        ...b(e),
+        ...Q(e),
         total: a.length,
-        ...A(
-          a.map(v),
+        ...M(
+          a.map(T),
           "mutations",
           r.mutationsGeneration,
           t
@@ -760,103 +801,103 @@ const w = (e) => {
       };
     },
     getMutationDetails({ mutationId: t }) {
-      const a = pe(e, t);
+      const a = Z(e, t);
       return {
-        summary: b(e),
+        summary: Q(e),
         mutation: {
-          ...v(a),
+          ...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: ie(a.options)
+          options: V(a.options)
         }
       };
     },
     async clearMutationCache() {
-      return p(e, {
+      return f(e, {
         type: "CLEAR_MUTATION_CACHE"
       });
     }
   };
-}, c = j, me = (e) => {
-  const r = M(
-    () => le(e),
+}, te = (e) => {
+  const r = I(
+    () => ee(e),
     [e]
   );
-  S(() => {
+  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: z,
+    pluginId: d,
+    tool: y.getCacheSummary,
     handler: () => r.getCacheSummary()
   }), i({
-    pluginId: c,
-    tool: V,
+    pluginId: d,
+    tool: y.getOnlineStatus,
     handler: () => r.getOnlineStatus()
   }), i({
-    pluginId: c,
-    tool: B,
+    pluginId: d,
+    tool: y.setOnlineStatus,
     handler: (t) => r.setOnlineStatus(t)
   }), i({
-    pluginId: c,
-    tool: W,
+    pluginId: d,
+    tool: y.listQueries,
     handler: (t = {}) => r.listQueries(t)
   }), i({
-    pluginId: c,
-    tool: Y,
+    pluginId: d,
+    tool: y.getQueryDetails,
     handler: (t) => r.getQueryDetails(t)
   }), i({
-    pluginId: c,
-    tool: J,
+    pluginId: d,
+    tool: y.refetchQuery,
     handler: (t) => r.refetchQuery(t)
   }), i({
-    pluginId: c,
-    tool: X,
+    pluginId: d,
+    tool: y.setQueryLoading,
     handler: (t) => r.setQueryLoading(t)
   }), i({
-    pluginId: c,
-    tool: Z,
+    pluginId: d,
+    tool: y.setQueryError,
     handler: (t) => r.setQueryError(t)
   }), i({
-    pluginId: c,
-    tool: ee,
+    pluginId: d,
+    tool: y.invalidateQuery,
     handler: (t) => r.invalidateQuery(t)
   }), i({
-    pluginId: c,
-    tool: te,
+    pluginId: d,
+    tool: y.resetQuery,
     handler: (t) => r.resetQuery(t)
   }), i({
-    pluginId: c,
-    tool: re,
+    pluginId: d,
+    tool: y.removeQuery,
     handler: (t) => r.removeQuery(t)
   }), i({
-    pluginId: c,
-    tool: ae,
+    pluginId: d,
+    tool: y.clearQueryCache,
     handler: () => r.clearQueryCache()
   }), i({
-    pluginId: c,
-    tool: se,
+    pluginId: d,
+    tool: y.listMutations,
     handler: (t = {}) => r.listMutations(t)
   }), i({
-    pluginId: c,
-    tool: ne,
+    pluginId: d,
+    tool: y.getMutationDetails,
     handler: (t) => r.getMutationDetails(t)
   }), i({
-    pluginId: c,
-    tool: oe,
+    pluginId: d,
+    tool: y.clearMutationCache,
     handler: () => r.clearMutationCache()
   });
-}, qe = (e) => {
-  const r = R({
+}, ie = (e) => {
+  const r = D({
     pluginId: "@rozenite/tanstack-query-plugin"
   });
-  w(r), C(e, r), _(e, r), G(e, r), me(e);
+  _(r), U(e, r), j(e, r), N(e, r), te(e);
 };
 export {
-  qe as useTanStackQueryDevTools
+  ie as useTanStackQueryDevTools
 };