tanstack-cacher 1.2.1 → 1.3.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025
+Copyright (c) 2025 Hagi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/{dist/index.d.ts → index.d.ts}

@@ -1,5 +1,5 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { QueryClient, QueryKey, UseQueryOptions, UseMutationOptions, UseQueryResult } from '@tanstack/react-query';
+import { QueryClient, QueryKey, UseMutationOptions } from '@tanstack/react-query';
 export * from '@tanstack/react-query';
 
 interface PaginationConfig {
@@ -9,10 +9,11 @@ interface PaginationConfig {
     pageSizePath?: string;
 }
 interface CacheConfig<TData, TItem> {
-    queryClient: QueryClient;
+    queryClient?: QueryClient;
     queryKey: QueryKey;
-    itemsPath: string;
+    itemsPath?: string;
     pagination?: PaginationConfig;
+    isPaginated?: boolean;
     keyExtractor?: (item: TItem) => string | number;
     initialData?: TData;
 }
@@ -38,23 +39,31 @@ declare class QueryCacheManager<TData, TItem> {
     getItemsFromCache(): TItem[];
     getDataFromCache(): TData | undefined;
     invalidate(): void;
+    refetch(key?: string | string[]): void;
     createHandlers(): CacheHandlers<TItem>;
 }
 
-type CacheOptions<TData = any, TItem = any> = Omit<CacheConfig<TData, TItem>, 'queryClient' | 'queryKey'>;
+type CacheManagerConstructor = new <TData, TItem>(config: CacheConfig<TData, TItem>) => QueryCacheManager<TData, TItem>;
+declare class CacheManagerFactory {
+    private managerClass;
+    setManagerClass(managerClass: CacheManagerConstructor): void;
+    resetManagerClass(): void;
+    create<TData, TItem>(config: CacheConfig<TData, TItem>): QueryCacheManager<TData, TItem>;
+    getManagerClass(): CacheManagerConstructor;
+}
+declare const cacheManagerFactory: CacheManagerFactory;
 
-type CustomQueryOptions<TData, TError = unknown> = UseQueryOptions<TData, TError> & {
-    queryKey: QueryKey;
-    cacheType?: string;
-    queryFn: () => Promise<TData>;
-    cacheConfig?: CacheOptions;
-};
-type CustomMutationOptions<TData, TError, TVariables, TContext> = UseMutationOptions<TData, TError, TVariables, TContext> & {
+type MutationTypes = 'add' | 'invalidate' | 'remove' | 'update';
+interface CacheActions<TData, TItem = unknown> extends Omit<CacheConfig<TData, TItem>, 'queryClient'> {
+    type: MutationTypes;
+}
+type CustomMutationOptions<TData, TError, TVariables> = UseMutationOptions<TData, TError, TVariables> & {
     notify?: boolean;
     notifyError?: boolean;
     errorMessage?: string;
     notifySuccess?: boolean;
     successMessage?: string;
+    cacheActions?: CacheActions<TData>[] | CacheActions<TData>;
     notificationConfig?: NotificationOptions;
     getErrorMessage?: (error: TError) => string;
 };
@@ -63,11 +72,7 @@ interface NotificationOptions {
     [key: string]: any;
 }
 
-declare function useCustomQuery<TData, TError = unknown, TItem = any>(options: CustomQueryOptions<TData, TError>): UseQueryResult<TData, TError> & {
-    cache?: QueryCacheManager<TData, TItem>;
-};
-
-declare const useCustomMutation: <TData, TError, TVariables = void, TContext = unknown>(options: CustomMutationOptions<TData, TError, TVariables, TContext>) => _tanstack_react_query.UseMutationResult<TData, TError, TVariables, TContext>;
+declare const useCustomMutation: <TData, TError, TVariables = void>(options: CustomMutationOptions<TData, TError, TVariables>) => _tanstack_react_query.UseMutationResult<TData, TError, TVariables, unknown>;
 
 declare const useQueryCacheManagers: <T extends Record<string, QueryCacheManager<any, any>>>(configs: { [K in keyof T]: {
     queryKey: readonly unknown[];
@@ -81,7 +86,9 @@ interface NotificationContextType {
 
 declare const useNotificationContext: () => NotificationContextType;
 
+type CacheOptions<TData = any, TItem = any> = Omit<CacheConfig<TData, TItem>, 'queryClient' | 'queryKey'>;
+
 declare const resetCacheManager: (queryKey: QueryKey) => void;
 declare const resetAllCacheManagers: () => void;
 
-export { type CacheConfig, type CacheHandlers, type CacheOptions, type CustomMutationOptions, type CustomQueryOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, resetAllCacheManagers, resetCacheManager, useCustomMutation, useCustomQuery, useNotificationContext, useQueryCacheManagers };
+export { type CacheConfig, type CacheHandlers, type CacheManagerConstructor, type CacheOptions, type CustomMutationOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, cacheManagerFactory, resetAllCacheManagers, resetCacheManager, useCustomMutation, useNotificationContext, useQueryCacheManagers };

package/{dist/index.js → index.js}

@@ -11,7 +11,7 @@ function getAtPath(obj, path, defaultValue) {
   const keys = path.split(".");
   let result = obj;
   for (const key of keys) {
-    if (result === null || result === void 0) {
+    if (result === null) {
       return defaultValue;
     }
     result = result[key];
@@ -40,13 +40,46 @@ function incrementAtPath(obj, path, increment) {
   const newValue = currentValue + increment;
   return setAtPath(obj, path, newValue);
 }
+var runCacheManagers = (type, manager, data) => {
+  switch (type) {
+    case "invalidate":
+      manager.invalidate();
+      break;
+    case "remove":
+      manager.delete(data);
+      break;
+    case "add":
+      manager.add(data);
+      break;
+    case "update":
+      manager.update(data);
+      break;
+  }
+};
+
+// src/managers/QueryCacheManager/QueryCache.consts.ts
+var DEFAULT_PAGINATION_PATHS = {
+  totalElementsPath: "data.page.totalElements",
+  totalPagesPath: "data.page.totalPages",
+  currentPagePath: "data.page.number",
+  pageSizePath: "data.page.size"
+};
 
 // src/managers/QueryCacheManager/QueryCache.manager.ts
+var defaultQueryClient = new reactQuery.QueryClient();
 var QueryCacheManager = class {
   constructor(config) {
+    const isPaginated = Boolean(config.pagination);
     this.config = {
       ...config,
-      keyExtractor: config.keyExtractor || ((item) => item.id)
+      itemsPath: config.itemsPath ?? "data.content",
+      queryClient: config.queryClient ?? defaultQueryClient,
+      isPaginated,
+      keyExtractor: config.keyExtractor || ((item) => item.id),
+      pagination: isPaginated ? {
+        ...DEFAULT_PAGINATION_PATHS,
+        ...config.pagination
+      } : void 0
     };
   }
   /**
@@ -270,6 +303,35 @@ var QueryCacheManager = class {
   invalidate() {
     this.config.queryClient.invalidateQueries({ queryKey: this.config.queryKey });
   }
+  /**
+   * Refetch query immediately
+   */
+  refetch(key) {
+    try {
+      if (!key) {
+        this.config.queryClient.refetchQueries({
+          queryKey: this.config.queryKey,
+          exact: true
+        });
+        return;
+      }
+      if (Array.isArray(key)) {
+        key.forEach((keyItem) => {
+          this.config.queryClient.refetchQueries({
+            queryKey: [keyItem],
+            exact: true
+          });
+        });
+      } else {
+        this.config.queryClient.refetchQueries({
+          queryKey: [key],
+          exact: true
+        });
+      }
+    } catch (error) {
+      console.error("[QueryCacheManager] Refetch failed:", error);
+    }
+  }
   /**
    * Get handlers for use with mutations
    *
@@ -284,75 +346,25 @@ var QueryCacheManager = class {
   }
 };
 
-// src/utils/cacheRegistry.ts
-var cacheConfigRegistry = /* @__PURE__ */ new Map();
-var cacheRegistry = /* @__PURE__ */ new Map();
-var defaultConfigs = {
-  paginated: {
-    itemsPath: "data.content",
-    pagination: {
-      totalElementsPath: "data.page.totalElements",
-      totalPagesPath: "data.page.totalPages",
-      currentPagePath: "data.page.number",
-      pageSizePath: "data.page.size"
-    }
-  },
-  nonPaginated: {
-    itemsPath: "data"
+// src/managers/QueryCacheManager/CacheManagerFactory.ts
+var CacheManagerFactory = class {
+  constructor() {
+    this.managerClass = QueryCacheManager;
   }
-};
-Object.entries(defaultConfigs).forEach(([key, config]) => {
-  cacheConfigRegistry.set(key, config);
-});
-var getOrCreateCacheManager = (queryKey, queryClient, options) => {
-  const key = JSON.stringify(queryKey);
-  if (cacheRegistry.has(key)) {
-    return cacheRegistry.get(key);
+  setManagerClass(managerClass) {
+    this.managerClass = managerClass;
   }
-  const cacheType = options?.cacheType;
-  const config = options?.cacheConfig || cacheType && cacheConfigRegistry.get(cacheType);
-  if (!config) {
-    throw new Error(
-      `[CacheManager] Unknown cacheType "${cacheType}". Available: ${[
-        ...cacheConfigRegistry.keys()
-      ].join(", ")}`
-    );
+  resetManagerClass() {
+    this.managerClass = QueryCacheManager;
   }
-  const manager = new QueryCacheManager({
-    queryClient,
-    queryKey,
-    ...config
-  });
-  cacheRegistry.set(key, manager);
-  return manager;
-};
-var resetCacheManager = (queryKey) => {
-  cacheRegistry.delete(JSON.stringify(queryKey));
-};
-var resetAllCacheManagers = () => {
-  cacheRegistry.clear();
-};
-
-// src/hooks/useCustomQuery.ts
-function useCustomQuery(options) {
-  const queryClient = reactQuery.useQueryClient();
-  const { queryKey, cacheType, cacheConfig, ...rest } = options;
-  const queryResult = reactQuery.useQuery({
-    queryKey,
-    ...rest
-  });
-  let cache;
-  if (cacheType) {
-    cache = getOrCreateCacheManager(queryKey, queryClient, {
-      cacheType,
-      cacheConfig
-    });
+  create(config) {
+    return new this.managerClass(config);
   }
-  return {
-    ...queryResult,
-    cache
-  };
-}
+  getManagerClass() {
+    return this.managerClass;
+  }
+};
+var cacheManagerFactory = new CacheManagerFactory();
 var NotificationContext = react.createContext(
   void 0
 );
@@ -371,6 +383,7 @@ var useCustomMutation = (options) => {
   const {
     onError,
     onSuccess,
+    cacheActions,
     notify = false,
     notifyError = false,
     notifySuccess = false,
@@ -380,21 +393,32 @@ var useCustomMutation = (options) => {
     getErrorMessage,
     ...rest
   } = options;
-  const { showSuccess, showError } = useNotificationContext();
+  const notificationContext = useNotificationContext();
   return reactQuery.useMutation({
     ...rest,
-    onSuccess: (data, variables, context, mutation) => {
+    onSuccess: (data, variables, mResult, context) => {
       if (notify || notifySuccess) {
-        showSuccess(successMessage, notificationConfig);
+        notificationContext?.showSuccess?.(successMessage, notificationConfig);
+      }
+      onSuccess?.(data, variables, mResult, context);
+      if (Array.isArray(cacheActions)) {
+        cacheActions.forEach((item) => {
+          const { type, ...rest2 } = item;
+          const manager = cacheManagerFactory.create(rest2);
+          runCacheManagers(type, manager, data);
+        });
+      } else if (cacheActions) {
+        const { type, ...rest2 } = cacheActions;
+        const manager = cacheManagerFactory.create(rest2);
+        runCacheManagers(type, manager, data);
       }
-      onSuccess?.(data, variables, context, mutation);
     },
-    onError: (apiError, variables, context, mutation) => {
+    onError: (apiError, variables, mResult, context) => {
       const message = getErrorMessage ? getErrorMessage(apiError) : apiError?.error?.message ?? errorMessage;
       if (notify || notifyError) {
-        showError(message, notificationConfig);
+        notificationContext?.showError(message, notificationConfig);
       }
-      onError?.(apiError, variables, context, mutation);
+      onError?.(apiError, variables, mResult, context);
     }
   });
 };
@@ -413,11 +437,38 @@ var useQueryCacheManagers = (configs) => {
   return managers;
 };
 
+// src/utils/cacheRegistry.ts
+var cacheConfigRegistry = /* @__PURE__ */ new Map();
+var cacheRegistry = /* @__PURE__ */ new Map();
+var defaultConfigs = {
+  paginated: {
+    itemsPath: "data.content",
+    pagination: {
+      totalElementsPath: "data.page.totalElements",
+      totalPagesPath: "data.page.totalPages",
+      currentPagePath: "data.page.number",
+      pageSizePath: "data.page.size"
+    }
+  },
+  nonPaginated: {
+    itemsPath: "data"
+  }
+};
+Object.entries(defaultConfigs).forEach(([key, config]) => {
+  cacheConfigRegistry.set(key, config);
+});
+var resetCacheManager = (queryKey) => {
+  cacheRegistry.delete(JSON.stringify(queryKey));
+};
+var resetAllCacheManagers = () => {
+  cacheRegistry.clear();
+};
+
 exports.QueryCacheManager = QueryCacheManager;
+exports.cacheManagerFactory = cacheManagerFactory;
 exports.resetAllCacheManagers = resetAllCacheManagers;
 exports.resetCacheManager = resetCacheManager;
 exports.useCustomMutation = useCustomMutation;
-exports.useCustomQuery = useCustomQuery;
 exports.useNotificationContext = useNotificationContext;
 exports.useQueryCacheManagers = useQueryCacheManagers;
 Object.keys(reactQuery).forEach(function (k) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tanstack-cacher",
-  "version": "1.2.1",
+  "version": "1.3.2",
   "description": "A lightweight cache management utility for TanStack Query that simplifies adding, updating, deleting, and synchronizing cached data",
   "license": "MIT",
   "repository": {
@@ -28,32 +28,36 @@
     "cache-manager",
     "optimistic-updates"
   ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "styles",
+    "LICENSE",
+    "README.md"
+  ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
   "engines": {
     "node": ">=16"
   },
   "scripts": {
-    "build": "tsup",
     "dev": "tsup --watch",
-    "lint": "eslint src --ext .ts,.tsx",
-    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "locale-build": "tsup",
     "type-check": "tsc --noEmit",
     "prepublishOnly": "npm run build",
-    "test": "echo \"No tests yet\" && exit 0"
+    "lint": "eslint src --ext .ts,.tsx",
+    "build": "tsup && npm run copy-dist",
+    "test": "echo \"No tests yet\" && exit 0",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "copy-dist": "cp dist/index.js index.js && cp dist/index.d.ts index.d.ts"
   },
   "dependencies": {
     "@tanstack/react-query": "^5.62.11"

package/dist/index.d.mts

@@ -1,87 +0,0 @@
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { QueryClient, QueryKey, UseQueryOptions, UseMutationOptions, UseQueryResult } from '@tanstack/react-query';
-export * from '@tanstack/react-query';
-
-interface PaginationConfig {
-    totalElementsPath?: string;
-    totalPagesPath?: string;
-    currentPagePath?: string;
-    pageSizePath?: string;
-}
-interface CacheConfig<TData, TItem> {
-    queryClient: QueryClient;
-    queryKey: QueryKey;
-    itemsPath: string;
-    pagination?: PaginationConfig;
-    keyExtractor?: (item: TItem) => string | number;
-    initialData?: TData;
-}
-interface CacheHandlers<TItem> {
-    onAdd: (newItem: TItem, position?: 'start' | 'end') => void;
-    onUpdate: (updatedItem: Partial<TItem>, matcher?: (item: TItem) => boolean) => void;
-    onDelete: (itemOrId: TItem | string | number, matcher?: (item: TItem) => boolean) => void;
-}
-type InsertPosition = 'start' | 'end';
-
-declare class QueryCacheManager<TData, TItem> {
-    private config;
-    constructor(config: CacheConfig<TData, TItem>);
-    private getItems;
-    private setItems;
-    private updatePaginationOnAdd;
-    private updatePaginationOnRemove;
-    add(newItem: TItem, position?: InsertPosition): void;
-    update(updatedItem: Partial<TItem>, matcher?: (item: TItem) => boolean): void;
-    delete(itemOrId: TItem | string | number, matcher?: (item: TItem) => boolean): void;
-    replace(newData: TData): void;
-    clear(): void;
-    getItemsFromCache(): TItem[];
-    getDataFromCache(): TData | undefined;
-    invalidate(): void;
-    createHandlers(): CacheHandlers<TItem>;
-}
-
-type CacheOptions<TData = any, TItem = any> = Omit<CacheConfig<TData, TItem>, 'queryClient' | 'queryKey'>;
-
-type CustomQueryOptions<TData, TError = unknown> = UseQueryOptions<TData, TError> & {
-    queryKey: QueryKey;
-    cacheType?: string;
-    queryFn: () => Promise<TData>;
-    cacheConfig?: CacheOptions;
-};
-type CustomMutationOptions<TData, TError, TVariables, TContext> = UseMutationOptions<TData, TError, TVariables, TContext> & {
-    notify?: boolean;
-    notifyError?: boolean;
-    errorMessage?: string;
-    notifySuccess?: boolean;
-    successMessage?: string;
-    notificationConfig?: NotificationOptions;
-    getErrorMessage?: (error: TError) => string;
-};
-interface NotificationOptions {
-    duration?: number;
-    [key: string]: any;
-}
-
-declare function useCustomQuery<TData, TError = unknown, TItem = any>(options: CustomQueryOptions<TData, TError>): UseQueryResult<TData, TError> & {
-    cache?: QueryCacheManager<TData, TItem>;
-};
-
-declare const useCustomMutation: <TData, TError, TVariables = void, TContext = unknown>(options: CustomMutationOptions<TData, TError, TVariables, TContext>) => _tanstack_react_query.UseMutationResult<TData, TError, TVariables, TContext>;
-
-declare const useQueryCacheManagers: <T extends Record<string, QueryCacheManager<any, any>>>(configs: { [K in keyof T]: {
-    queryKey: readonly unknown[];
-    options?: Partial<Omit<CacheConfig<any, any>, "queryClient">>;
-}; }) => T;
-
-interface NotificationContextType {
-    showError: (message: string, options?: NotificationOptions) => void;
-    showSuccess: (message: string, options?: NotificationOptions) => void;
-}
-
-declare const useNotificationContext: () => NotificationContextType;
-
-declare const resetCacheManager: (queryKey: QueryKey) => void;
-declare const resetAllCacheManagers: () => void;
-
-export { type CacheConfig, type CacheHandlers, type CacheOptions, type CustomMutationOptions, type CustomQueryOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, resetAllCacheManagers, resetCacheManager, useCustomMutation, useCustomQuery, useNotificationContext, useQueryCacheManagers };

package/dist/index.mjs

@@ -1,415 +0,0 @@
-import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
-export * from '@tanstack/react-query';
-import { createContext, useContext } from 'react';
-
-// src/index.ts
-
-// src/managers/QueryCacheManager/QueryCache.utils.ts
-function getAtPath(obj, path, defaultValue) {
-  if (!obj || !path) return defaultValue;
-  const keys = path.split(".");
-  let result = obj;
-  for (const key of keys) {
-    if (result === null || result === void 0) {
-      return defaultValue;
-    }
-    result = result[key];
-  }
-  return result !== void 0 ? result : defaultValue;
-}
-function setAtPath(obj, path, value) {
-  if (!path) return obj;
-  const keys = path.split(".");
-  const root = obj ? { ...obj } : {};
-  let current = root;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (!current[key] || typeof current[key] !== "object") {
-      current[key] = {};
-    } else {
-      current[key] = { ...current[key] };
-    }
-    current = current[key];
-  }
-  current[keys[keys.length - 1]] = value;
-  return root;
-}
-function incrementAtPath(obj, path, increment) {
-  const currentValue = getAtPath(obj, path, 0);
-  const newValue = currentValue + increment;
-  return setAtPath(obj, path, newValue);
-}
-
-// src/managers/QueryCacheManager/QueryCache.manager.ts
-var QueryCacheManager = class {
-  constructor(config) {
-    this.config = {
-      ...config,
-      keyExtractor: config.keyExtractor || ((item) => item.id)
-    };
-  }
-  /**
-   * Get items array from data
-   * Returns empty array if path doesn't exist or data is null
-   */
-  getItems(data) {
-    if (!data) return [];
-    if (!this.config.itemsPath) {
-      return Array.isArray(data) ? data : [];
-    }
-    const items = getAtPath(data, this.config.itemsPath, []);
-    return Array.isArray(items) ? items : [];
-  }
-  /**
-   * Set items array in data
-   * Creates nested structure if it doesn't exist
-   */
-  setItems(data, items) {
-    if (!data) {
-      if (this.config.initialData) {
-        data = this.config.initialData;
-      } else {
-        if (!this.config.itemsPath) {
-          return items;
-        }
-        data = {};
-      }
-    }
-    if (!this.config.itemsPath) {
-      return items;
-    }
-    return setAtPath(data, this.config.itemsPath, items);
-  }
-  /**
-   * Update pagination metadata after adding items
-   */
-  updatePaginationOnAdd(data, addedCount) {
-    if (!this.config.pagination) return data;
-    let result = data;
-    if (this.config.pagination.totalElementsPath) {
-      result = incrementAtPath(
-        result,
-        this.config.pagination.totalElementsPath,
-        addedCount
-      );
-    }
-    if (this.config.pagination.totalPagesPath && this.config.pagination.pageSizePath && this.config.pagination.totalElementsPath) {
-      const pageSize = getAtPath(result, this.config.pagination.pageSizePath, 0);
-      const totalElements = getAtPath(
-        result,
-        this.config.pagination.totalElementsPath,
-        0
-      );
-      if (pageSize > 0) {
-        const totalPages = Math.ceil(totalElements / pageSize);
-        result = setAtPath(
-          result,
-          this.config.pagination.totalPagesPath,
-          totalPages
-        );
-      }
-    }
-    return result;
-  }
-  /**
-   * Update pagination metadata after removing items
-   */
-  updatePaginationOnRemove(data, removedCount) {
-    if (!this.config.pagination) return data;
-    let result = data;
-    if (this.config.pagination.totalElementsPath) {
-      result = incrementAtPath(
-        result,
-        this.config.pagination.totalElementsPath,
-        -removedCount
-      );
-    }
-    if (this.config.pagination.totalPagesPath && this.config.pagination.pageSizePath && this.config.pagination.totalElementsPath) {
-      const pageSize = getAtPath(result, this.config.pagination.pageSizePath, 0);
-      const totalElements = getAtPath(
-        result,
-        this.config.pagination.totalElementsPath,
-        0
-      );
-      if (pageSize > 0) {
-        const totalPages = Math.ceil(Math.max(0, totalElements) / pageSize);
-        result = setAtPath(
-          result,
-          this.config.pagination.totalPagesPath,
-          totalPages
-        );
-      }
-    }
-    return result;
-  }
-  /**
-   * Add item to cache
-   *
-   * @param newItem - The item to add
-   * @param position - Where to add: 'start' or 'end'
-   */
-  add(newItem, position = "start") {
-    try {
-      this.config.queryClient.setQueryData(this.config.queryKey, (oldData) => {
-        const items = this.getItems(oldData);
-        const updatedItems = position === "start" ? [newItem, ...items] : [...items, newItem];
-        let result = this.setItems(oldData, updatedItems);
-        result = this.updatePaginationOnAdd(result, 1);
-        return result;
-      });
-    } catch (error) {
-      console.error("[QueryCacheManager] Add failed:", error);
-      this.invalidate();
-    }
-  }
-  /**
-   * Update existing item
-   *
-   * @param updatedItem - Partial item data to update
-   * @param matcher - Optional custom matcher function. Defaults to matching by key
-   */
-  update(updatedItem, matcher) {
-    try {
-      this.config.queryClient.setQueryData(this.config.queryKey, (oldData) => {
-        const items = this.getItems(oldData);
-        const matchFn = matcher || ((item) => this.config.keyExtractor(item) === this.config.keyExtractor(updatedItem));
-        const updatedItems = items.map(
-          (item) => matchFn(item) ? { ...item, ...updatedItem } : item
-        );
-        return this.setItems(oldData, updatedItems);
-      });
-    } catch (error) {
-      console.error("[QueryCacheManager] Update failed:", error);
-      this.invalidate();
-    }
-  }
-  /**
-   * Remove item from cache
-   *
-   * @param itemOrId - Item object or ID to remove
-   * @param matcher - Optional custom matcher function. Defaults to matching by key
-   */
-  delete(itemOrId, matcher) {
-    try {
-      this.config.queryClient.setQueryData(this.config.queryKey, (oldData) => {
-        const items = this.getItems(oldData);
-        const matchFn = matcher || ((item) => {
-          if (typeof itemOrId === "object") {
-            return this.config.keyExtractor(item) === this.config.keyExtractor(itemOrId);
-          }
-          return this.config.keyExtractor(item) === itemOrId;
-        });
-        const originalLength = items.length;
-        const updatedItems = items.filter((item) => !matchFn(item));
-        const removedCount = originalLength - updatedItems.length;
-        let result = this.setItems(oldData, updatedItems);
-        if (removedCount > 0) {
-          result = this.updatePaginationOnRemove(result, removedCount);
-        }
-        return result;
-      });
-    } catch (error) {
-      console.error("[QueryCacheManager] Delete failed:", error);
-      this.invalidate();
-    }
-  }
-  /**
-   * Replace full data
-   *
-   * @param newData - Complete new data to replace cache
-   */
-  replace(newData) {
-    try {
-      this.config.queryClient.setQueryData(this.config.queryKey, newData);
-    } catch (error) {
-      console.error("[QueryCacheManager] Replace failed:", error);
-      this.invalidate();
-    }
-  }
-  /**
-   * Clear all items (keeps structure, empties array)
-   */
-  clear() {
-    try {
-      this.config.queryClient.setQueryData(this.config.queryKey, (oldData) => {
-        let result = this.setItems(oldData, []);
-        if (this.config.pagination?.totalElementsPath) {
-          result = setAtPath(result, this.config.pagination.totalElementsPath, 0);
-        }
-        if (this.config.pagination?.totalPagesPath) {
-          result = setAtPath(result, this.config.pagination.totalPagesPath, 0);
-        }
-        return result;
-      });
-    } catch (error) {
-      console.error("[QueryCacheManager] Clear failed:", error);
-      this.invalidate();
-    }
-  }
-  /**
-   * Get current items from cache
-   *
-   * @returns Current items array or empty array if no data
-   */
-  getItemsFromCache() {
-    const data = this.config.queryClient.getQueryData(this.config.queryKey);
-    return this.getItems(data);
-  }
-  /**
-   * Get full data from cache
-   *
-   * @returns Current full data or undefined if no data
-   */
-  getDataFromCache() {
-    return this.config.queryClient.getQueryData(this.config.queryKey);
-  }
-  /**
-   * Invalidate query to trigger refetch
-   */
-  invalidate() {
-    this.config.queryClient.invalidateQueries({ queryKey: this.config.queryKey });
-  }
-  /**
-   * Get handlers for use with mutations
-   *
-   * @returns Object with onAdd, onUpdate, onDelete handlers
-   */
-  createHandlers() {
-    return {
-      onAdd: (newItem, position) => this.add(newItem, position),
-      onUpdate: (updatedItem, matcher) => this.update(updatedItem, matcher),
-      onDelete: (itemOrId, matcher) => this.delete(itemOrId, matcher)
-    };
-  }
-};
-
-// src/utils/cacheRegistry.ts
-var cacheConfigRegistry = /* @__PURE__ */ new Map();
-var cacheRegistry = /* @__PURE__ */ new Map();
-var defaultConfigs = {
-  paginated: {
-    itemsPath: "data.content",
-    pagination: {
-      totalElementsPath: "data.page.totalElements",
-      totalPagesPath: "data.page.totalPages",
-      currentPagePath: "data.page.number",
-      pageSizePath: "data.page.size"
-    }
-  },
-  nonPaginated: {
-    itemsPath: "data"
-  }
-};
-Object.entries(defaultConfigs).forEach(([key, config]) => {
-  cacheConfigRegistry.set(key, config);
-});
-var getOrCreateCacheManager = (queryKey, queryClient, options) => {
-  const key = JSON.stringify(queryKey);
-  if (cacheRegistry.has(key)) {
-    return cacheRegistry.get(key);
-  }
-  const cacheType = options?.cacheType;
-  const config = options?.cacheConfig || cacheType && cacheConfigRegistry.get(cacheType);
-  if (!config) {
-    throw new Error(
-      `[CacheManager] Unknown cacheType "${cacheType}". Available: ${[
-        ...cacheConfigRegistry.keys()
-      ].join(", ")}`
-    );
-  }
-  const manager = new QueryCacheManager({
-    queryClient,
-    queryKey,
-    ...config
-  });
-  cacheRegistry.set(key, manager);
-  return manager;
-};
-var resetCacheManager = (queryKey) => {
-  cacheRegistry.delete(JSON.stringify(queryKey));
-};
-var resetAllCacheManagers = () => {
-  cacheRegistry.clear();
-};
-
-// src/hooks/useCustomQuery.ts
-function useCustomQuery(options) {
-  const queryClient = useQueryClient();
-  const { queryKey, cacheType, cacheConfig, ...rest } = options;
-  const queryResult = useQuery({
-    queryKey,
-    ...rest
-  });
-  let cache;
-  if (cacheType) {
-    cache = getOrCreateCacheManager(queryKey, queryClient, {
-      cacheType,
-      cacheConfig
-    });
-  }
-  return {
-    ...queryResult,
-    cache
-  };
-}
-var NotificationContext = createContext(
-  void 0
-);
-
-// src/hooks/useNotificationContext.ts
-var useNotificationContext = () => {
-  const context = useContext(NotificationContext);
-  if (!context) {
-    throw new Error("useNotificationContext must be used within an NotificationProvider");
-  }
-  return context;
-};
-
-// src/hooks/useCustomMutation.ts
-var useCustomMutation = (options) => {
-  const {
-    onError,
-    onSuccess,
-    notify = false,
-    notifyError = false,
-    notifySuccess = false,
-    errorMessage = "Operation failed!",
-    successMessage = "Operation successfull!",
-    notificationConfig = { duration: 2 },
-    getErrorMessage,
-    ...rest
-  } = options;
-  const { showSuccess, showError } = useNotificationContext();
-  return useMutation({
-    ...rest,
-    onSuccess: (data, variables, context, mutation) => {
-      if (notify || notifySuccess) {
-        showSuccess(successMessage, notificationConfig);
-      }
-      onSuccess?.(data, variables, context, mutation);
-    },
-    onError: (apiError, variables, context, mutation) => {
-      const message = getErrorMessage ? getErrorMessage(apiError) : apiError?.error?.message ?? errorMessage;
-      if (notify || notifyError) {
-        showError(message, notificationConfig);
-      }
-      onError?.(apiError, variables, context, mutation);
-    }
-  });
-};
-var useQueryCacheManagers = (configs) => {
-  const queryClient = useQueryClient();
-  const managers = {};
-  Object.entries(configs).forEach(([key, config]) => {
-    const options = config.options ?? {};
-    managers[key] = new QueryCacheManager({
-      queryKey: config.queryKey,
-      queryClient,
-      ...options,
-      itemsPath: options.itemsPath ?? ""
-    });
-  });
-  return managers;
-};
-
-export { QueryCacheManager, resetAllCacheManagers, resetCacheManager, useCustomMutation, useCustomQuery, useNotificationContext, useQueryCacheManagers };