npm - @rozenite/tanstack-query-plugin - Versions diffs - 2.1.0 → 2.3.0 - Mend

@rozenite/tanstack-query-plugin 2.1.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/dist/devtools/tanstack-query.html CHANGED Viewed

@@ -22,7 +22,7 @@
     <script>
       var __ROZENITE_PANEL__ = true;
     </script>
-    <script type="module" crossorigin src="../devtools/assets/tanstack-query-CbF_imft.js"></script>
+    <script type="module" crossorigin src="../devtools/assets/tanstack-query-Bk8rHBM2.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/react-native/cjs/package.json ADDED Viewed

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/react-native/cjs/react-native.js ADDED Viewed

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTanStackQueryDevTools = void 0;
+const isDev = process.env.NODE_ENV !== 'production';
+const isServer = typeof window === 'undefined' && typeof lynx === 'undefined';
+if (isDev && !isServer) {
+    exports.useTanStackQueryDevTools =
+        require('./src/react-native/useTanStackQueryDevTools').useTanStackQueryDevTools;
+}
+else {
+    exports.useTanStackQueryDevTools = () => ({ isConnected: false });
+}

package/dist/react-native/cjs/src/react-native/agent/tanstack-query-agent.js ADDED Viewed

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTanStackQueryAgentController = exports.buildTanStackQueryCacheSummary = exports.TANSTACK_QUERY_AGENT_TOOLS = exports.clearMutationCacheTool = exports.getMutationDetailsTool = exports.listMutationsTool = exports.clearQueryCacheTool = exports.removeQueryTool = exports.resetQueryTool = exports.invalidateQueryTool = exports.setQueryErrorTool = exports.setQueryLoadingTool = exports.refetchQueryTool = exports.getQueryDetailsTool = exports.listQueriesTool = exports.setOnlineStatusTool = exports.getOnlineStatusTool = exports.getCacheSummaryTool = exports.serializeForAgent = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const devtools_actions_1 = require("../devtools-actions");
+const agent_tools_1 = require("../../shared/agent-tools");
+const DEFAULT_PAGE_LIMIT = 20;
+const MAX_PAGE_LIMIT = 100;
+const isPlainObject = (value) => {
+    return !!value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;
+};
+const serializeForAgent = (value, seen = new WeakSet()) => {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : String(value);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        return `[non-serializable:${typeof value}]`;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack ?? null,
+            cause: (0, exports.serializeForAgent)(value.cause, seen),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => (0, exports.serializeForAgent)(item, seen));
+    }
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(value).map((item) => typeof item === 'number' ? item : Number(item));
+    }
+    if (value instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(value));
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) {
+            return '[circular]';
+        }
+        seen.add(value);
+        if (!isPlainObject(value)) {
+            return `[non-serializable:${value.constructor?.name ?? 'Object'}]`;
+        }
+        const entries = Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            (0, exports.serializeForAgent)(nestedValue, seen),
+        ]);
+        return Object.fromEntries(entries);
+    }
+    return String(value);
+};
+exports.serializeForAgent = serializeForAgent;
+const sanitizeLimit = (limit) => {
+    if (typeof limit !== 'number' ||
+        !Number.isFinite(limit) ||
+        !Number.isInteger(limit) ||
+        limit < 1) {
+        return DEFAULT_PAGE_LIMIT;
+    }
+    return Math.min(limit, MAX_PAGE_LIMIT);
+};
+const encodeCursor = (kind, generation, offset) => {
+    return `${kind}:${generation}:${offset}`;
+};
+const decodeCursor = (cursor, kind, generation) => {
+    const [cursorKind, rawGeneration, rawOffset] = cursor.split(':', 3);
+    if (cursorKind !== kind || !rawGeneration || !rawOffset) {
+        throw new Error('Cursor does not match the requested listing. Run the command again.');
+    }
+    const cursorGeneration = Number(rawGeneration);
+    const offset = Number(rawOffset);
+    if (!Number.isInteger(cursorGeneration) || cursorGeneration !== generation) {
+        throw new Error('Cursor does not match the requested listing. Run the command again.');
+    }
+    if (!Number.isInteger(offset) || offset < 0) {
+        throw new Error('Cursor is invalid. Run the command again.');
+    }
+    return offset;
+};
+const paginate = (rows, kind, generation, input) => {
+    const limit = sanitizeLimit(input.limit);
+    const startIndex = input.cursor ? decodeCursor(input.cursor, kind, generation) : 0;
+    const endIndex = Math.min(startIndex + limit, rows.length);
+    const hasMore = endIndex < rows.length;
+    return {
+        items: rows.slice(startIndex, endIndex),
+        page: {
+            limit,
+            hasMore,
+            ...(hasMore ? { nextCursor: encodeCursor(kind, generation, endIndex) } : {}),
+        },
+    };
+};
+exports.getCacheSummaryTool = agent_tools_1.tanstackQueryToolDefinitions.getCacheSummary;
+exports.getOnlineStatusTool = agent_tools_1.tanstackQueryToolDefinitions.getOnlineStatus;
+exports.setOnlineStatusTool = agent_tools_1.tanstackQueryToolDefinitions.setOnlineStatus;
+exports.listQueriesTool = agent_tools_1.tanstackQueryToolDefinitions.listQueries;
+exports.getQueryDetailsTool = agent_tools_1.tanstackQueryToolDefinitions.getQueryDetails;
+exports.refetchQueryTool = agent_tools_1.tanstackQueryToolDefinitions.refetchQuery;
+exports.setQueryLoadingTool = agent_tools_1.tanstackQueryToolDefinitions.setQueryLoading;
+exports.setQueryErrorTool = agent_tools_1.tanstackQueryToolDefinitions.setQueryError;
+exports.invalidateQueryTool = agent_tools_1.tanstackQueryToolDefinitions.invalidateQuery;
+exports.resetQueryTool = agent_tools_1.tanstackQueryToolDefinitions.resetQuery;
+exports.removeQueryTool = agent_tools_1.tanstackQueryToolDefinitions.removeQuery;
+exports.clearQueryCacheTool = agent_tools_1.tanstackQueryToolDefinitions.clearQueryCache;
+exports.listMutationsTool = agent_tools_1.tanstackQueryToolDefinitions.listMutations;
+exports.getMutationDetailsTool = agent_tools_1.tanstackQueryToolDefinitions.getMutationDetails;
+exports.clearMutationCacheTool = agent_tools_1.tanstackQueryToolDefinitions.clearMutationCache;
+exports.TANSTACK_QUERY_AGENT_TOOLS = Object.values(agent_tools_1.tanstackQueryToolDefinitions);
+const pickObserverOptionsSummary = (options) => {
+    if (!options) {
+        return null;
+    }
+    return {
+        enabled: (0, exports.serializeForAgent)(options.enabled),
+        networkMode: (0, exports.serializeForAgent)(options.networkMode),
+        staleTime: (0, exports.serializeForAgent)(options.staleTime),
+        gcTime: (0, exports.serializeForAgent)(options.gcTime),
+        retry: (0, exports.serializeForAgent)(options.retry),
+        retryDelay: (0, exports.serializeForAgent)(options.retryDelay),
+        refetchInterval: (0, exports.serializeForAgent)(options.refetchInterval),
+        refetchOnMount: (0, exports.serializeForAgent)(options.refetchOnMount),
+        refetchOnReconnect: (0, exports.serializeForAgent)(options.refetchOnReconnect),
+        refetchOnWindowFocus: (0, exports.serializeForAgent)(options.refetchOnWindowFocus),
+        subscribed: (0, exports.serializeForAgent)(options.subscribed),
+        meta: (0, exports.serializeForAgent)(options.meta),
+        hasQueryFn: typeof options.queryFn === 'function',
+        hasSelect: typeof options.select === 'function',
+        hasPlaceholderData: 'placeholderData' in options,
+        hasInitialData: 'initialData' in options,
+    };
+};
+const pickMutationOptionsSummary = (options) => {
+    return {
+        mutationKey: (0, exports.serializeForAgent)(options.mutationKey),
+        networkMode: (0, exports.serializeForAgent)(options.networkMode),
+        gcTime: (0, exports.serializeForAgent)(options.gcTime),
+        retry: (0, exports.serializeForAgent)(options.retry),
+        retryDelay: (0, exports.serializeForAgent)(options.retryDelay),
+        meta: (0, exports.serializeForAgent)(options.meta),
+        scope: (0, exports.serializeForAgent)(options.scope),
+        hasMutationFn: typeof options.mutationFn === 'function',
+        hasOnMutate: typeof options.onMutate === 'function',
+        hasOnSuccess: typeof options.onSuccess === 'function',
+        hasOnError: typeof options.onError === 'function',
+        hasOnSettled: typeof options.onSettled === 'function',
+    };
+};
+const getQuerySortTimestamp = (query) => {
+    return Math.max(query.state.dataUpdatedAt, query.state.errorUpdatedAt);
+};
+const compareQueries = (a, b) => {
+    return (getQuerySortTimestamp(b) - getQuerySortTimestamp(a) ||
+        b.getObserversCount() - a.getObserversCount() ||
+        String(b.queryHash).localeCompare(String(a.queryHash)));
+};
+const compareMutations = (a, b) => {
+    return b.state.submittedAt - a.state.submittedAt || b.mutationId - a.mutationId;
+};
+const getQuerySummary = (query) => {
+    return {
+        queryHash: query.queryHash,
+        queryKey: (0, exports.serializeForAgent)(query.queryKey),
+        status: query.state.status,
+        fetchStatus: query.state.fetchStatus,
+        observersCount: query.getObserversCount(),
+        isInvalidated: query.state.isInvalidated,
+        dataUpdatedAt: query.state.dataUpdatedAt,
+        errorUpdatedAt: query.state.errorUpdatedAt,
+        hasData: query.state.data !== undefined,
+        hasError: query.state.error != null,
+    };
+};
+const getMutationStatus = (state) => {
+    return state.status;
+};
+const getMutationSummary = (mutation) => {
+    return {
+        mutationId: mutation.mutationId,
+        mutationKey: (0, exports.serializeForAgent)(mutation.options.mutationKey),
+        status: getMutationStatus(mutation.state),
+        isPaused: mutation.state.isPaused,
+        submittedAt: mutation.state.submittedAt,
+        failureCount: mutation.state.failureCount,
+        hasData: mutation.state.data !== undefined,
+        hasError: mutation.state.error != null,
+    };
+};
+const resolveQuery = (queryClient, queryHash) => {
+    const query = queryClient.getQueryCache().get(queryHash);
+    if (!query) {
+        const available = queryClient
+            .getQueryCache()
+            .getAll()
+            .map((entry) => entry.queryHash)
+            .join(', ');
+        throw new Error(`Unknown queryHash "${queryHash}". Available: ${available || '(none)'}`);
+    }
+    return query;
+};
+const resolveMutation = (queryClient, mutationId) => {
+    const mutation = queryClient
+        .getMutationCache()
+        .getAll()
+        .find((entry) => entry.mutationId === mutationId);
+    if (!mutation) {
+        const available = queryClient
+            .getMutationCache()
+            .getAll()
+            .map((entry) => entry.mutationId)
+            .join(', ');
+        throw new Error(`Unknown mutationId "${mutationId}". Available: ${available || '(none)'}`);
+    }
+    return mutation;
+};
+const buildTanStackQueryCacheSummary = (queryClient) => {
+    const queries = queryClient.getQueryCache().getAll();
+    const mutations = queryClient.getMutationCache().getAll();
+    return {
+        online: react_query_1.onlineManager.isOnline(),
+        queries: {
+            total: queries.length,
+            active: queries.filter((query) => query.getObserversCount() > 0).length,
+            fetching: queries.filter((query) => query.state.fetchStatus === 'fetching').length,
+            pending: queries.filter((query) => query.state.status === 'pending').length,
+            success: queries.filter((query) => query.state.status === 'success').length,
+            error: queries.filter((query) => query.state.status === 'error').length,
+            invalidated: queries.filter((query) => query.state.isInvalidated).length,
+        },
+        mutations: {
+            total: mutations.length,
+            pending: mutations.filter((mutation) => mutation.state.status === 'pending').length,
+            success: mutations.filter((mutation) => mutation.state.status === 'success').length,
+            error: mutations.filter((mutation) => mutation.state.status === 'error').length,
+            paused: mutations.filter((mutation) => mutation.state.isPaused).length,
+        },
+    };
+};
+exports.buildTanStackQueryCacheSummary = buildTanStackQueryCacheSummary;
+const createTanStackQueryAgentController = (queryClient) => {
+    const cursorState = {
+        queriesGeneration: 0,
+        mutationsGeneration: 0,
+    };
+    return {
+        handleQueryCacheEvent(event) {
+            if (event.type === 'added' || event.type === 'removed') {
+                cursorState.queriesGeneration += 1;
+            }
+        },
+        handleMutationCacheEvent(event) {
+            if (event.type === 'added' || event.type === 'removed') {
+                cursorState.mutationsGeneration += 1;
+            }
+        },
+        getCacheSummary() {
+            return (0, exports.buildTanStackQueryCacheSummary)(queryClient);
+        },
+        getOnlineStatus() {
+            return {
+                online: react_query_1.onlineManager.isOnline(),
+            };
+        },
+        setOnlineStatus({ online }) {
+            react_query_1.onlineManager.setOnline(online);
+            return {
+                online: react_query_1.onlineManager.isOnline(),
+            };
+        },
+        listQueries(input = {}) {
+            const queries = [...queryClient.getQueryCache().getAll()].sort(compareQueries);
+            return {
+                ...(0, exports.buildTanStackQueryCacheSummary)(queryClient),
+                total: queries.length,
+                ...paginate(queries.map(getQuerySummary), 'queries', cursorState.queriesGeneration, input),
+            };
+        },
+        getQueryDetails({ queryHash }) {
+            const query = resolveQuery(queryClient, queryHash);
+            return {
+                summary: (0, exports.buildTanStackQueryCacheSummary)(queryClient),
+                query: {
+                    ...getQuerySummary(query),
+                    data: (0, exports.serializeForAgent)(query.state.data),
+                    error: (0, exports.serializeForAgent)(query.state.error),
+                    observers: query.observers.map((observer) => ({
+                        queryHash: query.queryHash,
+                        options: pickObserverOptionsSummary(observer.options),
+                    })),
+                },
+            };
+        },
+        async refetchQuery({ queryHash }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'REFETCH',
+                queryHash,
+            });
+        },
+        async setQueryLoading({ queryHash, enabled }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: enabled ? 'TRIGGER_LOADING' : 'RESTORE_LOADING',
+                queryHash,
+            });
+        },
+        async setQueryError({ queryHash, enabled }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: enabled ? 'TRIGGER_ERROR' : 'RESTORE_ERROR',
+                queryHash,
+            });
+        },
+        async invalidateQuery({ queryHash }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'INVALIDATE',
+                queryHash,
+            });
+        },
+        async resetQuery({ queryHash }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'RESET',
+                queryHash,
+            });
+        },
+        async removeQuery({ queryHash }) {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'REMOVE',
+                queryHash,
+            });
+        },
+        async clearQueryCache() {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'CLEAR_QUERY_CACHE',
+            });
+        },
+        listMutations(input = {}) {
+            const mutations = [...queryClient.getMutationCache().getAll()].sort(compareMutations);
+            return {
+                ...(0, exports.buildTanStackQueryCacheSummary)(queryClient),
+                total: mutations.length,
+                ...paginate(mutations.map(getMutationSummary), 'mutations', cursorState.mutationsGeneration, input),
+            };
+        },
+        getMutationDetails({ mutationId }) {
+            const mutation = resolveMutation(queryClient, mutationId);
+            return {
+                summary: (0, exports.buildTanStackQueryCacheSummary)(queryClient),
+                mutation: {
+                    ...getMutationSummary(mutation),
+                    variables: (0, exports.serializeForAgent)(mutation.state.variables),
+                    data: (0, exports.serializeForAgent)(mutation.state.data),
+                    error: (0, exports.serializeForAgent)(mutation.state.error),
+                    context: (0, exports.serializeForAgent)(mutation.state.context),
+                    failureReason: (0, exports.serializeForAgent)(mutation.state.failureReason),
+                    options: pickMutationOptionsSummary(mutation.options),
+                },
+            };
+        },
+        async clearMutationCache() {
+            return (0, devtools_actions_1.applyTanStackQueryDevtoolsAction)(queryClient, {
+                type: 'CLEAR_MUTATION_CACHE',
+            });
+        },
+    };
+};
+exports.createTanStackQueryAgentController = createTanStackQueryAgentController;

