sibujs 1.4.0 → 2.0.0

package/dist/{chunk-JAKHTMQU.js → chunk-JA6667UN.js}

@@ -1,19 +1,19 @@
 import {
   context
-} from "./chunk-BGN5ZMP4.js";
+} from "./chunk-GTBNNBJ6.js";
 import {
   derived
-} from "./chunk-NEKUBFPT.js";
+} from "./chunk-54EDRCEF.js";
 import {
   sanitizeUrl
-} from "./chunk-CMBFNA7L.js";
+} from "./chunk-UCS6AMJ7.js";
 import {
   effect
-} from "./chunk-CHF5OHIA.js";
+} from "./chunk-HB24TBAF.js";
 import {
   batch,
   signal
-} from "./chunk-WZSPOOER.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/data/retry.ts
 function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
@@ -30,10 +30,12 @@ function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
       break;
   }
   delay = Math.min(delay, maxDelay);
+  if (!Number.isFinite(delay)) delay = Number.MAX_SAFE_INTEGER;
   if (jitter > 0) {
     const jitterRange = delay * jitter;
     delay += (Math.random() * 2 - 1) * jitterRange;
   }
+  if (!Number.isFinite(delay) || Number.isNaN(delay)) delay = 0;
   return Math.max(0, delay);
 }
 async function withRetry(fn, options, onRetry, signal2) {
@@ -47,6 +49,7 @@ async function withRetry(fn, options, onRetry, signal2) {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
     try {
+      if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
       return await fn();
     } catch (error) {
       lastError = error;
@@ -54,9 +57,13 @@ async function withRetry(fn, options, onRetry, signal2) {
       const delay = calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter);
       onRetry?.(error, attempt, delay);
       await new Promise((resolve, reject) => {
-        const timer = setTimeout(resolve, delay);
+        let onAbort = null;
+        const timer = setTimeout(() => {
+          if (onAbort && signal2) signal2.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
         if (signal2) {
-          const onAbort = () => {
+          onAbort = () => {
             clearTimeout(timer);
             reject(new DOMException("Aborted", "AbortError"));
           };
@@ -124,24 +131,46 @@ function query(key, fetcher, options = {}) {
     let entry = queryCache.get(key2);
     if (!entry) {
       entry = getOrCreateEntry(key2);
-      entry.subscribers++;
       entry.listeners.add(onCacheUpdate);
       entry.refetchers.add(doFetch);
     }
     if (entry.promise) {
       setIsFetching(true);
+      const captured = entry.promise;
       try {
-        await entry.promise;
+        await captured;
+        if (disposed || currentKey !== key2) return;
+        if (entry.promise === captured) {
+          onCacheUpdate();
+          if (entry.error) onError?.(entry.error);
+          else if (entry.data !== void 0) onSuccess?.(entry.data);
+        }
       } catch {
+        if (disposed || currentKey !== key2) return;
+        if (entry.promise === captured) {
+          onCacheUpdate();
+          if (entry.error) onError?.(entry.error);
+        }
+      } finally {
+        if (!disposed && currentKey === key2) onSettled?.();
       }
-      onCacheUpdate();
       return;
     }
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
     setIsFetching(true);
-    const promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
+    let promise;
+    try {
+      promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
+    } catch (err) {
+      setIsFetching(false);
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      entry.error = errorObj;
+      onError?.(errorObj);
+      onSettled?.();
+      return;
+    }
     entry.promise = promise;
     try {
       const result = await promise;
@@ -203,13 +232,15 @@ function query(key, fetcher, options = {}) {
         oldEntry.subscribers--;
         if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
           const oldKey = currentKey;
+          if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
           oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
         }
       }
     }
+    const keyChanged = currentKey !== key2;
     currentKey = key2;
     const entry = getOrCreateEntry(key2, initialData);
-    entry.subscribers++;
+    if (keyChanged) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
       entry.gcTimer = null;
@@ -224,6 +255,11 @@ function query(key, fetcher, options = {}) {
         setError(entry.error);
       });
     }
+    if (!keyChanged && currentKey === key2 && entry.data !== void 0) {
+      const isDataStale2 = entry.dataUpdatedAt === 0 || Date.now() - entry.dataUpdatedAt >= staleTime;
+      if (enabled && isDataStale2 && !entry.promise) doFetch();
+      return;
+    }
     const isDataStale = entry.dataUpdatedAt === 0 || Date.now() - entry.dataUpdatedAt >= staleTime;
     if (enabled && (entry.data === void 0 || isDataStale)) {
       doFetch();
@@ -251,6 +287,7 @@ function query(key, fetcher, options = {}) {
     }
   }
   function dispose() {
+    if (disposed) return;
     disposed = true;
     abortController?.abort();
     effectCleanup();
@@ -263,12 +300,17 @@ function query(key, fetcher, options = {}) {
         entry.subscribers--;
         if (entry.subscribers <= 0 && cacheTime >= 0) {
           const key2 = currentKey;
+          if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
           entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
         }
       }
     }
-    if (focusHandler) globalThis.removeEventListener("focus", focusHandler);
-    if (onlineHandler) globalThis.removeEventListener("online", onlineHandler);
+    if (focusHandler && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("focus", focusHandler);
+    }
+    if (onlineHandler && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("online", onlineHandler);
+    }
   }
   return {
     data,
@@ -312,7 +354,19 @@ function clearQueryCache() {
   }
   queryCache.clear();
   for (const listener of activeListeners) listener();
-  for (const refetcher of activeRefetchers) refetcher();
+  for (const refetcher of activeRefetchers) {
+    refetcher().catch((err) => {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS query] refetch after clearQueryCache failed:", err);
+      }
+    });
+  }
+}
+function __resetQueryCache() {
+  for (const entry of queryCache.values()) {
+    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+  }
+  queryCache.clear();
 }
 
 // src/data/mutation.ts
@@ -323,7 +377,9 @@ function mutation(mutationFn, options = {}) {
   const [status, setStatus] = signal("idle");
   const isSuccess = derived(() => status() === "success");
   const isIdle = derived(() => status() === "idle");
+  let runId = 0;
   async function execute(variables) {
+    const myRun = ++runId;
     let context2;
     batch(() => {
       setLoading(true);
@@ -335,6 +391,7 @@ function mutation(mutationFn, options = {}) {
         context2 = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables), options.retry);
+      if (myRun !== runId) return result;
       batch(() => {
         setData(result);
         setLoading(false);
@@ -345,6 +402,7 @@ function mutation(mutationFn, options = {}) {
       return result;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
+      if (myRun !== runId) throw errorObj;
       batch(() => {
         setError(errorObj);
         setLoading(false);
@@ -356,6 +414,7 @@ function mutation(mutationFn, options = {}) {
     }
   }
   function reset() {
+    runId++;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -370,7 +429,10 @@ function mutation(mutationFn, options = {}) {
     isSuccess,
     isIdle,
     mutate: (variables) => {
-      execute(variables).catch(() => {
+      execute(variables).catch((err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
+        }
       });
     },
     mutateAsync: execute,
@@ -406,11 +468,13 @@ function infiniteQuery(key, fetcher, options) {
   const hasPreviousPage = derived(() => prevPageParam() !== void 0);
   let abortController = null;
   let disposed = false;
+  let runId = 0;
   async function fetchPage(pageParam, direction) {
     if (disposed) return;
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
+    const myRun = ++runId;
     batch(() => {
       setIsFetching(true);
       if (direction === "next") setIsFetchingNext(true);
@@ -419,7 +483,7 @@ function infiniteQuery(key, fetcher, options) {
     });
     try {
       const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
-      if (disposed) return;
+      if (disposed || myRun !== runId) return;
       const currentPages = pages();
       let newPages;
       if (direction === "prev") {
@@ -439,7 +503,7 @@ function infiniteQuery(key, fetcher, options) {
       });
       onSuccess?.(newPages);
     } catch (err) {
-      if (disposed) return;
+      if (disposed || myRun !== runId) return;
       if (err instanceof DOMException && err.name === "AbortError") return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
       batch(() => {
@@ -454,9 +518,12 @@ function infiniteQuery(key, fetcher, options) {
   const effectCleanup = effect(() => {
     resolveKey();
     if (enabled) {
-      setPages([]);
-      setNextPageParam(initialPageParam);
-      setPrevPageParam(void 0);
+      abortController?.abort();
+      batch(() => {
+        setPages([]);
+        setNextPageParam(initialPageParam);
+        setPrevPageParam(void 0);
+      });
       fetchPage(initialPageParam, "initial");
     }
   });
@@ -605,7 +672,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       options.onSuccess?.(result);
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
+      if (err instanceof DOMException && err.name === "AbortError") {
+        if (version === fetchVersion) setLoading(false);
+        return;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
       batch(() => {
         setError(errorObj);
@@ -690,18 +760,57 @@ function idbPut(db, store, item) {
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbDelete(db, store, key) {
+function idbPutWithChange(db, item, change) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(["items", "_changes"], "readwrite");
+    tx.objectStore("items").put(item);
+    tx.objectStore("_changes").put(change);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbDeleteWithChange(db, key, change) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(["items", "_changes"], "readwrite");
+    tx.objectStore("items").delete(key);
+    tx.objectStore("_changes").put(change);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbGetAllWithKeys(db, store) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const out = [];
+    const req = tx.objectStore(store).openCursor();
+    req.onsuccess = () => {
+      const cursor = req.result;
+      if (cursor) {
+        out.push({ key: cursor.primaryKey, value: cursor.value });
+        cursor.continue();
+      } else {
+        resolve(out);
+      }
+    };
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbDeleteKeys(db, store, keys) {
+  if (keys.length === 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).delete(key);
+    const objStore = tx.objectStore(store);
+    for (const k of keys) objStore.delete(k);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbClear(db, store) {
+function idbPutMany(db, store, items) {
+  if (items.length === 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).clear();
+    const objStore = tx.objectStore(store);
+    for (const item of items) objStore.put(item);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
@@ -724,15 +833,13 @@ async function offlineStore(options) {
     setPendingCount(changes.length);
   }
   async function put(item) {
-    await idbPut(db, "items", item);
-    await idbPut(db, "_changes", { type: "put", item, timestamp: Date.now() });
+    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() });
     await refreshData();
   }
   async function remove(key) {
     const existing = await idbGet(db, "items", key);
     if (existing) {
-      await idbDelete(db, "items", key);
-      await idbPut(db, "_changes", { type: "delete", item: existing, timestamp: Date.now() });
+      await idbDeleteWithChange(db, key, { type: "delete", item: existing, timestamp: Date.now() });
       await refreshData();
     }
   }
@@ -743,25 +850,45 @@ async function offlineStore(options) {
     return data().filter(filter);
   }
   async function sync() {
-    if (!adapter || isSyncing()) return;
+    if (!adapter || isSyncing() || closed) return;
     setIsSyncing(true);
     try {
-      const changes = await idbGetAll(db, "_changes");
-      if (changes.length > 0) {
-        const result = await adapter.push(changes);
+      const snapshot = await idbGetAllWithKeys(db, "_changes");
+      if (closed) return;
+      if (snapshot.length > 0) {
+        const result = await adapter.push(snapshot.map((e) => e.value));
+        if (closed) return;
         if (result.ok) {
-          await idbClear(db, "_changes");
+          await idbDeleteKeys(
+            db,
+            "_changes",
+            snapshot.map((e) => e.key)
+          );
+          if (closed) return;
         }
       }
       const remoteItems = await adapter.pull(lastSynced());
-      for (const item of remoteItems) {
-        await idbPut(db, "items", item);
+      if (closed) return;
+      const pendingChanges = await idbGetAll(db, "_changes");
+      if (closed) return;
+      const pendingKeys = /* @__PURE__ */ new Set();
+      for (const c of pendingChanges) {
+        const k = c.item[keyPath];
+        if (k != null) pendingKeys.add(k);
       }
+      const safeRemote = remoteItems.filter((item) => {
+        const k = item[keyPath];
+        return k == null || !pendingKeys.has(k);
+      });
+      await idbPutMany(db, "items", safeRemote);
+      if (closed) return;
       const now = Date.now();
       await idbPut(db, "_meta", now);
+      if (closed) return;
       setLastSynced(now);
       await refreshData();
-    } catch {
+    } catch (err) {
+      if (typeof console !== "undefined") console.warn("[offlineStore] sync failed", err);
     } finally {
       setIsSyncing(false);
     }
@@ -769,13 +896,21 @@ async function offlineStore(options) {
   function attach(newAdapter) {
     adapter = newAdapter;
   }
+  let onlineHandler = null;
+  let closed = false;
   function close() {
+    closed = true;
+    if (onlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", onlineHandler);
+      onlineHandler = null;
+    }
     db.close();
   }
   if (autoSync && typeof window !== "undefined") {
-    window.addEventListener("online", () => {
+    onlineHandler = () => {
       sync();
-    });
+    };
+    window.addEventListener("online", onlineHandler);
   }
   return {
     data,
@@ -813,9 +948,16 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2) {
+async function preloadRoute(route, context2, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
+  if (callerSignal) {
+    if (callerSignal.aborted) {
+      controller.abort();
+    } else {
+      callerSignal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+  }
   return route.loader(context2, { signal: controller.signal });
 }
 
@@ -830,7 +972,7 @@ function validateWsUrl(raw) {
 function socket(url, options) {
   const autoReconnect = options?.autoReconnect ?? false;
   const reconnectDelay = options?.reconnectDelay ?? 1e3;
-  const maxReconnects = options?.maxReconnects ?? Infinity;
+  const maxReconnects = options?.maxReconnects ?? 10;
   const heartbeat = options?.heartbeat;
   const protocols = options?.protocols;
   const [data, setData] = signal(null);
@@ -840,6 +982,7 @@ function socket(url, options) {
   let reconnectTimer = null;
   let heartbeatTimer = null;
   let disposed = false;
+  let manuallyClosed = false;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
@@ -863,11 +1006,18 @@ function socket(url, options) {
     ws.onclose = () => {
       setStatus("closed");
       stopHeartbeat();
-      if (autoReconnect && !disposed && reconnectCount < maxReconnects) {
+      const wasManual = manuallyClosed;
+      manuallyClosed = false;
+      if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
+        const cap = 3e4;
+        const delay = Math.min(cap, reconnectDelay * 2 ** reconnectCount);
+        const jittered = delay * (0.5 + Math.random() * 0.5);
         reconnectCount++;
         reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          if (disposed || manuallyClosed) return;
           connect();
-        }, reconnectDelay);
+        }, jittered);
       }
     };
     ws.onerror = () => {
@@ -894,6 +1044,7 @@ function socket(url, options) {
     }
   }
   function close() {
+    manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
@@ -920,12 +1071,16 @@ function validateSseUrl(raw) {
 }
 function stream(url, options) {
   const autoReconnect = options?.autoReconnect ?? false;
+  const maxReconnects = options?.maxReconnects ?? 10;
+  const baseMs = options?.reconnectBaseMs ?? 1e3;
+  const maxMs = options?.reconnectMaxMs ?? 3e4;
   const [data, setData] = signal(null);
   const [event, setEvent] = signal(null);
   const [status, setStatus] = signal("connecting");
   let source = null;
   let disposed = false;
   let reconnectTimer = null;
+  let attempts = 0;
   function connect() {
     if (disposed) return;
     const safeUrl = validateSseUrl(url);
@@ -939,6 +1094,7 @@ function stream(url, options) {
     });
     source.onopen = () => {
       setStatus("open");
+      attempts = 0;
     };
     source.onmessage = (evt) => {
       setData(evt.data);
@@ -948,11 +1104,14 @@ function stream(url, options) {
       if (source && source.readyState === EventSource.CLOSED) {
         setStatus("closed");
         source = null;
-        if (autoReconnect && !disposed) {
+        if (autoReconnect && !disposed && attempts < maxReconnects) {
+          const delay = Math.min(maxMs, baseMs * 2 ** attempts);
+          const jittered = delay * (0.5 + Math.random() * 0.5);
+          attempts++;
           reconnectTimer = setTimeout(() => {
             reconnectTimer = null;
             connect();
-          }, 1e3);
+          }, jittered);
         }
       }
     };
@@ -984,6 +1143,7 @@ export {
   getQueryData,
   setQueryData,
   clearQueryCache,
+  __resetQueryCache,
   mutation,
   infiniteQuery,
   previous,