@buoy-gg/react-query 7.0.40 → 7.0.42

package/lib/module/react-query/hooks/useAllQueries.js

@@ -1,114 +1 @@
-"use strict";
-
-import { useEffect, useState, useRef, useMemo, useCallback } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { isStorageQuery } from "../utils/storageQueryUtils";
-
-// React Query DevTools sorting logic - moved outside component for performance
-
-const getStatusRank = q => q.state.fetchStatus !== "idle" ? 0 : !q.getObserversCount() ? 3 : q.isStale() ? 2 : 1;
-const dateSort = (a, b) => a.state.dataUpdatedAt < b.state.dataUpdatedAt ? 1 : -1;
-const statusAndDateSort = (a, b) => {
-  if (getStatusRank(a) === getStatusRank(b)) {
-    return dateSort(a, b);
-  }
-  return getStatusRank(a) > getStatusRank(b) ? 1 : -1;
-};
-
-/**
- * Optimized hook to track all queries with live updates
- * Performance optimizations for mobile:
- * - Filters event types to only relevant ones
- * - Uses lightweight comparison instead of deep equality
- * - Batches updates to reduce re-renders
- * - Memoizes sorted results
- */
-function useAllQueries() {
-  const queryClient = useQueryClient();
-  const [queries, setQueries] = useState(() => {
-    // Initialize with current queries to avoid flash
-    const initial = queryClient.getQueryCache().getAll().filter(query => !isStorageQuery(query.queryKey)).sort(statusAndDateSort);
-    return initial;
-  });
-
-  // Track query states using a Map for O(1) lookups
-  const queryStatesRef = useRef(new Map());
-  const updateTimerRef = useRef(undefined);
-
-  // Memoized callback to check if queries need update
-  const hasQueriesChanged = useCallback(newQueries => {
-    const statesMap = queryStatesRef.current;
-
-    // Quick length check first
-    if (newQueries.length !== statesMap.size) {
-      return true;
-    }
-
-    // Check if any query state has changed
-    for (const query of newQueries) {
-      const prevState = statesMap.get(query.queryHash);
-      if (!prevState) return true;
-
-      // Compare only relevant state properties for rendering
-      if (prevState.dataUpdatedAt !== query.state.dataUpdatedAt || prevState.errorUpdatedAt !== query.state.errorUpdatedAt || prevState.fetchStatus !== query.state.fetchStatus || prevState.status !== query.state.status || prevState.isInvalidated !== query.state.isInvalidated) {
-        return true;
-      }
-    }
-    return false;
-  }, []);
-
-  // Memoized update function
-  const updateQueries = useCallback(() => {
-    const allQueries = queryClient.getQueryCache().getAll();
-
-    // Filter out storage queries
-    const nonStorageQueries = allQueries.filter(query => !isStorageQuery(query.queryKey));
-
-    // Check if update is needed
-    if (hasQueriesChanged(nonStorageQueries)) {
-      // Update states map
-      const newStatesMap = new Map();
-      nonStorageQueries.forEach(q => {
-        newStatesMap.set(q.queryHash, q.state);
-      });
-      queryStatesRef.current = newStatesMap;
-
-      // Sort and update
-      const sortedQueries = [...nonStorageQueries].sort(statusAndDateSort);
-      setQueries(sortedQueries);
-    }
-  }, [queryClient, hasQueriesChanged]);
-  useEffect(() => {
-    // Initial update
-    updateQueries();
-
-    // Subscribe with event filtering for performance
-    const unsubscribe = queryClient.getQueryCache().subscribe(event => {
-      // Only process events that affect query list
-      if (event.type === "added" || event.type === "removed" || event.type === "updated") {
-        // Skip storage queries
-        if ("query" in event && event.query && isStorageQuery(event.query.queryKey)) {
-          return;
-        }
-
-        // Debounce updates to batch rapid changes
-        if (updateTimerRef.current) {
-          clearTimeout(updateTimerRef.current);
-        }
-        updateTimerRef.current = setTimeout(() => {
-          updateQueries();
-        }, 10); // Small delay to batch updates
-      }
-    });
-    return () => {
-      unsubscribe();
-      if (updateTimerRef.current) {
-        clearTimeout(updateTimerRef.current);
-      }
-    };
-  }, [queryClient, updateQueries]);
-
-  // Memoize the final sorted array to prevent unnecessary re-renders
-  return useMemo(() => queries, [queries]);
-}
-export default useAllQueries;
+"use strict";import{useEffect as h,useState as m,useRef as y,useMemo as Q,useCallback as p}from"react";import{useQueryClient as A}from"@tanstack/react-query";import{isStorageQuery as c}from"../utils/storageQueryUtils";const o=t=>t.state.fetchStatus!=="idle"?0:!t.getObserversCount()?3:t.isStale()?2:1;const q=(t,s)=>t.state.dataUpdatedAt<s.state.dataUpdatedAt?1:-1;const S=(t,s)=>{if(o(t)===o(s)){return q(t,s)}return o(t)>o(s)?1:-1};function C(){const t=A();const[s,g]=m(()=>{const u=t.getQueryCache().getAll().filter(e=>!c(e.queryKey)).sort(S);return u});const d=y(new Map);const n=y(void 0);const f=p(u=>{const e=d.current;if(u.length!==e.size){return true}for(const r of u){const a=e.get(r.queryHash);if(!a)return true;if(a.dataUpdatedAt!==r.state.dataUpdatedAt||a.errorUpdatedAt!==r.state.errorUpdatedAt||a.fetchStatus!==r.state.fetchStatus||a.status!==r.state.status||a.isInvalidated!==r.state.isInvalidated){return true}}return false},[]);const i=p(()=>{const u=t.getQueryCache().getAll();const e=u.filter(r=>!c(r.queryKey));if(f(e)){const r=new Map;e.forEach(l=>{r.set(l.queryHash,l.state)});d.current=r;const a=[...e].sort(S);g(a)}},[t,f]);h(()=>{i();const u=t.getQueryCache().subscribe(e=>{if(e.type==="added"||e.type==="removed"||e.type==="updated"){if("query"in e&&e.query&&c(e.query.queryKey)){return}if(n.current){clearTimeout(n.current)}n.current=setTimeout(()=>{i()},10)}});return()=>{u();if(n.current){clearTimeout(n.current)}}},[t,i]);return Q(()=>s,[s])}export default C;