package/dist/react-native/cjs/src/react-native/agent/useTanStackQueryAgentTools.js ADDED Viewed

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTanStackQueryAgentTools = void 0;
+const react_1 = require("react");
+const agent_bridge_1 = require("@rozenite/agent-bridge");
+const tanstack_query_agent_1 = require("./tanstack-query-agent");
+const agent_tools_1 = require("../../shared/agent-tools");
+const useTanStackQueryAgentTools = (queryClient) => {
+    const controller = (0, react_1.useMemo)(() => (0, tanstack_query_agent_1.createTanStackQueryAgentController)(queryClient), [queryClient]);
+    (0, react_1.useEffect)(() => {
+        const unsubscribeQueryCache = queryClient
+            .getQueryCache()
+            .subscribe((event) => controller.handleQueryCacheEvent(event));
+        const unsubscribeMutationCache = queryClient
+            .getMutationCache()
+            .subscribe((event) => controller.handleMutationCacheEvent(event));
+        return () => {
+            unsubscribeQueryCache();
+            unsubscribeMutationCache();
+        };
+    }, [controller, queryClient]);
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.getCacheSummary,
+        handler: () => controller.getCacheSummary(),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.getOnlineStatus,
+        handler: () => controller.getOnlineStatus(),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.setOnlineStatus,
+        handler: (input) => controller.setOnlineStatus(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.listQueries,
+        handler: (input = {}) => controller.listQueries(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.getQueryDetails,
+        handler: (input) => controller.getQueryDetails(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.refetchQuery,
+        handler: (input) => controller.refetchQuery(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.setQueryLoading,
+        handler: (input) => controller.setQueryLoading(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.setQueryError,
+        handler: (input) => controller.setQueryError(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.invalidateQuery,
+        handler: (input) => controller.invalidateQuery(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.resetQuery,
+        handler: (input) => controller.resetQuery(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.removeQuery,
+        handler: (input) => controller.removeQuery(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.clearQueryCache,
+        handler: () => controller.clearQueryCache(),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.listMutations,
+        handler: (input = {}) => controller.listMutations(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.getMutationDetails,
+        handler: (input) => controller.getMutationDetails(input),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.tanstackQueryToolDefinitions.clearMutationCache,
+        handler: () => controller.clearMutationCache(),
+    });
+};
+exports.useTanStackQueryAgentTools = useTanStackQueryAgentTools;

package/dist/react-native/cjs/src/react-native/devtools-actions.js ADDED Viewed

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTanStackQueryDevtoolsAction = void 0;
+const getActiveQuery = (queryClient, queryHash) => {
+    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;
+};
+const applyTanStackQueryDevtoolsAction = async (queryClient, input) => {
+    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 'SET_QUERY_DATA': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            queryClient.setQueryData(activeQuery.queryKey, input.metadata?.data);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        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.__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,
+            };
+        }
+    }
+};
+exports.applyTanStackQueryDevtoolsAction = applyTanStackQueryDevtoolsAction;