tanstack-cacher 1.6.1 → 1.6.2

package/index.d.ts

@@ -8,6 +8,7 @@ interface PaginationConfig {
     totalPagesPath?: string;
     currentPagePath?: string;
     pageSizePath?: string;
+    numberOfElementsPath?: string;
 }
 interface CacheConfig<TData, TItem> {
     queryClient?: QueryClient;
@@ -24,6 +25,7 @@ interface CacheHandlers<TItem> {
     onDelete: (itemOrId: TItem | string | number, matcher?: (item: TItem) => boolean) => void;
 }
 type InsertPosition = 'start' | 'end';
+type ResolvedCacheConfig<TData, TItem> = Required<Pick<CacheConfig<TData, TItem>, 'queryClient' | 'queryKey' | 'itemsPath'>> & Pick<CacheConfig<TData, TItem>, 'keyExtractor' | 'pagination' | 'initialData' | 'isPaginated'>;
 
 declare class QueryCacheManager<TData, TItem> {
     private config;
@@ -47,7 +49,7 @@ declare class QueryCacheManager<TData, TItem> {
     refetch(key?: string | string[]): void;
     hasQuery(key?: string): boolean;
     removeQuery(key?: string): void;
-    getConfig(): typeof this.config;
+    getConfig(): ResolvedCacheConfig<TData, TItem>;
     createHandlers(): CacheHandlers<TItem>;
 }
 
@@ -97,6 +99,22 @@ declare const useQueryCacheManagers: <T extends Record<string, QueryCacheManager
     options?: Partial<Omit<CacheConfig<any, any>, "queryClient">>;
 }; }) => T;
 
+interface UsePaginatedCacheActionsConfig<TData, TItem> {
+    cacher: QueryCacheManager<TData, TItem>;
+    defaultPage?: number;
+    refetchThreshold?: number;
+    onNavigateToPage?: (page: number) => void;
+    onClearSearch?: () => void;
+    onRefetch?: () => void;
+}
+declare const usePaginatedCacheActions: <TData, TItem extends {
+    id: string | number;
+}>({ cacher, defaultPage, refetchThreshold, onNavigateToPage, onClearSearch, onRefetch, }: UsePaginatedCacheActionsConfig<TData, TItem>) => {
+    add: (item: TItem) => void;
+    update: (item: TItem) => void;
+    remove: (id: string | number) => void;
+};
+
 interface CacheProviderProps {
     children: ReactNode;
     config: CacheContextType;
@@ -108,4 +126,4 @@ type CacheOptions<TData = any, TItem = any> = Omit<CacheConfig<TData, TItem>, 'q
 declare const resetCacheManager: (queryKey: QueryKey) => void;
 declare const resetAllCacheManagers: () => void;
 
-export { type CacheConfig, type CacheHandlers, type CacheManagerConstructor, type CacheOptions, CacheProvider, type CustomMutationOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, cacheManagerFactory, resetAllCacheManagers, resetCacheManager, useCacherContext, useCacherMutation, useQueryCacheManagers };
+export { type CacheConfig, type CacheHandlers, type CacheManagerConstructor, type CacheOptions, CacheProvider, type CustomMutationOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, type UsePaginatedCacheActionsConfig, cacheManagerFactory, resetAllCacheManagers, resetCacheManager, useCacherContext, useCacherMutation, usePaginatedCacheActions, useQueryCacheManagers };

package/index.js

@@ -497,6 +497,86 @@ var useQueryCacheManagers = (configs) => {
   });
   return managers;
 };
