react-smart-query 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1018 @@
+import { init_requestLock_service, requestLock_service_exports, fetchWithLock, enqueueMutation, processQueue } from './chunk-KLJQATIV.mjs';
+export { clearQueue, enqueueMutation, fetchWithLock, getQueue, getQueueLength, inFlightCount, inFlightKeys, initQueue, processQueue, registerExecutor } from './chunk-KLJQATIV.mjs';
+import { cacheKeyFor, readCache, writeCache, isCacheStale, emit, deleteCache } from './chunk-KSLDOL27.mjs';
+export { CURRENT_CACHE_VERSION, addObserver, cacheKeyFor, clearObservers, deleteCache, getPartialCache, isCacheStale, readCache, removeObserver, setMaxCacheEntries, writeCache } from './chunk-KSLDOL27.mjs';
+import { __toCommonJS, storage } from './chunk-QRCVY7UR.mjs';
+import { useMemo, useState, useRef, useEffect, useCallback, useSyncExternalStore } from 'react';
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import equal from 'fast-deep-equal';
+
+init_requestLock_service();
+function smartCompare(oldData, newData, options = {}) {
+  const idField = options.idField ?? "id";
+  const versionField = options.versionField === void 0 ? "updatedAt" : options.versionField;
+  if (oldData === newData) return { isEqual: true, tier: 1 };
+  const oldIsArr = Array.isArray(oldData);
+  const newIsArr = Array.isArray(newData);
+  if (oldIsArr !== newIsArr) return { isEqual: false, tier: 2 };
+  if (!oldIsArr) return { isEqual: equal(oldData, newData), tier: 5 };
+  const o = oldData;
+  const n = newData;
+  if (o.length !== n.length) return { isEqual: false, tier: 2 };
+  if (o.length === 0) return { isEqual: true, tier: 2 };
+  let oldIds = "";
+  let newIds = "";
+  for (let i = 0; i < o.length; i++) {
+    oldIds += String(o[i][idField] ?? i) + "|";
+    newIds += String(n[i][idField] ?? i) + "|";
+  }
+  if (oldIds !== newIds) return { isEqual: false, tier: 3 };
+  if (versionField !== null) {
+    let xorOld = 0;
+    let xorNew = 0;
+    for (let i = 0; i < o.length; i++) {
+      xorOld ^= Number(o[i][versionField] ?? 0) ^ i;
+      xorNew ^= Number(n[i][versionField] ?? 0) ^ i;
+    }
+    if (xorOld !== xorNew) return { isEqual: false, tier: 4 };
+  }
+  return { isEqual: equal(oldData, newData), tier: 5 };
+}
+function isDataEqual(oldData, newData, options) {
+  return smartCompare(oldData, newData, options).isEqual;
+}
+
+// src/utils/normalize.ts
+function emptyList() {
+  return { byId: /* @__PURE__ */ Object.create(null), allIds: [] };
+}
+function fromArray(items, getItemId, comparator) {
+  const byId = /* @__PURE__ */ Object.create(null);
+  const allIds = new Array(items.length);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const id = getItemId(item);
+    byId[id] = item;
+    allIds[i] = id;
+  }
+  if (comparator) allIds.sort((a, b) => comparator(byId[a], byId[b]));
+  return { byId, allIds };
+}
+function toArray(list) {
+  const out = new Array(list.allIds.length);
+  for (let i = 0; i < list.allIds.length; i++) out[i] = list.byId[list.allIds[i]];
+  return out;
+}
+function binaryIdx(allIds, byId, item, getItemId, cmp) {
+  const itemId = getItemId(item);
+  let lo = 0, hi = allIds.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const midItem = byId[allIds[mid]];
+    let res = cmp(midItem, item);
+    if (res === 0) {
+      res = allIds[mid].localeCompare(itemId);
+    }
+    res <= 0 ? lo = mid + 1 : hi = mid;
+  }
+  return lo;
+}
+function normalizedAdd(list, item, getItemId, comparator, getItemVersion) {
+  const id = getItemId(item);
+  const existing = list.byId[id];
+  if (existing && getItemVersion) {
+    const vExisting = getItemVersion(existing);
+    const vNew = getItemVersion(item);
+    if (vNew < vExisting) return list;
+  }
+  const newById = { ...list.byId, [id]: item };
+  const existingIdx = list.allIds.indexOf(id);
+  const workingIds = list.allIds.slice();
+  if (existingIdx !== -1) workingIds.splice(existingIdx, 1);
+  const insertIdx = binaryIdx(workingIds, newById, item, getItemId, comparator);
+  workingIds.splice(insertIdx, 0, id);
+  return { byId: newById, allIds: workingIds };
+}
+function normalizedUpdate(list, item, getItemId, comparator, getItemVersion) {
+  const id = getItemId(item);
+  const oldItem = list.byId[id];
+  if (!oldItem) return list;
+  if (getItemVersion) {
+    const vExisting = getItemVersion(oldItem);
+    const vNew = getItemVersion(item);
+    if (vNew < vExisting) return list;
+  }
+  if (comparator(oldItem, item) === 0) {
+    return {
+      allIds: list.allIds,
+      // Keep same reference if possible, but immutable is safer
+      byId: { ...list.byId, [id]: item }
+    };
+  }
+  return normalizedAdd(list, item, getItemId, comparator, getItemVersion);
+}
+function normalizedRemove(list, id) {
+  if (!(id in list.byId)) return list;
+  const newById = { ...list.byId };
+  delete newById[id];
+  const idx = list.allIds.indexOf(id);
+  const newAllIds = list.allIds.slice();
+  if (idx !== -1) newAllIds.splice(idx, 1);
+  return { byId: newById, allIds: newAllIds };
+}
+function mergeNormalizedData(existing, incomingIds, incomingById, getItemId, comparator) {
+  const newById = { ...existing.byId, ...incomingById };
+  const allIds = [...existing.allIds];
+  const seen = new Set(existing.allIds);
+  for (const id of incomingIds) {
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    if (comparator) {
+      const item = incomingById[id];
+      const insertIdx = binaryIdx(allIds, newById, item, getItemId, comparator);
+      allIds.splice(insertIdx, 0, id);
+    } else {
+      allIds.push(id);
+    }
+  }
+  if (comparator && incomingIds.some((id) => existing.byId[id])) {
+    allIds.sort((a, b) => comparator(newById[a], newById[b]));
+  }
+  return { byId: newById, allIds };
+}
+function getPage(allIds, byId, pageIndex, pageSize) {
+  const start = pageIndex * pageSize;
+  const ids = allIds.slice(start, start + pageSize);
+  return ids.map((id) => byId[id]);
+}
+function derivePages(allIds, byId, pageSize) {
+  const totalItems = allIds.length;
+  const totalPages = Math.ceil(totalItems / pageSize);
+  const pages = [];
+  for (let i = 0; i < totalPages; i++) {
+    pages.push(getPage(allIds, byId, i, pageSize));
+  }
+  return pages;
+}
+function isNormalizedEmpty(list) {
+  return list.allIds.length === 0;
+}
+function trimNormalizedList(list, maxItems) {
+  if (list.allIds.length <= maxItems) return list;
+  const removeCount = Math.max(
+    Math.ceil(list.allIds.length * 0.2),
+    list.allIds.length - maxItems
+  );
+  const newSize = list.allIds.length - removeCount;
+  const newAllIds = list.allIds.slice(0, newSize);
+  const newById = {};
+  for (const id of newAllIds) {
+    newById[id] = list.byId[id];
+  }
+  return { byId: newById, allIds: newAllIds };
+}
+
+// src/registry/smartQueryRegistry.ts
+var liveRegistry = /* @__PURE__ */ new Map();
+var sortConfigRegistry = /* @__PURE__ */ new Map();
+function _registerUpdater(storageKey, updater, config) {
+  liveRegistry.set(storageKey, updater);
+  if (config) sortConfigRegistry.set(storageKey, config);
+}
+function _unregisterUpdater(storageKey) {
+  liveRegistry.delete(storageKey);
+}
+async function mutateStorageOnly(storageKey, queryKey, fn) {
+  const config = sortConfigRegistry.get(storageKey);
+  if (!config) return;
+  const entry = await readCache(storageKey, queryKey);
+  if (!entry) return;
+  const rawData = entry.data;
+  const isUnified = "data" in rawData && "meta" in rawData;
+  const currentList = isUnified ? rawData.data : rawData;
+  const nextList = fn(currentList, config);
+  const nextData = isUnified ? { ...rawData, data: nextList } : nextList;
+  await writeCache(storageKey, nextData, queryKey);
+}
+function getSmartQueryActions(queryKey) {
+  const storageKey = cacheKeyFor(queryKey);
+  return {
+    isActive: () => liveRegistry.has(storageKey),
+    addItem: async (item) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.add(item);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list, { comparator, getItemId }) => normalizedAdd(list, item, getItemId, comparator)
+      );
+    },
+    updateItem: async (item) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.update(item);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list, { comparator, getItemId }) => normalizedUpdate(list, item, getItemId, comparator)
+      );
+    },
+    removeItem: async (id) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.remove(id);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list) => normalizedRemove(list, id)
+      );
+    }
+  };
+}
+var smartQueryDebug = {
+  /** Get the current normalized state for a query key. */
+  getNormalizedState: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return null;
+    const storageKey = cacheKeyFor(queryKey);
+    const entry = await readCache(storageKey, queryKey);
+    return entry ? entry.data : null;
+  },
+  /** Log a detailed summary of the cache entry to the console. */
+  inspectCache: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return;
+    const storageKey = cacheKeyFor(queryKey);
+    const entry = await readCache(storageKey, queryKey);
+    if (!entry) {
+      console.log(`[SmartQuery Debug] Cache MISS for:`, queryKey);
+      return;
+    }
+    console.log(`[SmartQuery Debug] Cache HIT for:`, queryKey, {
+      cachedAt: new Date(entry.cachedAt).toISOString(),
+      size: JSON.stringify(entry.data).length,
+      data: entry.data
+    });
+  },
+  /** Clear the cache entry for a query key. */
+  clearCache: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return;
+    const storageKey = cacheKeyFor(queryKey);
+    const { deleteCache: deleteCache2 } = await import('./cache.service-MR6EEYM4.mjs');
+    await deleteCache2(storageKey);
+  },
+  /** Get the current state of the offline mutation queue. */
+  getQueue: async () => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return [];
+    try {
+      const { getStorage } = await import('./storage.adapter-PJCVI4DE.mjs');
+      const raw = await getStorage().get("sq_mutation_queue");
+      return raw ? JSON.parse(raw) : [];
+    } catch {
+      return [];
+    }
+  },
+  /** Get list of all storage keys currently being fetched. */
+  inFlightRequests: () => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return [];
+    try {
+      const { inFlightKeys: inFlightKeys2 } = (init_requestLock_service(), __toCommonJS(requestLock_service_exports));
+      return inFlightKeys2();
+    } catch {
+      return [];
+    }
+  }
+};
+async function batchUpdate(queryKey, fn) {
+  const storageKey = cacheKeyFor(queryKey);
+  const actions = getSmartQueryActions(queryKey);
+  const live = liveRegistry.has(storageKey);
+  if (live) {
+    await fn(actions);
+    return;
+  }
+  const config = sortConfigRegistry.get(storageKey);
+  if (!config) return;
+  const entry = await readCache(storageKey, queryKey);
+  if (!entry) return;
+  let currentData = entry.data;
+  const isUnified = "data" in currentData && "meta" in currentData;
+  let currentList = isUnified ? currentData.data : currentData;
+  const batchActions = {
+    isActive: () => false,
+    addItem: async (item) => {
+      currentList = normalizedAdd(currentList, item, config.getItemId, config.comparator);
+    },
+    updateItem: async (item) => {
+      currentList = normalizedUpdate(currentList, item, config.getItemId, config.comparator);
+    },
+    removeItem: async (id) => {
+      currentList = normalizedRemove(currentList, id);
+    }
+  };
+  await fn(batchActions);
+  const nextData = isUnified ? { ...currentData, data: currentList } : currentList;
+  await writeCache(storageKey, nextData, queryKey);
+}
+
+// src/hooks/useSmartQuery.ts
+function normalizeError(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+var DEFAULT_TTL = 5 * 6e4;
+function useSmartQuery(options) {
+  const {
+    queryKey,
+    queryFn,
+    select,
+    getItemId,
+    sortComparator,
+    cacheTtl = DEFAULT_TTL,
+    maxItems = 1e3,
+    getItemVersion,
+    strictFreshness = false,
+    fallbackData,
+    compareOptions,
+    onSuccess,
+    onError,
+    queryOptions = {}
+  } = options;
+  const queryClient = useQueryClient();
+  const storageKey = useMemo(
+    () => cacheKeyFor(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const listMode = typeof sortComparator === "function" && typeof getItemId === "function";
+  const [viewData, setViewData] = useState(void 0);
+  const [isCacheLoading, setIsCacheLoading] = useState(true);
+  const [isFromCache, setIsFromCache] = useState(false);
+  const [shouldFetch, setShouldFetch] = useState(false);
+  const [smartError, setSmartError] = useState(null);
+  const prevRawRef = useRef(void 0);
+  const normalizedRef = useRef(emptyList());
+  useEffect(() => {
+    let cancelled = false;
+    setIsCacheLoading(true);
+    readCache(storageKey, queryKey).then((entry) => {
+      if (cancelled) return;
+      if (entry !== null) {
+        const isStale = isCacheStale(entry, cacheTtl);
+        const usable = !strictFreshness || !isStale;
+        if (usable) {
+          if (listMode) {
+            let normalized;
+            if (Array.isArray(entry.data)) {
+              normalized = fromArray(
+                entry.data,
+                getItemId,
+                sortComparator
+              );
+            } else {
+              normalized = entry.data;
+            }
+            normalizedRef.current = normalized;
+            const view = toArray(normalized);
+            prevRawRef.current = normalized;
+            queryClient.setQueryData(queryKey, view);
+            setViewData(view);
+          } else {
+            prevRawRef.current = entry.data;
+            queryClient.setQueryData(queryKey, entry.data);
+            setViewData(entry.data);
+          }
+          setIsFromCache(true);
+          setShouldFetch(isStale);
+        } else {
+          setShouldFetch(true);
+        }
+      } else {
+        setShouldFetch(true);
+      }
+      setIsCacheLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storageKey]);
+  const wrappedQueryFn = useCallback(
+    async (ctx) => {
+      emit({ type: "fetch_start", queryKey });
+      const start = Date.now();
+      try {
+        const raw = await fetchWithLock(storageKey, () => queryFn(ctx));
+        const transformed = select ? select(raw) : raw;
+        emit({
+          type: "fetch_success",
+          queryKey,
+          durationMs: Date.now() - start
+        });
+        return transformed;
+      } catch (err) {
+        emit({ type: "fetch_error", queryKey, error: err });
+        throw err;
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey, queryFn, select]
+  );
+  const {
+    data: freshData,
+    isFetching,
+    error: tqError,
+    refetch: tqRefetch
+  } = useQuery({
+    queryKey,
+    queryFn: wrappedQueryFn,
+    enabled: !isCacheLoading && shouldFetch,
+    staleTime: cacheTtl,
+    gcTime: cacheTtl * 2,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: true,
+    networkMode: "offlineFirst",
+    ...queryOptions
+  });
+  useEffect(() => {
+    if (!tqError) {
+      setSmartError(null);
+      return;
+    }
+    const structured = normalizeError(tqError);
+    const suppressed = onError?.(structured);
+    if (!suppressed) setSmartError(structured);
+  }, [tqError, onError]);
+  useEffect(() => {
+    if (freshData === void 0 || isFetching) return;
+    if (listMode) {
+      const freshNormalized = fromArray(
+        freshData,
+        getItemId,
+        sortComparator
+      );
+      if (!isDataEqual(prevRawRef.current, freshNormalized, compareOptions)) {
+        prevRawRef.current = freshNormalized;
+        normalizedRef.current = freshNormalized;
+        const view = toArray(freshNormalized);
+        queryClient.setQueryData(queryKey, view);
+        setViewData(() => view);
+        setIsFromCache(false);
+        const trimmed = trimNormalizedList(freshNormalized, maxItems);
+        void writeCache(storageKey, trimmed, queryKey);
+        onSuccess?.(view);
+      }
+    } else {
+      if (!isDataEqual(prevRawRef.current, freshData, compareOptions)) {
+        prevRawRef.current = freshData;
+        queryClient.setQueryData(queryKey, freshData);
+        setViewData(() => freshData);
+        setIsFromCache(false);
+        void writeCache(storageKey, freshData, queryKey);
+        onSuccess?.(freshData);
+      }
+    }
+  }, [freshData, isFetching]);
+  const applyMutation = useCallback(
+    (fn) => {
+      const next = trimNormalizedList(fn(normalizedRef.current), maxItems);
+      normalizedRef.current = next;
+      prevRawRef.current = next;
+      const view = toArray(next);
+      queryClient.setQueryData(queryKey, view);
+      setViewData(view);
+      void writeCache(storageKey, next, queryKey);
+    },
+    [queryClient, queryKey, storageKey, maxItems]
+  );
+  const addItem = useCallback(
+    (item) => {
+      if (!listMode) return;
+      applyMutation(
+        (cur) => normalizedAdd(
+          cur,
+          item,
+          getItemId,
+          sortComparator,
+          getItemVersion
+        )
+      );
+    },
+    [listMode, getItemId, sortComparator, getItemVersion, applyMutation]
+  );
+  const updateItem = useCallback(
+    (item) => {
+      if (!listMode) return;
+      applyMutation(
+        (cur) => normalizedUpdate(
+          cur,
+          item,
+          getItemId,
+          sortComparator,
+          getItemVersion
+        )
+      );
+    },
+    [listMode, getItemId, sortComparator, getItemVersion, applyMutation]
+  );
+  const removeItem = useCallback(
+    (id) => {
+      if (!listMode) return;
+      applyMutation((cur) => normalizedRemove(cur, id));
+    },
+    [listMode, applyMutation]
+  );
+  const addRef = useRef(addItem);
+  const updateRef = useRef(updateItem);
+  const removeRef = useRef(removeItem);
+  useEffect(() => {
+    addRef.current = addItem;
+  }, [addItem]);
+  useEffect(() => {
+    updateRef.current = updateItem;
+  }, [updateItem]);
+  useEffect(() => {
+    removeRef.current = removeItem;
+  }, [removeItem]);
+  useEffect(() => {
+    _registerUpdater(
+      storageKey,
+      {
+        add: (item) => addRef.current(item),
+        update: (item) => updateRef.current(item),
+        remove: (id) => removeRef.current(id)
+      },
+      listMode && !!sortComparator && !!getItemId ? {
+        comparator: sortComparator,
+        getItemId
+      } : null
+    );
+    return () => _unregisterUpdater(storageKey);
+  }, [storageKey]);
+  const data = viewData ?? (tqError ? fallbackData : void 0);
+  const isLoading = isCacheLoading || data === void 0 && isFetching;
+  const refetch = useCallback(() => {
+    setShouldFetch(true);
+    tqRefetch();
+  }, [tqRefetch]);
+  return {
+    data,
+    isLoading,
+    isFetching,
+    isFromCache,
+    isCacheLoading,
+    error: smartError,
+    refetch,
+    addItem,
+    updateItem,
+    removeItem
+  };
+}
+var invalidateSmartCache = (queryKey) => deleteCache(cacheKeyFor(queryKey));
+var clearAllSmartCache = () => storage.clearAll();
+function defaultIsOnline() {
+  if (typeof navigator !== "undefined" && "onLine" in navigator) {
+    return navigator.onLine;
+  }
+  return true;
+}
+function normalizeError2(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+function useSmartMutation(options) {
+  const {
+    queryKey,
+    mutationType,
+    mutationFn,
+    getItemId,
+    toItem,
+    enableOfflineQueue = true,
+    getEntityKey,
+    onSuccess,
+    onError,
+    isOnline = defaultIsOnline
+  } = options;
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState(null);
+  const isMounted = useRef(true);
+  const getActions = useCallback(
+    () => getSmartQueryActions(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const mutateAsync = useCallback(
+    async (item) => {
+      const actions = getActions();
+      const itemId = getItemId(item);
+      if (isMounted.current) {
+        setIsPending(true);
+        setError(null);
+      }
+      if (mutationType === "ADD_ITEM" || mutationType === "CUSTOM") {
+        await actions.addItem(item);
+      } else if (mutationType === "UPDATE_ITEM") {
+        await actions.updateItem(item);
+      } else if (mutationType === "REMOVE_ITEM") {
+        await actions.removeItem(itemId);
+      }
+      if (!isOnline()) {
+        if (enableOfflineQueue) {
+          await enqueueMutation({
+            type: mutationType,
+            queryKey,
+            payload: item,
+            entityKey: getEntityKey?.(item)
+          });
+        }
+        if (isMounted.current) setIsPending(false);
+        return;
+      }
+      try {
+        const response = await mutationFn(item);
+        const confirmedItem = toItem ? toItem(response) : response;
+        if (mutationType !== "REMOVE_ITEM") {
+          await actions.updateItem(confirmedItem);
+        }
+        emit({
+          type: "queue_success",
+          mutationId: `${mutationType}:${itemId}`
+        });
+        onSuccess?.(response, item);
+        void processQueue();
+      } catch (err) {
+        if (mutationType === "ADD_ITEM" || mutationType === "CUSTOM") {
+          await actions.removeItem(itemId);
+        } else if (mutationType === "UPDATE_ITEM") ; else if (mutationType === "REMOVE_ITEM") {
+          await actions.addItem(item);
+        }
+        const structured = normalizeError2(err);
+        if (isMounted.current) setError(structured);
+        onError?.(structured, item);
+      } finally {
+        if (isMounted.current) setIsPending(false);
+      }
+    },
+    [
+      getActions,
+      getItemId,
+      mutationType,
+      mutationFn,
+      toItem,
+      enableOfflineQueue,
+      getEntityKey,
+      isOnline,
+      onSuccess,
+      onError,
+      queryKey
+    ]
+  );
+  const mutate = useCallback(
+    (item) => {
+      void mutateAsync(item);
+    },
+    [mutateAsync]
+  );
+  const reset = useCallback(() => {
+    setError(null);
+    setIsPending(false);
+  }, []);
+  return { mutate, mutateAsync, isPending, error, reset };
+}
+init_requestLock_service();
+function normalizeError3(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+var DEFAULT_TTL2 = 5 * 6e4;
+function useInfiniteSmartQuery(options) {
+  const {
+    queryKey,
+    queryFn,
+    getNextCursor,
+    select,
+    getItemId,
+    getItemVersion,
+    sortComparator,
+    initialPageParam = void 0,
+    paginationMode = "normalized",
+    pageSize: pageSizeProp,
+    maxItems = 1e3,
+    cacheTtl = DEFAULT_TTL2,
+    strictFreshness = false,
+    onError
+  } = options;
+  const storageKey = useMemo(
+    () => cacheKeyFor(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const [infiniteData, setInfiniteData] = useState({
+    data: emptyList(),
+    meta: {
+      nextCursor: initialPageParam ?? null,
+      pageParams: []
+    }
+  });
+  const [pageSize, setPageSize] = useState(pageSizeProp);
+  const [isCacheLoading, setIsCacheLoading] = useState(true);
+  const [isFetchingNextPage, setIsFetchingNextPage] = useState(false);
+  const [isFetching, setIsFetching] = useState(false);
+  const [error, setError] = useState(null);
+  const infiniteRef = useRef(infiniteData);
+  function setAndNotify(next) {
+    infiniteRef.current = next;
+    setInfiniteData(next);
+  }
+  useEffect(() => {
+    let cancelled = false;
+    setIsCacheLoading(true);
+    readCache(storageKey, queryKey).then((entry) => {
+      if (cancelled) return;
+      if (entry !== null) {
+        const isStale = isCacheStale(entry, cacheTtl);
+        if (!strictFreshness || !isStale) {
+          setAndNotify(entry.data);
+        }
+      }
+      setIsCacheLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storageKey]);
+  const fetchPage = useCallback(
+    async (cursor) => {
+      const lockKey = `${storageKey}:${JSON.stringify(cursor)}`;
+      emit({ type: "fetch_start", queryKey });
+      try {
+        const raw = await fetchWithLock(lockKey, () => queryFn({ pageParam: cursor }));
+        const items = select(raw);
+        const nextCursor = getNextCursor(raw);
+        const pageIds = items.map(getItemId);
+        const pageById = fromArray(items, getItemId).byId;
+        const now = Date.now();
+        emit({ type: "fetch_success", queryKey, durationMs: 0 });
+        const current = infiniteRef.current;
+        const alreadyFetched = current.meta.pageParams.includes(cursor);
+        if (!pageSize && items.length > 0) {
+          setPageSize(items.length);
+        }
+        let mergedList = mergeNormalizedData(
+          current.data,
+          pageIds,
+          pageById,
+          getItemId,
+          sortComparator
+        );
+        mergedList = trimNormalizedList(mergedList, maxItems);
+        const next = {
+          data: mergedList,
+          meta: {
+            pageParams: alreadyFetched ? current.meta.pageParams : [...current.meta.pageParams, cursor],
+            nextCursor,
+            lastFetchedAt: now
+          }
+        };
+        setAndNotify(next);
+        void writeCache(storageKey, next, queryKey);
+        setError(null);
+      } catch (err) {
+        emit({ type: "fetch_error", queryKey, error: err });
+        const structured = normalizeError3(err);
+        setError(structured);
+        onError?.(structured);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey, queryFn, select, getNextCursor, getItemId, sortComparator, maxItems]
+  );
+  useEffect(() => {
+    if (isCacheLoading) return;
+    void (async () => {
+      setIsFetching(true);
+      await fetchPage(initialPageParam);
+      setIsFetching(false);
+    })();
+  }, [isCacheLoading]);
+  const inFlightRef = useRef(/* @__PURE__ */ new Set());
+  const fetchNextPage = useCallback(() => {
+    const { nextCursor, lastFetchedAt } = infiniteRef.current.meta;
+    if (nextCursor === null || isFetchingNextPage) return;
+    const cursorKey = JSON.stringify(nextCursor);
+    if (inFlightRef.current.has(cursorKey)) return;
+    if (lastFetchedAt && Date.now() - lastFetchedAt < 500) return;
+    void (async () => {
+      inFlightRef.current.add(cursorKey);
+      setIsFetchingNextPage(true);
+      await fetchPage(nextCursor);
+      setIsFetchingNextPage(false);
+      inFlightRef.current.delete(cursorKey);
+    })();
+  }, [fetchPage, isFetchingNextPage]);
+  const refetch = useCallback(() => {
+    void (async () => {
+      setIsFetching(true);
+      await fetchPage(initialPageParam);
+      setIsFetching(false);
+    })();
+  }, [fetchPage, initialPageParam]);
+  const applyItemMutation = useCallback(
+    (fn) => {
+      const current = infiniteRef.current;
+      const next = {
+        ...current,
+        data: fn(current.data)
+      };
+      setAndNotify(next);
+      void writeCache(storageKey, next, queryKey);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey]
+  );
+  const updateItem = useCallback(
+    (item) => {
+      applyItemMutation(
+        (data) => normalizedUpdate(
+          data,
+          item,
+          getItemId,
+          sortComparator ?? ((a, b) => 0),
+          getItemVersion
+        )
+      );
+    },
+    [getItemId, sortComparator, getItemVersion, applyItemMutation]
+  );
+  const addItem = useCallback(
+    (item) => {
+      const id = getItemId(item);
+      const current = infiniteRef.current;
+      if (id in current.data.byId) {
+        updateItem(item);
+        return;
+      }
+      applyItemMutation((data) => {
+        const next = normalizedAdd(
+          data,
+          item,
+          getItemId,
+          sortComparator ?? ((a, b) => 0),
+          getItemVersion
+        );
+        return trimNormalizedList(next, maxItems);
+      });
+    },
+    [getItemId, sortComparator, getItemVersion, applyItemMutation, updateItem, maxItems]
+  );
+  const removeItem = useCallback(
+    (id) => {
+      applyItemMutation((data) => normalizedRemove(data, id));
+    },
+    [applyItemMutation]
+  );
+  const flatData = useMemo(() => toArray(infiniteData.data), [infiniteData.data]);
+  const isLoading = isCacheLoading || flatData.length === 0 && isFetching;
+  const isRefreshing = !!(flatData.length > 0 && isFetching && !isFetchingNextPage);
+  const hasNextPage = infiniteRef.current.meta.nextCursor !== null;
+  const totalCount = infiniteData.data.allIds.length;
+  const derivedData = useMemo(() => {
+    if (paginationMode === "pages") {
+      return {
+        pages: derivePages(
+          infiniteData.data.allIds,
+          infiniteData.data.byId,
+          pageSize ?? flatData.length
+        )
+      };
+    }
+    return flatData;
+  }, [paginationMode, infiniteData.data.allIds, infiniteData.data.byId, pageSize, flatData]);
+  return {
+    data: derivedData,
+    isLoading,
+    isFetchingNextPage,
+    isFetching,
+    isRefreshing,
+    hasNextPage,
+    error,
+    totalCount,
+    fetchNextPage,
+    refetch,
+    addItem,
+    updateItem,
+    removeItem
+  };
+}
+function useSmartQuerySelector(queryKey, selector, equalityFn = equal) {
+  const queryClient = useQueryClient();
+  const selectedRef = useRef(selector(queryClient.getQueryData(queryKey)));
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      return queryClient.getQueryCache().subscribe((event) => {
+        if (event.type !== "updated" && event.type !== "added" && event.type !== "removed") return;
+        const cacheKey = JSON.stringify(queryKey);
+        const eventKey = JSON.stringify(event.query.queryKey);
+        if (cacheKey !== eventKey) return;
+        const newSelected = selector(queryClient.getQueryData(queryKey));
+        if (!equalityFn(selectedRef.current, newSelected)) {
+          selectedRef.current = newSelected;
+          onStoreChange();
+        }
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [queryClient, JSON.stringify(queryKey), selector, equalityFn]
+  );
+  const getSnapshot = useCallback(
+    () => selectedRef.current,
+    []
+  );
+  const getServerSnapshot = useCallback(
+    () => selector(void 0),
+    [selector]
+  );
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+// src/factory/createTypedQuery.ts
+function createTypedQuery(config) {
+  return {
+    useQuery(...args) {
+      const qk = config.queryKey(...args);
+      return useSmartQuery({
+        queryKey: qk,
+        queryFn: () => config.queryFn(...args),
+        select: config.select,
+        getItemId: config.getItemId,
+        sortComparator: config.sortComparator,
+        cacheTtl: config.cacheTtl,
+        strictFreshness: config.strictFreshness,
+        ...config.defaultOptions
+      });
+    },
+    useMutation(...argsAndOptions) {
+      const mutationOptions = argsAndOptions[argsAndOptions.length - 1];
+      const args = argsAndOptions.slice(0, -1);
+      const qk = config.queryKey(...args);
+      if (!config.getItemId) {
+        throw new Error(
+          "[SmartQuery] useMutation requires getItemId to be defined in createTypedQuery"
+        );
+      }
+      return useSmartMutation({
+        queryKey: qk,
+        getItemId: config.getItemId,
+        ...mutationOptions
+      });
+    },
+    getActions(...args) {
+      const qk = config.queryKey(...args);
+      return getSmartQueryActions(qk);
+    },
+    invalidate(...args) {
+      const qk = config.queryKey(...args);
+      return invalidateSmartCache(qk);
+    }
+  };
+}
+
+// src/index.ts
+init_requestLock_service();
+
+export { batchUpdate, clearAllSmartCache, createTypedQuery, emptyList, fromArray, getSmartQueryActions, invalidateSmartCache, isDataEqual, isNormalizedEmpty, normalizedAdd, normalizedRemove, normalizedUpdate, smartCompare, smartQueryDebug, toArray, trimNormalizedList, useInfiniteSmartQuery, useSmartMutation, useSmartQuery, useSmartQuerySelector };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map