package/lib/module/react-query/hooks/useModalManager.js

@@ -1,175 +1 @@
-"use strict";
-
-import { useState, useEffect } from "react";
-import { useModalPersistence } from "./useModalPersistence";
-import { devToolsStorageKeys } from "@buoy-gg/shared-ui";
-
-/**
- * Custom hook for managing modal states and related query selection
- * Enhanced with persistence following composition principles
- * Restores modal state on app restart
- */
-export function useModalManager() {
-  const [isModalOpen, setIsModalOpen] = useState(false);
-  const [isDebugModalOpen, setIsDebugModalOpen] = useState(false);
-  const [isEnvModalOpen, setIsEnvModalOpen] = useState(false);
-  const [isSentryModalOpen, setIsSentryModalOpen] = useState(false);
-  const [isStorageModalOpen, setIsStorageModalOpen] = useState(false);
-  const [isNetworkModalOpen, setIsNetworkModalOpen] = useState(false);
-  const [selectedQueryKey, setSelectedQueryKey] = useState(undefined);
-  const [selectedSection, setSelectedSection] = useState(null);
-  const [activeFilter, setActiveFilter] = useState(null);
-  const [isStateRestored, setIsStateRestored] = useState(false); // Default to false to prevent clearing state before restoration
-  const [activeTab, setActiveTab] = useState("queries");
-  const [selectedMutationId, setSelectedMutationId] = useState(undefined);
-
-  // Persistence hook for saving/loading modal state
-  const {
-    loadSavedState
-  } = useModalPersistence({
-    storagePrefix: devToolsStorageKeys.modal.state(),
-    isModalOpen,
-    isDebugModalOpen,
-    isEnvModalOpen,
-    isSentryModalOpen,
-    isStorageModalOpen,
-    isNetworkModalOpen,
-    selectedQueryKey,
-    selectedSection,
-    activeFilter,
-    activeTab,
-    selectedMutationId,
-    isStateRestored
-  });
-
-  // Restore saved modal state on component mount
-  useEffect(() => {
-    const restoreState = async () => {
-      // Don't set to false again if already restoring
-      if (isStateRestored) return;
-      try {
-        const savedState = await loadSavedState();
-        if (savedState) {
-          setIsModalOpen(savedState.isModalOpen);
-          setIsDebugModalOpen(savedState.isDebugModalOpen);
-          setIsEnvModalOpen(savedState.isEnvModalOpen || false);
-          setIsSentryModalOpen(savedState.isSentryModalOpen || false);
-          setIsStorageModalOpen(savedState.isStorageModalOpen || false);
-          setIsNetworkModalOpen(savedState.isNetworkModalOpen || false);
-          if (savedState.selectedQueryKey) {
-            try {
-              const queryKey = JSON.parse(savedState.selectedQueryKey);
-              setSelectedQueryKey(queryKey);
-            } catch {
-              // Silently fail if query key can't be parsed
-            }
-          }
-          if (savedState.selectedSection) {
-            setSelectedSection(savedState.selectedSection);
-          }
-          if (savedState.activeFilter) {
-            setActiveFilter(savedState.activeFilter);
-          }
-          if (savedState.activeTab) {
-            setActiveTab(savedState.activeTab);
-          }
-          if (savedState.selectedMutationId) {
-            setSelectedMutationId(Number(savedState.selectedMutationId));
-          }
-        }
-      } catch {
-        // Silently fail if state can't be restored
-      } finally {
-        // Mark restoration as complete
-        setIsStateRestored(true);
-      }
-    };
-    restoreState();
-  }, [isStateRestored, loadSavedState]);
-  const handleModalDismiss = () => {
-    setIsModalOpen(false);
-    setSelectedQueryKey(undefined);
-    // Note: Keep activeFilter when dismissing - user might want to maintain filter on next open
-  };
-  const handleDebugModalDismiss = () => {
-    setIsDebugModalOpen(false);
-    setSelectedSection(null);
-  };
-  const handleQuerySelect = query => {
-    setSelectedQueryKey(query?.queryKey);
-  };
-  const handleQueryPress = () => {
-    setIsModalOpen(true);
-  };
-  const handleStatusPress = () => {
-    setIsDebugModalOpen(true);
-  };
-  const handleEnvPress = () => {
-    setIsEnvModalOpen(true);
-  };
-  const handleSentryPress = () => {
-    setIsSentryModalOpen(true);
-  };
-  const handleStoragePress = () => {
-    setIsStorageModalOpen(true);
-  };
-  const handleEnvModalDismiss = () => {
-    setIsEnvModalOpen(false);
-  };
-  const handleSentryModalDismiss = () => {
-    setIsSentryModalOpen(false);
-  };
-  const handleStorageModalDismiss = () => {
-    setIsStorageModalOpen(false);
-  };
-  const handleNetworkPress = () => {
-    setIsNetworkModalOpen(true);
-  };
-  const handleNetworkModalDismiss = () => {
-    setIsNetworkModalOpen(false);
-  };
-  const handleMutationSelect = mutation => {
-    setSelectedMutationId(mutation?.mutationId);
-  };
-  const handleTabChange = newTab => {
-    if (newTab !== activeTab) {
-      setSelectedQueryKey(undefined);
-      setSelectedMutationId(undefined);
-      // Reset query status filters when switching tabs (they don't apply to storage)
-      setActiveFilter(null);
-    }
-    setActiveTab(newTab);
-  };
-  return {
-    isModalOpen,
-    isDebugModalOpen,
-    isEnvModalOpen,
-    isSentryModalOpen,
-    isStorageModalOpen,
-    isNetworkModalOpen,
-    selectedQueryKey,
-    selectedSection,
-    activeFilter,
-    isStateRestored,
-    activeTab,
-    selectedMutationId,
-    setSelectedSection,
-    setActiveFilter,
-    setActiveTab,
-    handleModalDismiss,
-    handleDebugModalDismiss,
-    handleEnvModalDismiss,
-    handleSentryModalDismiss,
-    handleStorageModalDismiss,
-    handleNetworkModalDismiss,
-    handleQuerySelect,
-    handleQueryPress,
-    handleStatusPress,
-    handleEnvPress,
-    handleSentryPress,
-    handleStoragePress,
-    handleNetworkPress,
-    handleTabChange,
-    handleMutationSelect
-  };
-}
+"use strict";import{useState as t,useEffect as H}from"react";import{useModalPersistence as L}from"./useModalPersistence";import{devToolsStorageKeys as U}from"@buoy-gg/shared-ui";export function useModalManager(){const[p,o]=t(false);const[O,l]=t(false);const[h,d]=t(false);const[v,i]=t(false);const[m,c]=t(false);const[g,r]=t(false);const[I,n]=t(void 0);const[D,u]=t(null);const[b,f]=t(null);const[a,N]=t(false);const[M,S]=t("queries");const[P,y]=t(void 0);const{loadSavedState:K}=L({storagePrefix:U.modal.state(),isModalOpen:p,isDebugModalOpen:O,isEnvModalOpen:h,isSentryModalOpen:v,isStorageModalOpen:m,isNetworkModalOpen:g,selectedQueryKey:I,selectedSection:D,activeFilter:b,activeTab:M,selectedMutationId:P,isStateRestored:a});H(()=>{const s=async()=>{if(a)return;try{const e=await K();if(e){o(e.isModalOpen);l(e.isDebugModalOpen);d(e.isEnvModalOpen||false);i(e.isSentryModalOpen||false);c(e.isStorageModalOpen||false);r(e.isNetworkModalOpen||false);if(e.selectedQueryKey){try{const G=JSON.parse(e.selectedQueryKey);n(G)}catch{}}if(e.selectedSection){u(e.selectedSection)}if(e.activeFilter){f(e.activeFilter)}if(e.activeTab){S(e.activeTab)}if(e.selectedMutationId){y(Number(e.selectedMutationId))}}}catch{}finally{N(true)}};s()},[a,K]);const E=()=>{o(false);n(void 0)};const Q=()=>{l(false);u(null)};const k=s=>{n(s?.queryKey)};const w=()=>{o(true)};const T=()=>{l(true)};const F=()=>{d(true)};const q=()=>{i(true)};const x=()=>{c(true)};const A=()=>{d(false)};const R=()=>{i(false)};const C=()=>{c(false)};const J=()=>{r(true)};const j=()=>{r(false)};const z=s=>{y(s?.mutationId)};const B=s=>{if(s!==M){n(void 0);y(void 0);f(null)}S(s)};return{isModalOpen:p,isDebugModalOpen:O,isEnvModalOpen:h,isSentryModalOpen:v,isStorageModalOpen:m,isNetworkModalOpen:g,selectedQueryKey:I,selectedSection:D,activeFilter:b,isStateRestored:a,activeTab:M,selectedMutationId:P,setSelectedSection:u,setActiveFilter:f,setActiveTab:S,handleModalDismiss:E,handleDebugModalDismiss:Q,handleEnvModalDismiss:A,handleSentryModalDismiss:R,handleStorageModalDismiss:C,handleNetworkModalDismiss:j,handleQuerySelect:k,handleQueryPress:w,handleStatusPress:T,handleEnvPress:F,handleSentryPress:q,handleStoragePress:x,handleNetworkPress:J,handleTabChange:B,handleMutationSelect:z}}