+
+// src/hooks/usePaginatedCacheActions.ts
+var DEFAULT_REFETCH_THRESHOLD = 5;
+var usePaginatedCacheActions = ({
+  cacher,
+  defaultPage = 0,
+  refetchThreshold = DEFAULT_REFETCH_THRESHOLD,
+  onNavigateToPage,
+  onClearSearch,
+  onRefetch
+}) => {
+  const config = cacher.getConfig();
+  const { queryClient, queryKey, itemsPath, pagination } = config;
+  const currentPagePath = pagination?.currentPagePath ?? "page";
+  const pageSizePath = pagination?.pageSizePath ?? "size";
+  const totalElementsPath = pagination?.totalElementsPath ?? "totalElements";
+  const totalPagesPath = pagination?.totalPagesPath ?? "totalPages";
+  const numberOfElementsPath = pagination?.numberOfElementsPath ?? "numberOfElements";
+  const add = (item) => {
+    onClearSearch?.();
+    onNavigateToPage?.(1);
+    queryClient.setQueriesData({ queryKey }, (old) => {
+      if (!old) return old;
+      const currentPage = getAtPath(old, currentPagePath, 1);
+      if (currentPage !== defaultPage) return old;
+      const items = getAtPath(old, itemsPath, []);
+      const totalElements = getAtPath(old, totalElementsPath, 0);
+      const pageSize = getAtPath(old, pageSizePath, 10);
+      const newTotal = totalElements + 1;
+      const newItems = [item, ...items];
+      let result = { ...old };
+      result = setAtPath(result, itemsPath, newItems);
+      result = setAtPath(result, totalElementsPath, newTotal);
+      result = setAtPath(result, totalPagesPath, Math.ceil(newTotal / pageSize));
+      result = setAtPath(result, numberOfElementsPath, newItems.length);
+      return result;
+    });
+  };
+  const update = (item) => {
+    queryClient.setQueriesData({ queryKey }, (old) => {
+      if (!old) return old;
+      const items = getAtPath(old, itemsPath, []);
+      const index = items.findIndex((i) => i.id === item.id);
+      if (index === -1) return old;
+      const newItems = [...items];
+      newItems[index] = item;
+      return setAtPath({ ...old }, itemsPath, newItems);
+    });
+  };
+  const remove = (id) => {
+    let shouldRefetch = false;
+    queryClient.setQueriesData({ queryKey }, (old) => {
+      if (!old) return old;
+      const items = getAtPath(old, itemsPath, []);
+      const index = items.findIndex((i) => i.id === id);
+      if (index === -1) return old;
+      const newItems = items.filter((i) => i.id !== id);
+      const currentPage = getAtPath(old, currentPagePath, 1);
+      const totalElements = getAtPath(old, totalElementsPath, 0);
+      const pageSize = getAtPath(old, pageSizePath, 10);
+      const totalPages = getAtPath(old, totalPagesPath, 1);
+      const newTotal = Math.max(0, totalElements - 1);
+      const newTotalPages = Math.ceil(newTotal / pageSize);
+      if (newItems.length === 0 && currentPage > 1) {
+        onNavigateToPage?.(currentPage - 1);
+      } else if (newItems.length > 0 && newItems.length <= refetchThreshold && totalPages > currentPage) {
+        shouldRefetch = true;
+      }
+      let result = { ...old };
+      result = setAtPath(result, itemsPath, newItems);
+      result = setAtPath(result, totalElementsPath, newTotal);
+      result = setAtPath(result, totalPagesPath, newTotalPages);
+      result = setAtPath(result, numberOfElementsPath, newItems.length);
+      return result;
+    });
+    if (shouldRefetch) onRefetch?.();
+  };
+  return { add, update, remove };
+};
+var usePaginatedCacheActions_default = usePaginatedCacheActions;
 var CacheProvider = ({ config, children }) => {
   const queryClient = reactQuery.useQueryClient();
   React.useEffect(() => {
@@ -539,6 +619,7 @@ exports.resetAllCacheManagers = resetAllCacheManagers;
 exports.resetCacheManager = resetCacheManager;
 exports.useCacherContext = useCacherContext;
 exports.useCacherMutation = useCacherMutation;
+exports.usePaginatedCacheActions = usePaginatedCacheActions_default;
 exports.useQueryCacheManagers = useQueryCacheManagers;
 Object.keys(reactQuery).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tanstack-cacher",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "A lightweight cache management utility for TanStack Query that simplifies adding, updating, deleting, and synchronizing cached data",
   "license": "MIT",
   "repository": {