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

package/src/react-native/agent/useTanStackQueryAgentTools.ts

@@ -0,0 +1,147 @@
+import { useEffect, useMemo } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { useRozenitePluginAgentTool } from '@rozenite/agent-bridge';
+import {
+  clearMutationCacheTool,
+  clearQueryCacheTool,
+  createTanStackQueryAgentController,
+  getCacheSummaryTool,
+  getMutationDetailsTool,
+  getOnlineStatusTool,
+  getQueryDetailsTool,
+  invalidateQueryTool,
+  listMutationsTool,
+  listQueriesTool,
+  refetchQueryTool,
+  removeQueryTool,
+  resetQueryTool,
+  setQueryErrorTool,
+  setQueryLoadingTool,
+  TANSTACK_QUERY_AGENT_PLUGIN_ID,
+  type TanStackQueryAgentMutationIdInput,
+  type TanStackQueryAgentOnlineStatusInput,
+  type TanStackQueryAgentPaginationInput,
+  type TanStackQueryAgentQueryHashInput,
+  type TanStackQueryAgentQueryToggleInput,
+  setOnlineStatusTool,
+} from './tanstack-query-agent';
+
+export const useTanStackQueryAgentTools = (queryClient: QueryClient) => {
+  const controller = useMemo(
+    () => createTanStackQueryAgentController(queryClient),
+    [queryClient]
+  );
+
+  useEffect(() => {
+    const unsubscribeQueryCache = queryClient
+      .getQueryCache()
+      .subscribe((event) => controller.handleQueryCacheEvent(event));
+    const unsubscribeMutationCache = queryClient
+      .getMutationCache()
+      .subscribe((event) => controller.handleMutationCacheEvent(event));
+
+    return () => {
+      unsubscribeQueryCache();
+      unsubscribeMutationCache();
+    };
+  }, [controller, queryClient]);
+
+  useRozenitePluginAgentTool({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: getCacheSummaryTool,
+    handler: () => controller.getCacheSummary(),
+  });
+
+  useRozenitePluginAgentTool({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: getOnlineStatusTool,
+    handler: () => controller.getOnlineStatus(),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentOnlineStatusInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: setOnlineStatusTool,
+    handler: (input: TanStackQueryAgentOnlineStatusInput) =>
+      controller.setOnlineStatus(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentPaginationInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: listQueriesTool,
+    handler: (input = {}) => controller.listQueries(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryHashInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: getQueryDetailsTool,
+    handler: (input: TanStackQueryAgentQueryHashInput) =>
+      controller.getQueryDetails(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryHashInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: refetchQueryTool,
+    handler: (input: TanStackQueryAgentQueryHashInput) =>
+      controller.refetchQuery(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryToggleInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: setQueryLoadingTool,
+    handler: (input: TanStackQueryAgentQueryToggleInput) =>
+      controller.setQueryLoading(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryToggleInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: setQueryErrorTool,
+    handler: (input: TanStackQueryAgentQueryToggleInput) =>
+      controller.setQueryError(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryHashInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: invalidateQueryTool,
+    handler: (input: TanStackQueryAgentQueryHashInput) =>
+      controller.invalidateQuery(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryHashInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: resetQueryTool,
+    handler: (input: TanStackQueryAgentQueryHashInput) =>
+      controller.resetQuery(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentQueryHashInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: removeQueryTool,
+    handler: (input: TanStackQueryAgentQueryHashInput) =>
+      controller.removeQuery(input),
+  });
+
+  useRozenitePluginAgentTool({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: clearQueryCacheTool,
+    handler: () => controller.clearQueryCache(),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentPaginationInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: listMutationsTool,
+    handler: (input = {}) => controller.listMutations(input),
+  });
+
+  useRozenitePluginAgentTool<TanStackQueryAgentMutationIdInput>({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: getMutationDetailsTool,
+    handler: (input: TanStackQueryAgentMutationIdInput) =>
+      controller.getMutationDetails(input),
+  });
+
+  useRozenitePluginAgentTool({
+    pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+    tool: clearMutationCacheTool,
+    handler: () => controller.clearMutationCache(),
+  });
+};

package/src/react-native/devtools-actions.ts

@@ -0,0 +1,197 @@
+import { QueryClient } from '@tanstack/react-query';
+import { DevToolsActionType } from '../shared/types';
+
+type QueryScopedActionInput = {
+  type: Exclude<
+    DevToolsActionType,
+    'CLEAR_MUTATION_CACHE' | 'CLEAR_QUERY_CACHE'
+  >;
+  queryHash: string;
+};
+
+type CacheScopedActionInput = {
+  type: 'CLEAR_MUTATION_CACHE' | 'CLEAR_QUERY_CACHE';
+  queryHash?: string;
+};
+
+export type TanStackQueryDevtoolsActionInput =
+  | QueryScopedActionInput
+  | CacheScopedActionInput;
+
+const getActiveQuery = (queryClient: QueryClient, queryHash?: string) => {
+  if (!queryHash) {
+    throw new Error('queryHash is required for this TanStack Query action.');
+  }
+
+  const activeQuery = queryClient.getQueryCache().get(queryHash);
+  if (!activeQuery) {
+    throw new Error(`No active query found for hash: ${queryHash}`);
+  }
+
+  return activeQuery;
+};
+
+export const applyTanStackQueryDevtoolsAction = async (
+  queryClient: QueryClient,
+  input: TanStackQueryDevtoolsActionInput
+) => {
+  switch (input.type) {
+    case 'CLEAR_QUERY_CACHE': {
+      const queryCountBefore = queryClient.getQueryCache().getAll().length;
+      queryClient.getQueryCache().clear();
+      return {
+        applied: true,
+        action: input.type,
+        cleared: true,
+        queryCountBefore,
+        queryCountAfter: queryClient.getQueryCache().getAll().length,
+      };
+    }
+
+    case 'CLEAR_MUTATION_CACHE': {
+      const mutationCountBefore =
+        queryClient.getMutationCache().getAll().length;
+      queryClient.getMutationCache().clear();
+      return {
+        applied: true,
+        action: input.type,
+        cleared: true,
+        mutationCountBefore,
+        mutationCountAfter: queryClient.getMutationCache().getAll().length,
+      };
+    }
+
+    case 'TRIGGER_ERROR': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      const previousQueryOptions = activeQuery.options;
+      const error = new Error('Unknown error from devtools');
+
+      activeQuery.setState({
+        status: 'error',
+        error,
+        fetchMeta: {
+          ...activeQuery.state.fetchMeta,
+          // @ts-expect-error This does exist
+          __previousQueryOptions: previousQueryOptions,
+        },
+      });
+
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'RESTORE_ERROR': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      await queryClient.resetQueries(activeQuery);
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'TRIGGER_LOADING': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      const previousQueryOptions = activeQuery.options;
+
+      void activeQuery.fetch({
+        ...previousQueryOptions,
+        queryFn: () =>
+          new Promise(() => {
+            // Never resolve - simulates perpetual loading
+          }),
+        gcTime: -1,
+      });
+
+      activeQuery.setState({
+        data: undefined,
+        status: 'pending',
+        fetchMeta: {
+          ...activeQuery.state.fetchMeta,
+          // @ts-expect-error This does exist
+          __previousQueryOptions: previousQueryOptions,
+        },
+      });
+
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'RESTORE_LOADING': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      const previousState = activeQuery.state;
+      const previousOptions = activeQuery.state.fetchMeta
+        ? (
+            activeQuery.state.fetchMeta as unknown as {
+              __previousQueryOptions: unknown;
+            }
+          ).__previousQueryOptions
+        : null;
+
+      activeQuery.cancel({ silent: true });
+      activeQuery.setState({
+        ...previousState,
+        fetchStatus: 'idle',
+        fetchMeta: null,
+      });
+
+      if (previousOptions) {
+        void activeQuery.fetch(previousOptions);
+      }
+
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'RESET': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      await queryClient.resetQueries(activeQuery);
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'REMOVE': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      queryClient.removeQueries(activeQuery);
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'REFETCH': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      await activeQuery.fetch().catch(() => {
+        // Ignore errors from refetch in the agent/UI bridge.
+      });
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+
+    case 'INVALIDATE': {
+      const activeQuery = getActiveQuery(queryClient, input.queryHash);
+      await queryClient.invalidateQueries(activeQuery);
+      return {
+        applied: true,
+        action: input.type,
+        queryHash: activeQuery.queryHash,
+      };
+    }
+  }
+};

package/src/react-native/useHandleDevToolsMessages.ts

@@ -1,6 +1,7 @@
 import { useEffect } from 'react';
 import { QueryClient } from '@tanstack/react-query';
 import { TanStackQueryPluginClient } from '../shared/messaging';
+import { applyTanStackQueryDevtoolsAction } from './devtools-actions';
 
 export const useHandleDevToolsMessages = (
   queryClient: QueryClient,
@@ -14,110 +15,14 @@ export const useHandleDevToolsMessages = (
     const subscription = client.onMessage(
       'devtools-action',
       ({ type, queryHash }) => {
-        const activeQuery = queryClient.getQueryCache().get(queryHash);
-
-        if (!activeQuery) {
-          console.warn(`No active query found for hash: ${queryHash}`);
-          return;
-        }
-
-        switch (type) {
-          case 'TRIGGER_ERROR': {
-            // Code from React Query External Sync:
-            // https://github.com/LovesWorking/react-query-external-sync/blob/main/src/react-query-external-sync/useSyncQueriesExternal.ts#L717
-
-            const __previousQueryOptions = activeQuery.options;
-            const error = new Error('Unknown error from devtools');
-
-            activeQuery.setState({
-              status: 'error',
-              error,
-              fetchMeta: {
-                ...activeQuery.state.fetchMeta,
-                // @ts-expect-error This does exist
-                __previousQueryOptions,
-              },
-            });
-            break;
-          }
-          case 'RESTORE_ERROR': {
-            queryClient.resetQueries(activeQuery);
-            break;
-          }
-          case 'TRIGGER_LOADING': {
-            // Code from React Query External Sync:
-            // https://github.com/LovesWorking/react-query-external-sync/blob/main/src/react-query-external-sync/useSyncQueriesExternal.ts#L742
-
-            if (!activeQuery) return;
-            const __previousQueryOptions = activeQuery.options;
-            // Trigger a fetch in order to trigger suspense as well.
-            activeQuery.fetch({
-              ...__previousQueryOptions,
-              queryFn: () => {
-                return new Promise(() => {
-                  // Never resolve - simulates perpetual loading
-                });
-              },
-              gcTime: -1,
-            });
-            activeQuery.setState({
-              data: undefined,
-              status: 'pending',
-              fetchMeta: {
-                ...activeQuery.state.fetchMeta,
-                // @ts-expect-error This does exist
-                __previousQueryOptions,
-              },
-            });
-            break;
-          }
-          case 'RESTORE_LOADING': {
-            // Code from React Query External Sync:
-            // https://github.com/LovesWorking/tanstack-query-dev-tools-expo-plugin/blob/main/src/useSyncQueries.ts#L176
-
-            const previousState = activeQuery.state;
-            const previousOptions = activeQuery.state.fetchMeta
-              ? (
-                  activeQuery.state.fetchMeta as unknown as {
-                    __previousQueryOptions: unknown;
-                  }
-                ).__previousQueryOptions
-              : null;
-
-            activeQuery.cancel({ silent: true });
-            activeQuery.setState({
-              ...previousState,
-              fetchStatus: 'idle',
-              fetchMeta: null,
-            });
-
-            if (previousOptions) {
-              activeQuery.fetch(previousOptions);
-            }
-            break;
-          }
-          case 'RESET': {
-            queryClient.resetQueries(activeQuery);
-            break;
-          }
-          case 'REMOVE': {
-            queryClient.removeQueries(activeQuery);
-            break;
-          }
-          case 'REFETCH': {
-            activeQuery.fetch().catch(() => {
-              // Ignore errors
-            });
-            break;
-          }
-          case 'INVALIDATE': {
-            queryClient.invalidateQueries(activeQuery);
-            break;
-          }
-          default: {
-            console.warn(`Unknown devtools action: ${type}`);
-          }
-        }
+        void applyTanStackQueryDevtoolsAction(queryClient, { type, queryHash })
+          .catch((error) => {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            console.warn(
+              `[Rozenite, tanstack-query-plugin] Failed to apply devtools action "${type}": ${message}`
+            );
+          });
       }
     );
 

package/src/react-native/useTanStackQueryDevTools.ts

@@ -5,6 +5,7 @@ import { useSyncOnlineStatus } from '../shared/useSyncOnlineStatus';
 import { useHandleDevToolsMessages } from './useHandleDevToolsMessages';
 import { useSyncTanStackCache } from './useSyncTanStackCache';
 import { useHandleInitialData } from './useHandleInitialData';
+import { useTanStackQueryAgentTools } from './agent/useTanStackQueryAgentTools';
 
 export const useTanStackQueryDevTools = (queryClient: QueryClient) => {
   const client = useRozeniteDevToolsClient<TanStackQueryPluginEventMap>({
@@ -18,4 +19,6 @@ export const useTanStackQueryDevTools = (queryClient: QueryClient) => {
   useSyncTanStackCache(queryClient, client);
 
   useHandleInitialData(queryClient, client);
+
+  useTanStackQueryAgentTools(queryClient);
 };

package/tsconfig.json

@@ -19,6 +19,9 @@
   "include": ["src/**/*", "react-native.ts", "rozenite.config.ts"],
   "exclude": ["node_modules", "dist", "build"],
   "references": [
+    {
+      "path": "../agent-bridge"
+    },
     {
       "path": "../plugin-bridge"
     },

package/dist/react-native.d.ts

@@ -1 +0,0 @@
-export declare let useTanStackQueryDevTools: typeof import('./src/react-native/useTanStackQueryDevTools').useTanStackQueryDevTools;

package/dist/react-native.js

@@ -1,6 +0,0 @@
-let e;
-const o = process.env.NODE_ENV !== "production", s = typeof window > "u";
-o && !s ? e = require("./useTanStackQueryDevTools.js").useTanStackQueryDevTools : e = () => ({ isConnected: !1 });
-export {
-  e as useTanStackQueryDevTools
-};

package/dist/rozenite.config.d.ts

@@ -1,7 +0,0 @@
-declare const _default: {
-    panels: {
-        name: string;
-        source: string;
-    }[];
-};
-export default _default;

package/dist/src/react-native/useHandleDevToolsMessages.d.ts

@@ -1,3 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-import { TanStackQueryPluginClient } from '../shared/messaging';
-export declare const useHandleDevToolsMessages: (queryClient: QueryClient, client: TanStackQueryPluginClient | null) => void;

package/dist/src/react-native/useHandleInitialData.d.ts

@@ -1,3 +0,0 @@
-import { TanStackQueryPluginClient } from '../shared/messaging';
-import { QueryClient } from '@tanstack/react-query';
-export declare const useHandleInitialData: (queryClient: QueryClient, client: TanStackQueryPluginClient | null) => void;

package/dist/src/react-native/useSyncTanStackCache.d.ts

@@ -1,3 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-import { TanStackQueryPluginClient } from '../shared/messaging';
-export declare const useSyncTanStackCache: (queryClient: QueryClient, client: TanStackQueryPluginClient | null) => void;

package/dist/src/react-native/useTanStackQueryDevTools.d.ts

@@ -1,2 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-export declare const useTanStackQueryDevTools: (queryClient: QueryClient) => void;

package/dist/src/shared/dehydrate.d.ts

@@ -1,6 +0,0 @@
-import { Query, Mutation, QueryClient } from '@tanstack/react-query';
-import { SerializableQuery, SerializableMutation, SerializableObserver, SerializableQueryClient } from './types';
-export declare const dehydrateObservers: (query: Query) => SerializableObserver[];
-export declare const dehydrateQuery: (query: Query) => SerializableQuery;
-export declare const dehydrateMutation: (mutation: Mutation) => SerializableMutation;
-export declare const dehydrateQueryClient: (queryClient: QueryClient) => SerializableQueryClient;

package/dist/src/shared/hydrate.d.ts

@@ -1,10 +0,0 @@
-import { QueryClient } from '@tanstack/react-query';
-import { SerializableQuery, SerializableMutation, SerializableQueryClient, SerializableObserver, PartialQueryState } from './types';
-export declare const hydrateQueryClient: (client: QueryClient, dehydratedState: SerializableQueryClient) => void;
-export declare const applyQueryEvent: (queryClient: QueryClient, type: "added" | "updated" | "removed" | "observerAdded" | "observerRemoved" | "observerResultsUpdated" | "observerOptionsUpdated", data: SerializableQuery | PartialQueryState, action?: string) => void;
-export declare const applyPartialQueryState: (queryClient: QueryClient, data: PartialQueryState) => void;
-export declare const applyMutationEvent: (queryClient: QueryClient, type: "added" | "updated" | "removed" | "observerAdded" | "observerRemoved" | "observerResultsUpdated" | "observerOptionsUpdated", data: SerializableMutation) => void;
-export declare const applyQueryObserverEvent: (queryClient: QueryClient, data: {
-    queryHash: string;
-    observers: SerializableObserver[];
-}) => void;

package/dist/src/shared/messaging.d.ts

@@ -1,34 +0,0 @@
-import { RozeniteDevToolsClient } from '@rozenite/plugin-bridge';
-import { DevToolsActionType, SerializableQueryClient, SerializableQuery, SerializableMutation, SerializableObserver, PartialQueryState } from './types';
-export type TanStackQueryPluginEventMap = {
-    'online-status-changed': {
-        online: boolean;
-    };
-    'devtools-action': {
-        type: DevToolsActionType;
-        queryHash: string;
-    };
-    'request-initial-data': unknown;
-    'sync-data': {
-        data: SerializableQueryClient;
-    };
-    'sync-query-event': {
-        type: 'added' | 'removed';
-        data: SerializableQuery;
-    } | {
-        type: 'updated';
-        action?: string;
-        data: SerializableQuery | PartialQueryState;
-    } | {
-        type: 'observerAdded' | 'observerRemoved' | 'observerOptionsUpdated';
-        data: {
-            queryHash: string;
-            observers: SerializableObserver[];
-        };
-    };
-    'sync-mutation-event': {
-        type: 'added' | 'updated' | 'removed' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
-        data: SerializableMutation;
-    };
-};
-export type TanStackQueryPluginClient = RozeniteDevToolsClient<TanStackQueryPluginEventMap>;

package/dist/src/shared/types.d.ts

@@ -1,25 +0,0 @@
-import { QueryKey, MutationState, QueryState, QueryObserverOptions, InfiniteQueryObserverOptions, MutationOptions } from '@tanstack/react-query';
-export type SerializableQuery = {
-    queryHash: string;
-    state: QueryState;
-    queryKey: QueryKey;
-    observers: SerializableObserver[];
-};
-export type PartialQueryState = {
-    queryHash: string;
-    state: Partial<QueryState>;
-};
-export type SerializableMutation = {
-    mutationId: number;
-    options: MutationOptions;
-    state: MutationState;
-};
-export type SerializableObserver = {
-    queryHash: string;
-    options: QueryObserverOptions | InfiniteQueryObserverOptions;
-};
-export type SerializableQueryClient = {
-    queries: SerializableQuery[];
-    mutations: SerializableMutation[];
-};
-export type DevToolsActionType = 'REFETCH' | 'INVALIDATE' | 'RESET' | 'REMOVE' | 'TRIGGER_ERROR' | 'RESTORE_ERROR' | 'TRIGGER_LOADING' | 'RESTORE_LOADING' | 'CLEAR_MUTATION_CACHE' | 'CLEAR_QUERY_CACHE';

package/dist/src/shared/useSyncOnlineStatus.d.ts

@@ -1,2 +0,0 @@
-import { TanStackQueryPluginClient } from './messaging';
-export declare const useSyncOnlineStatus: (client: TanStackQueryPluginClient | null) => void;

package/dist/src/ui/tanstack-query.d.ts

@@ -1 +0,0 @@
-export default function TanStackQueryPanel(): import("react/jsx-runtime").JSX.Element;

package/dist/src/ui/useHandleSyncMessages.d.ts

@@ -1,2 +0,0 @@
-import { TanStackQueryPluginClient } from '../shared/messaging';
-export declare const useHandleSyncMessages: (client: TanStackQueryPluginClient | null) => void;

package/dist/src/ui/useSyncDevToolsEvents.d.ts

@@ -1,2 +0,0 @@
-import { TanStackQueryPluginClient } from '../shared/messaging';
-export declare const useSyncDevToolsEvents: (client: TanStackQueryPluginClient | null) => void;

package/dist/src/ui/useSyncInitialData.d.ts

@@ -1,2 +0,0 @@
-import { TanStackQueryPluginClient } from '../shared/messaging';
-export declare const useSyncInitialData: (client: TanStackQueryPluginClient | null) => void;

package/dist/useTanStackQueryDevTools.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const b=require("@rozenite/plugin-bridge"),y=require("react"),p=require("@tanstack/react-query"),q=require("fast-deep-equal"),S=e=>e&&e.__esModule?e:{default:e},g=S(q),l=e=>{y.useEffect(()=>{if(!e)return;const a=p.onlineManager.subscribe(n=>{e.send("online-status-changed",{online:n})}),c=e.onMessage("online-status-changed",({online:n})=>{p.onlineManager.setOnline(n)});return()=>{a(),c.remove()}},[e])},M=(e,a)=>{y.useEffect(()=>{if(!a)return;const c=a.onMessage("devtools-action",({type:n,queryHash:o})=>{const s=e.getQueryCache().get(o);if(!s){console.warn(`No active query found for hash: ${o}`);return}switch(n){case"TRIGGER_ERROR":{const d=s.options,t=new Error("Unknown error from devtools");s.setState({status:"error",error:t,fetchMeta:{...s.state.fetchMeta,__previousQueryOptions:d}});break}case"RESTORE_ERROR":{e.resetQueries(s);break}case"TRIGGER_LOADING":{if(!s)return;const d=s.options;s.fetch({...d,queryFn:()=>new Promise(()=>{}),gcTime:-1}),s.setState({data:void 0,status:"pending",fetchMeta:{...s.state.fetchMeta,__previousQueryOptions:d}});break}case"RESTORE_LOADING":{const d=s.state,t=s.state.fetchMeta?s.state.fetchMeta.__previousQueryOptions:null;s.cancel({silent:!0}),s.setState({...d,fetchStatus:"idle",fetchMeta:null}),t&&s.fetch(t);break}case"RESET":{e.resetQueries(s);break}case"REMOVE":{e.removeQueries(s);break}case"REFETCH":{s.fetch().catch(()=>{});break}case"INVALIDATE":{e.invalidateQueries(s);break}default:console.warn(`Unknown devtools action: ${n}`)}});return()=>{c.remove()}},[a])},f=e=>e.observers.map(a=>({queryHash:e.queryHash,options:a.options})),h=e=>{const a=f(e);return{state:e.state,queryKey:e.queryKey,queryHash:e.queryHash,observers:a}},v=e=>({mutationId:e.mutationId,state:e.state,options:e.options}),H=e=>({queries:e.getQueryCache().getAll().map(h),mutations:e.getMutationCache().getAll().map(v)}),R=(e,a)=>{const c=y.useRef(new Map),n=y.useMemo(()=>o=>{if(!a||o.type==="observerResultsUpdated")return;if("query"in o){const{query:t,type:u}=o;if(u==="added"||u==="removed"){u==="removed"&&c.current.delete(t.queryHash);const i=h(t);a.send("sync-query-event",{type:u,data:i});return}if(u==="updated"&&"action"in o){const i=o.action;switch(i.type){case"fetch":{const r={queryHash:t.queryHash,state:{status:t.state.status,fetchStatus:t.state.fetchStatus,fetchMeta:t.state.fetchMeta,dataUpdatedAt:t.state.dataUpdatedAt,errorUpdatedAt:t.state.errorUpdatedAt}};a.send("sync-query-event",{type:"updated",action:"fetch",data:r});break}case"success":{const r={queryHash:t.queryHash,state:{status:t.state.status,data:t.state.data,dataUpdatedAt:t.state.dataUpdatedAt,error:t.state.error,errorUpdatedAt:t.state.errorUpdatedAt,fetchStatus:t.state.fetchStatus}};a.send("sync-query-event",{type:"updated",action:"success",data:r});break}case"error":{const r={queryHash:t.queryHash,state:{status:t.state.status,error:t.state.error,errorUpdatedAt:t.state.errorUpdatedAt,fetchStatus:t.state.fetchStatus}};a.send("sync-query-event",{type:"updated",action:"error",data:r});break}case"setState":{const r={queryHash:t.queryHash,state:i.state};a.send("sync-query-event",{type:"updated",action:"setState",data:r});break}case"invalidate":{const r={queryHash:t.queryHash,state:{isInvalidated:t.state.isInvalidated}};a.send("sync-query-event",{type:"updated",action:"invalidate",data:r});break}case"pause":{const r={queryHash:t.queryHash,state:{fetchStatus:t.state.fetchStatus}};a.send("sync-query-event",{type:"updated",action:"pause",data:r});break}case"continue":{const r={queryHash:t.queryHash,state:{fetchStatus:t.state.fetchStatus}};a.send("sync-query-event",{type:"updated",action:"continue",data:r});break}default:{const r=h(t);a.send("sync-query-event",{type:u,data:r})}}return}if(u==="observerAdded"||u==="observerRemoved"||u==="observerOptionsUpdated"){const i=f(t),r=c.current.get(t.queryHash);if(u==="observerOptionsUpdated"&&r&&g.default(r,i))return;c.current.set(t.queryHash,i),a.send("sync-query-event",{type:u,data:{queryHash:t.queryHash,observers:i}});return}}const{mutation:s,type:d}=o;if(s){const t=v(s);a.send("sync-mutation-event",{type:d,data:t})}},[a]);y.useEffect(()=>{if(!a)return;const o=e.getMutationCache().subscribe(n),s=e.getQueryCache().subscribe(n);return()=>{o(),s()}},[a,e,n])},k=(e,a)=>{y.useEffect(()=>{if(!a)return;const c=a.onMessage("request-initial-data",()=>{const n=H(e);a.send("sync-data",{data:n})});return()=>{c.remove()}},[a,e])},O=e=>{const a=b.useRozeniteDevToolsClient({pluginId:"@rozenite/tanstack-query-plugin"});l(a),M(e,a),R(e,a),k(e,a)};exports.useTanStackQueryDevTools=O;