package/lib/module/react-query/hooks/useModalPersistence.js

@@ -1,67 +1 @@
-"use strict";
-
-import { useEffect, useCallback } from "react";
-import { saveModalVisibilityState, loadModalVisibilityState, clearModalVisibilityState } from "../utils/modalStorageOperations";
-/**
- * Hook for persisting modal state following "Extract Reusable Logic" principle
- * Manages saving/loading modal visibility and selection state across app restarts
- */
-export function useModalPersistence({
-  storagePrefix,
-  isModalOpen,
-  isDebugModalOpen,
-  isEnvModalOpen = false,
-  isSentryModalOpen = false,
-  isStorageModalOpen = false,
-  isNetworkModalOpen = false,
-  selectedQueryKey,
-  selectedSection,
-  activeFilter,
-  activeTab,
-  selectedMutationId,
-  isStateRestored
-}) {
-  const saveCurrentState = useCallback(async () => {
-    const state = {
-      isModalOpen,
-      isDebugModalOpen,
-      isEnvModalOpen,
-      isSentryModalOpen,
-      isStorageModalOpen,
-      isNetworkModalOpen,
-      selectedQueryKey: selectedQueryKey ? JSON.stringify(selectedQueryKey) : undefined,
-      selectedSection: selectedSection || undefined,
-      activeFilter: activeFilter || undefined,
-      activeTab: activeTab || undefined,
-      selectedMutationId: selectedMutationId?.toString() || undefined
-    };
-    await saveModalVisibilityState(storagePrefix, state);
-  }, [storagePrefix, isModalOpen, isDebugModalOpen, isEnvModalOpen, isSentryModalOpen, isStorageModalOpen, isNetworkModalOpen, selectedQueryKey, selectedSection, activeFilter, activeTab, selectedMutationId]);
-  const loadSavedState = useCallback(async () => {
-    return await loadModalVisibilityState(storagePrefix);
-  }, [storagePrefix]);
-  const clearSavedState = useCallback(async () => {
-    await clearModalVisibilityState(storagePrefix);
-  }, [storagePrefix]);
-
-  // Auto-save state when modal state changes
-  useEffect(() => {
-    // Don't persist anything until state restoration is complete to avoid race condition
-    if (!isStateRestored) {
-      return;
-    }
-
-    // Only save if a modal is actually open to avoid saving closed state
-    if (isModalOpen || isDebugModalOpen || isEnvModalOpen || isSentryModalOpen || isStorageModalOpen || isNetworkModalOpen) {
-      saveCurrentState();
-    } else {
-      // Clear saved state when all modals are closed
-      clearSavedState();
-    }
-  }, [isModalOpen, isDebugModalOpen, isEnvModalOpen, isSentryModalOpen, isStorageModalOpen, isNetworkModalOpen, selectedQueryKey, selectedSection, activeFilter, activeTab, selectedMutationId, isStateRestored, saveCurrentState, clearSavedState]);
-  return {
-    saveCurrentState,
-    loadSavedState,
-    clearSavedState
-  };
-}
+"use strict";import{useEffect as z,useCallback as n}from"react";import{saveModalVisibilityState as A,loadModalVisibilityState as B,clearModalVisibilityState as G}from"../utils/modalStorageOperations";export function useModalPersistence({storagePrefix:f,isModalOpen:t,isDebugModalOpen:u,isEnvModalOpen:c=false,isSentryModalOpen:m=false,isStorageModalOpen:a=false,isNetworkModalOpen:V=false,selectedQueryKey:C,selectedSection:S,activeFilter:i,activeTab:J,selectedMutationId:b,isStateRestored:q}){const h=n(async()=>{const y={isModalOpen:t,isDebugModalOpen:u,isEnvModalOpen:c,isSentryModalOpen:m,isStorageModalOpen:a,isNetworkModalOpen:V,selectedQueryKey:C?JSON.stringify(C):void 0,selectedSection:S||void 0,activeFilter:i||void 0,activeTab:J||void 0,selectedMutationId:b?.toString()||void 0};await A(f,y)},[f,t,u,c,m,a,V,C,S,i,J,b]);const w=n(async()=>{return await B(f)},[f]);const j=n(async()=>{await G(f)},[f]);z(()=>{if(!q){return}if(t||u||c||m||a||V){h()}else{j()}},[t,u,c,m,a,V,C,S,i,J,b,q,h,j]);return{saveCurrentState:h,loadSavedState:w,clearSavedState:j}}

package/lib/module/react-query/hooks/useMutationActionButtons.js

@@ -1,17 +1 @@
-"use strict";
-
-import { useMemo } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-/**
- * Supplies action button metadata for a selected mutation. Currently exposes a remove control but
- * centralizes logic so future actions stay consistent across the UI.
- */
-export function useMutationActionButtons(selectedMutation) {
-  const queryClient = useQueryClient();
-  return useMemo(() => [{
-    label: "Remove",
-    variant: "remove",
-    disabled: false,
-    onPress: () => queryClient.getMutationCache().remove(selectedMutation)
-  }], [selectedMutation, queryClient]);
-}
+"use strict";import{useMemo as o}from"react";import{useQueryClient as r}from"@tanstack/react-query";export function useMutationActionButtons(e){const t=r();return o(()=>[{label:"Remove",variant:"remove",disabled:false,onPress:()=>t.getMutationCache().remove(e)}],[e,t])}

package/lib/module/react-query/hooks/useQueryStatusCounts.js

@@ -1,112 +1 @@
-"use strict";
-
-import { useEffect, useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { getQueryStatusLabel } from "../utils/getQueryStatusLabel";
-/**
- * Tracks how many queries fall into each status bucket (fresh, stale, fetching, etc.). Uses
- * cache subscriptions to stay up to date without polling.
- */
-function useQueryStatusCounts() {
-  const queryClient = useQueryClient();
-  const [counts, setCounts] = useState({
-    fresh: 0,
-    stale: 0,
-    fetching: 0,
-    paused: 0,
-    inactive: 0,
-    error: 0,
-    disabled: 0
-  });
-  useEffect(() => {
-    const updateCounts = () => {
-      const allQueries = queryClient.getQueryCache().getAll();
-      const newCounts = allQueries.reduce((acc, query) => {
-        const status = getQueryStatusLabel(query);
-        acc[status] = (acc[status] || 0) + 1;
-        return acc;
-      }, {
-        fresh: 0,
-        stale: 0,
-        fetching: 0,
-        paused: 0,
-        inactive: 0,
-        error: 0,
-        disabled: 0
-      });
-      setTimeout(() => setCounts(newCounts), 0);
-    };
-
-    // Perform an initial update
-    updateCounts();
-
-    // Subscribe to the query cache to run updates on changes
-    const unsubscribe = queryClient.getQueryCache().subscribe(updateCounts);
-
-    // Cleanup the subscription when the component unmounts
-    return () => unsubscribe();
-  }, [queryClient]);
-  return counts;
-}
-export default useQueryStatusCounts;
-
-// Mutation status counts hook
-
-/**
- * Companion hook for query status counts that groups mutations by status and pause state.
- */
-export function useMutationStatusCounts() {
-  const queryClient = useQueryClient();
-  const [counts, setCounts] = useState({
-    pending: 0,
-    success: 0,
-    error: 0,
-    paused: 0,
-    idle: 0
-  });
-  useEffect(() => {
-    const updateCounts = () => {
-      const allMutations = queryClient.getMutationCache().getAll();
-      const newCounts = allMutations.reduce((acc, mutation) => {
-        const status = mutation.state.status;
-        const isPaused = mutation.state.isPaused;
-        if (isPaused) {
-          acc.paused++;
-        } else {
-          switch (status) {
-            case "idle":
-              acc.idle++;
-              break;
-            case "pending":
-              acc.pending++;
-              break;
-            case "success":
-              acc.success++;
-              break;
-            case "error":
-              acc.error++;
-              break;
-          }
-        }
-        return acc;
-      }, {
-        pending: 0,
-        success: 0,
-        error: 0,
-        paused: 0,
-        idle: 0
-      });
-      setTimeout(() => setCounts(newCounts), 0);
-    };
-
-    // Perform an initial update
-    updateCounts();
-
-    // Subscribe to the mutation cache to run updates on changes
-    const unsubscribe = queryClient.getMutationCache().subscribe(updateCounts);
-
-    // Cleanup the subscription when the component unmounts
-    return () => unsubscribe();
-  }, [queryClient]);
-  return counts;
-}
+"use strict";import{useEffect as d,useState as l}from"react";import{useQueryClient as p}from"@tanstack/react-query";import{getQueryStatusLabel as C}from"../utils/getQueryStatusLabel";function f(){const t=p();const[n,o]=l({fresh:0,stale:0,fetching:0,paused:0,inactive:0,error:0,disabled:0});d(()=>{const s=()=>{const a=t.getQueryCache().getAll();const c=a.reduce((e,u)=>{const r=C(u);e[r]=(e[r]||0)+1;return e},{fresh:0,stale:0,fetching:0,paused:0,inactive:0,error:0,disabled:0});setTimeout(()=>o(c),0)};s();const i=t.getQueryCache().subscribe(s);return()=>i()},[t]);return n}export default f;export function useMutationStatusCounts(){const t=p();const[n,o]=l({pending:0,success:0,error:0,paused:0,idle:0});d(()=>{const s=()=>{const a=t.getMutationCache().getAll();const c=a.reduce((e,u)=>{const r=u.state.status;const b=u.state.isPaused;if(b){e.paused++}else{switch(r){case"idle":e.idle++;break;case"pending":e.pending++;break;case"success":e.success++;break;case"error":e.error++;break}}return e},{pending:0,success:0,error:0,paused:0,idle:0});setTimeout(()=>o(c),0)};s();const i=t.getMutationCache().subscribe(s);return()=>i()},[t]);return n}

package/lib/module/react-query/hooks/useReactQueryState.js

@@ -1,20 +1 @@
-"use strict";
-
-/**
- * Custom hook for getting React Query state information
- * Separated from UI concerns following composition principles
- */
-export function useReactQueryState(queryClient) {
-  const getReactBuoySubtitle = () => {
-    try {
-      const allQueries = queryClient.getQueryCache().getAll();
-      const allMutations = queryClient.getMutationCache().getAll();
-      return `${allQueries.length} queries • ${allMutations.length} mutations`;
-    } catch {
-      return "Data management & cache inspector";
-    }
-  };
-  return {
-    getReactBuoySubtitle
-  };
-}
+"use strict";export function useReactQueryState(t){const e=()=>{try{const a=t.getQueryCache().getAll();const n=t.getMutationCache().getAll();return`${a.length} queries \u2022 ${n.length} mutations`}catch{return"Data management & cache inspector"}};return{getReactBuoySubtitle:e}}

package/lib/module/react-query/hooks/useSelectedMutation.js

@@ -1,27 +1 @@
-"use strict";
-
-import { useEffect, useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-
-/**
- * Watches the mutation cache for a specific mutation id. Useful when the UI needs to follow
- * mutation lifecycle events (loading, success, error) for a focused inspection panel.
- */
-export function useGetMutationById(mutationId) {
-  const queryClient = useQueryClient();
-  const [selectedMutation, setSelectedMutation] = useState(undefined);
-  useEffect(() => {
-    const updateSelectedMutation = () => {
-      if (mutationId !== undefined) {
-        const mutation = queryClient.getMutationCache().getAll().find(m => m.mutationId === mutationId);
-        setSelectedMutation(mutation);
-      } else {
-        setSelectedMutation(undefined);
-      }
-    };
-    setTimeout(updateSelectedMutation, 0);
-    const unsubscribe = queryClient.getMutationCache().subscribe(updateSelectedMutation);
-    return () => unsubscribe();
-  }, [queryClient, mutationId]);
-  return selectedMutation;
-}
+"use strict";import{useEffect as r,useState as d}from"react";import{useQueryClient as a}from"@tanstack/react-query";export function useGetMutationById(e){const t=a();const[i,n]=d(void 0);r(()=>{const u=()=>{if(e!==void 0){const o=t.getMutationCache().getAll().find(c=>c.mutationId===e);n(o)}else{n(void 0)}};setTimeout(u,0);const s=t.getMutationCache().subscribe(u);return()=>s()},[t,e]);return i}

package/lib/module/react-query/hooks/useSelectedQuery.js

@@ -1,92 +1 @@
-"use strict";
-
-import { useEffect, useState, useRef } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-
-/**
- * Custom hook to track a single query by its queryKey with live updates
- * Optimized to only re-render when the specific query changes
- */
-
-/**
- * Returns a single query instance matching the provided key and resubscribes whenever the cache
- * entry changes. Ideal for detail panes where live updates are required without scanning the
- * entire query cache.
- */
-export function useGetQueryByQueryKey(queryKey) {
-  const {
-    query
-  } = useGetQueryByQueryKeyWithVersion(queryKey);
-  return query;
-}
-
-/**
- * Returns a single query instance with a version number that increments on each cache update.
- * Use the version as a dependency or key to ensure child components re-render when query state changes.
- *
- * This is necessary because React Query mutates the Query object in place, so React's
- * shallow comparison won't detect changes to nested properties like query.state.status.
- */
-export function useGetQueryByQueryKeyWithVersion(queryKey) {
-  const queryClient = useQueryClient();
-  const [queryState, setQueryState] = useState({
-    query: undefined,
-    version: 0
-  });
-  const queryHashRef = useRef(undefined);
-  useEffect(() => {
-    if (!queryKey) {
-      setQueryState({
-        query: undefined,
-        version: 0
-      });
-      queryHashRef.current = undefined;
-      return;
-    }
-
-    // Get initial query state
-    const query = queryClient.getQueryCache().find({
-      queryKey,
-      exact: true
-    });
-    setQueryState({
-      query,
-      version: 0
-    });
-
-    // Store the stringified queryKey for comparison
-    const queryKeyString = JSON.stringify(queryKey);
-    queryHashRef.current = queryKeyString;
-
-    // Subscribe to query cache changes but only update if our specific query changed
-    const unsubscribe = queryClient.getQueryCache().subscribe(event => {
-      // Only process events for our specific query
-      if (event.type === "updated" || event.type === "added" || event.type === "removed") {
-        if ("query" in event && event.query) {
-          // Check if the event is for our query by comparing the stringified keys
-          const eventQueryKeyString = JSON.stringify(event.query.queryKey);
-          const isOurQuery = eventQueryKeyString === queryHashRef.current;
-          if (isOurQuery) {
-            if (event.type === "removed") {
-              setQueryState({
-                query: undefined,
-                version: 0
-              });
-            } else {
-              // For 'updated' and 'added' events, use the query from the event
-              // Update both the query and increment version to force re-renders
-              setQueryState(prev => ({
-                query: event.query,
-                version: prev.version + 1
-              }));
-            }
-          }
-        }
-      }
-    });
-
-    // Cleanup subscription when component unmounts
-    return () => unsubscribe();
-  }, [queryClient, queryKey]);
-  return queryState;
-}
+"use strict";import{useEffect as q,useState as Q,useRef as a}from"react";import{useQueryClient as p}from"@tanstack/react-query";export function useGetQueryByQueryKey(r){const{query:u}=useGetQueryByQueryKeyWithVersion(r);return u}export function useGetQueryByQueryKeyWithVersion(r){const u=p();const[i,t]=Q({query:void 0,version:0});const n=a(void 0);q(()=>{if(!r){t({query:void 0,version:0});n.current=void 0;return}const s=u.getQueryCache().find({queryKey:r,exact:true});t({query:s,version:0});const y=JSON.stringify(r);n.current=y;const o=u.getQueryCache().subscribe(e=>{if(e.type==="updated"||e.type==="added"||e.type==="removed"){if("query"in e&&e.query){const c=JSON.stringify(e.query.queryKey);const f=c===n.current;if(f){if(e.type==="removed"){t({query:void 0,version:0})}else{t(d=>({query:e.query,version:d.version+1}))}}}}});return()=>o()},[u,r]);return i}

package/lib/module/react-query/hooks/useStorageQueryCounts.js

@@ -1,25 +1 @@
-"use strict";
-
-import { useMemo } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { getStorageQueryCounts } from "../utils/getStorageQueryCounts";
-
-/**
- * Hook to get storage query counts with proper memoization
- * Following rule3 - Component Composition principles:
- * - Extract Reusable Logic: Dedicated hook for storage counting
- * - Rigor and Justification: Proper memoization only where proven necessary
- * - Stable references: useMemo with correct dependencies to prevent infinite loops
- */
-export function useStorageQueryCounts() {
-  const queryClient = useQueryClient();
-
-  // Memoize counts based on query cache state changes
-  // This prevents infinite re-renders by stabilizing the counts object
-  const counts = useMemo(() => {
-    const allQueries = queryClient.getQueryCache().getAll();
-    return getStorageQueryCounts(allQueries);
-  }, [queryClient]); // Depend on queryClient, not the result of getAll()
-
-  return counts;
-}
+"use strict";import{useMemo as o}from"react";import{useQueryClient as u}from"@tanstack/react-query";import{getStorageQueryCounts as n}from"../utils/getStorageQueryCounts";export function useStorageQueryCounts(){const e=u();const t=o(()=>{const r=e.getQueryCache().getAll();return n(r)},[e]);return t}