sibujs 3.4.1 → 4.0.1

package/dist/{chunk-MPE75KOA.js → chunk-HPXTUPJD.js}

@@ -1,25 +1,69 @@
 import {
   context
-} from "./chunk-6CAJU5TP.js";
+} from "./chunk-XET2RUJF.js";
 import {
   derived
-} from "./chunk-4I3M326N.js";
+} from "./chunk-AD5YSZAN.js";
+import {
+  sanitizeUrl
+} from "./chunk-5INI7D2L.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
-import {
-  sanitizeUrl
-} from "./chunk-L3GAGWCC.js";
 import {
   effect
-} from "./chunk-X4JS367G.js";
+} from "./chunk-XDOMTQHM.js";
 import {
   getRequestScopedCache
-} from "./chunk-S3NFJO6L.js";
+} from "./chunk-TIRZCERI.js";
 import {
   batch,
   signal
-} from "./chunk-335KJEN2.js";
+} from "./chunk-TVURNWDK.js";
+
+// src/data/abort.ts
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+function createAbortError(message = "Aborted") {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(message, "AbortError");
+  }
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+// src/data/callbacks.ts
+function reportCallbackError(label, error) {
+  if (typeof console !== "undefined") {
+    console.error(`[SibuJS data] ${label} threw. The operation's own status is unaffected.`, error);
+  }
+}
+function runCallback(label, fn) {
+  try {
+    fn();
+  } catch (error) {
+    reportCallbackError(label, error);
+  }
+}
+function runSelect(label, fn) {
+  try {
+    return { ok: true, value: fn() };
+  } catch (error) {
+    reportCallbackError(label, error);
+    return { ok: false };
+  }
+}
+function notifyListeners(listeners, label) {
+  for (const listener of Array.from(listeners)) {
+    try {
+      listener();
+    } catch (error) {
+      reportCallbackError(label, error);
+    }
+  }
+}
 
 // src/data/retry.ts
 function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
@@ -53,39 +97,54 @@ async function withRetry(fn, options, onRetry, signal2) {
   const shouldRetry = options?.shouldRetry ?? (() => true);
   let lastError;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
+    if (signal2?.aborted) throw createAbortError();
     try {
-      if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
       return await fn();
     } catch (error) {
       lastError = error;
+      if (signal2?.aborted) throw createAbortError();
+      if (isAbortError(error)) throw error;
       if (attempt >= maxRetries || !shouldRetry(error, attempt)) throw error;
       const delay = calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter);
       onRetry?.(error, attempt, delay);
-      await new Promise((resolve, reject) => {
-        let onAbort = null;
-        const timer = setTimeout(() => {
-          if (onAbort && signal2) signal2.removeEventListener("abort", onAbort);
-          resolve();
-        }, delay);
-        if (signal2) {
-          onAbort = () => {
-            clearTimeout(timer);
-            reject(new DOMException("Aborted", "AbortError"));
-          };
-          signal2.addEventListener("abort", onAbort, { once: true });
-        }
-      });
+      await waitForRetryDelay(delay, signal2);
     }
   }
   throw lastError;
 }
+function waitForRetryDelay(delay, signal2) {
+  if (signal2?.aborted) return Promise.reject(createAbortError());
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (action) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal2) signal2.removeEventListener("abort", onAbort);
+      action();
+    };
+    const onAbort = () => finish(() => reject(createAbortError()));
+    const timer = setTimeout(() => finish(resolve), delay);
+    if (signal2) {
+      signal2.addEventListener("abort", onAbort, { once: true });
+      if (signal2.aborted) onAbort();
+    }
+  });
+}
 
 // src/data/query.ts
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
   return getRequestScopedCache("query") ?? globalQueryCache;
 }
+function abandonEntry(entry) {
+  if (entry.gcTimer) clearTimeout(entry.gcTimer);
+  entry.gcTimer = null;
+  entry.controller?.abort();
+  entry.controller = null;
+  entry.promise = null;
+  entry.generation++;
+}
 function getOrCreateEntry(cache, key, initialData) {
   let entry = cache.get(key);
   if (!entry) {
@@ -97,7 +156,9 @@ function getOrCreateEntry(cache, key, initialData) {
       gcTimer: null,
       promise: null,
       listeners: /* @__PURE__ */ new Set(),
-      refetchers: /* @__PURE__ */ new Set()
+      refetchers: /* @__PURE__ */ new Set(),
+      controller: null,
+      generation: 0
     };
     cache.set(key, entry);
   }
@@ -123,9 +184,10 @@ function query(key, fetcher, options = {}) {
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
-  let abortController = null;
   let disposed = false;
   let currentKey = null;
+  let attachedEntry = null;
+  let attachedKey = null;
   let intervalTimer = null;
   const loading = derived(() => isFetching() && data() === void 0);
   const isStale = derived(() => {
@@ -135,82 +197,128 @@ function query(key, fetcher, options = {}) {
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
+  function detachFromEntry() {
+    const entry = attachedEntry;
+    const key2 = attachedKey;
+    if (!entry) return;
+    attachedEntry = null;
+    attachedKey = null;
+    entry.listeners.delete(onCacheUpdate);
+    entry.refetchers.delete(doFetch);
+    entry.subscribers = Math.max(0, entry.subscribers - 1);
+    if (entry.subscribers > 0 || cacheTime < 0 || key2 === null) return;
+    if (cache.get(key2) !== entry) return;
+    if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
+    entry.gcTimer = setTimeout(() => {
+      const current = cache.get(key2);
+      if (current === entry && current.subscribers <= 0) {
+        abandonEntry(current);
+        cache.delete(key2);
+      }
+    }, cacheTime);
+    entry.gcTimer.unref?.();
+  }
+  function attachToEntry(entry, key2) {
+    if (attachedEntry === entry) {
+      if (entry.gcTimer !== null) {
+        clearTimeout(entry.gcTimer);
+        entry.gcTimer = null;
+      }
+      return;
+    }
+    detachFromEntry();
+    attachedEntry = entry;
+    attachedKey = key2;
+    entry.subscribers++;
+    entry.listeners.add(onCacheUpdate);
+    entry.refetchers.add(doFetch);
+    if (entry.gcTimer !== null) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = null;
+    }
+  }
   async function doFetch() {
     if (disposed || !currentKey || !enabled) return;
     const key2 = currentKey;
-    let entry = cache.get(key2);
-    if (!entry) {
-      entry = getOrCreateEntry(cache, key2);
-      entry.listeners.add(onCacheUpdate);
-      entry.refetchers.add(doFetch);
-    }
+    const entry = getOrCreateEntry(cache, key2);
+    attachToEntry(entry, key2);
     if (entry.promise) {
       setIsFetching(true);
       const captured = entry.promise;
       try {
         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) {
+      } finally {
+        if (!disposed && currentKey === key2) {
           onCacheUpdate();
-          if (entry.error) onError?.(entry.error);
+          if (entry.error) {
+            const settledError = entry.error;
+            runCallback("query onError", () => onError?.(settledError));
+          } else if (entry.data !== void 0) {
+            const settledData = entry.data;
+            runCallback("query onSuccess", () => onSuccess?.(settledData));
+          }
+          runCallback("query onSettled", () => onSettled?.());
         }
-      } finally {
-        if (!disposed && currentKey === key2) onSettled?.();
       }
       return;
     }
-    abortController?.abort();
-    abortController = new AbortController();
-    const signal2 = abortController.signal;
+    entry.controller = new AbortController();
+    const signal2 = entry.controller.signal;
+    const generation = ++entry.generation;
     setIsFetching(true);
     let promise;
     try {
       promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
     } catch (err) {
       setIsFetching(false);
+      if (isAbortError(err)) return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
       entry.error = errorObj;
-      onError?.(errorObj);
-      onSettled?.();
+      runCallback("query onError", () => onError?.(errorObj));
+      runCallback("query onSettled", () => onSettled?.());
       return;
     }
     entry.promise = promise;
     try {
       const result = await promise;
+      if (entry.generation !== generation) return;
       entry.promise = null;
-      if (disposed || currentKey !== key2) return;
+      entry.controller = null;
       entry.data = result;
       entry.dataUpdatedAt = Date.now();
       entry.error = void 0;
-      const selected = select ? select(result) : result;
+      notifyListeners(entry.listeners, "query cache listener");
+      if (disposed || currentKey !== key2) return;
+      const selected = runSelect("query select", () => select ? select(result) : result);
       batch(() => {
-        setData(selected);
+        if (selected.ok) setData(selected.value);
         setIsFetching(false);
         setError(void 0);
       });
-      for (const listener of entry.listeners) listener();
-      onSuccess?.(result);
+      runCallback("query onSuccess", () => onSuccess?.(result));
     } catch (err) {
+      if (entry.generation !== generation) return;
       entry.promise = null;
-      if (disposed || currentKey !== key2) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
+      entry.controller = null;
+      if (isAbortError(err)) {
+        notifyListeners(entry.listeners, "query cache listener");
+        if (!disposed && currentKey === key2) setIsFetching(false);
+        return;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
       entry.error = errorObj;
+      notifyListeners(entry.listeners, "query cache listener");
+      if (disposed || currentKey !== key2) return;
       batch(() => {
         setError(errorObj);
         setIsFetching(false);
       });
-      for (const listener of entry.listeners) listener();
-      onError?.(errorObj);
+      runCallback("query onError", () => onError?.(errorObj));
     } finally {
-      if (!disposed && currentKey === key2) onSettled?.();
+      if (!disposed && currentKey === key2 && entry.generation === generation) {
+        runCallback("query onSettled", () => onSettled?.());
+      }
     }
   }
   function onCacheUpdate() {
@@ -225,43 +333,24 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const raw = entry.data;
-    const selected = raw !== void 0 && select ? select(raw) : raw;
+    const selected = raw !== void 0 && select ? runSelect("query select", () => select(raw)) : { ok: true, value: raw };
     batch(() => {
-      setData(selected);
+      if (selected.ok) setData(selected.value);
       setError(entry.error);
       if (!entry.promise) setIsFetching(false);
     });
   }
   const effectCleanup = effect(() => {
     const key2 = resolveKey();
-    if (currentKey !== null && currentKey !== key2) {
-      const oldEntry = cache.get(currentKey);
-      if (oldEntry) {
-        oldEntry.listeners.delete(onCacheUpdate);
-        oldEntry.refetchers.delete(doFetch);
-        oldEntry.subscribers--;
-        if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
-          const oldKey = currentKey;
-          if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
-          oldEntry.gcTimer = setTimeout(() => cache.delete(oldKey), cacheTime);
-        }
-      }
-    }
     const keyChanged = currentKey !== key2;
     currentKey = key2;
     const entry = getOrCreateEntry(cache, key2, initialData);
-    if (keyChanged) entry.subscribers++;
-    if (entry.gcTimer !== null) {
-      clearTimeout(entry.gcTimer);
-      entry.gcTimer = null;
-    }
-    entry.listeners.add(onCacheUpdate);
-    entry.refetchers.add(doFetch);
+    attachToEntry(entry, key2);
     if (entry.data !== void 0) {
       const raw = entry.data;
-      const selected = select ? select(raw) : raw;
+      const selected = runSelect("query select", () => select ? select(raw) : raw);
       batch(() => {
-        setData(selected);
+        if (selected.ok) setData(selected.value);
         setError(entry.error);
       });
     }
@@ -299,22 +388,9 @@ function query(key, fetcher, options = {}) {
   function dispose() {
     if (disposed) return;
     disposed = true;
-    abortController?.abort();
     effectCleanup();
     if (intervalTimer) clearInterval(intervalTimer);
-    if (currentKey) {
-      const entry = cache.get(currentKey);
-      if (entry) {
-        entry.listeners.delete(onCacheUpdate);
-        entry.refetchers.delete(doFetch);
-        entry.subscribers--;
-        if (entry.subscribers <= 0 && cacheTime >= 0) {
-          const key2 = currentKey;
-          if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
-          entry.gcTimer = setTimeout(() => cache.delete(key2), cacheTime);
-        }
-      }
-    }
+    detachFromEntry();
     if (focusHandler && typeof globalThis.removeEventListener === "function") {
       globalThis.removeEventListener("focus", focusHandler);
     }
@@ -350,21 +426,21 @@ function setQueryData(key, data) {
   const newData = typeof data === "function" ? data(entry.data) : data;
   entry.data = newData;
   entry.dataUpdatedAt = Date.now();
-  for (const listener of entry.listeners) listener();
+  notifyListeners(entry.listeners, "query cache listener");
 }
 function clearQueryCache() {
   const activeListeners = [];
   const activeRefetchers = [];
   const activeCache = getActiveQueryCache();
   for (const entry of activeCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
     if (entry.subscribers > 0) {
       for (const listener of entry.listeners) activeListeners.push(listener);
       for (const refetcher of entry.refetchers) activeRefetchers.push(refetcher);
     }
+    abandonEntry(entry);
   }
   activeCache.clear();
-  for (const listener of activeListeners) listener();
+  notifyListeners(activeListeners, "query cache listener");
   for (const refetcher of activeRefetchers) {
     refetcher().catch((err) => {
       if (typeof console !== "undefined") {
@@ -376,7 +452,7 @@ function clearQueryCache() {
 function __resetQueryCache() {
   const activeCache = getActiveQueryCache();
   for (const entry of activeCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+    abandonEntry(entry);
   }
   activeCache.clear();
 }
@@ -391,6 +467,8 @@ function mutation(mutationFn, options = {}) {
   const isIdle = derived(() => status() === "idle");
   let runId = 0;
   let abortController = null;
+  let terminalStatus = "idle";
+  let terminalError;
   async function execute(variables) {
     abortController?.abort();
     abortController = new AbortController();
@@ -408,25 +486,38 @@ function mutation(mutationFn, options = {}) {
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
+      terminalStatus = "success";
+      terminalError = void 0;
       batch(() => {
         setData(result);
         setLoading(false);
         setStatus("success");
       });
-      options.onSuccess?.(result, variables, context2);
-      options.onSettled?.(result, void 0, variables, context2);
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
       return result;
     } catch (err) {
+      if (isAbortError(err)) {
+        if (myRun === runId) {
+          batch(() => {
+            setLoading(false);
+            setError(terminalError);
+            setStatus(terminalStatus);
+          });
+        }
+        throw err;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      if (errorObj instanceof DOMException && errorObj.name === "AbortError") throw errorObj;
       if (myRun !== runId) throw errorObj;
+      terminalStatus = "error";
+      terminalError = errorObj;
       batch(() => {
         setError(errorObj);
         setLoading(false);
         setStatus("error");
       });
-      options.onError?.(errorObj, variables, context2);
-      options.onSettled?.(void 0, errorObj, variables, context2);
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
       throw errorObj;
     }
   }
@@ -434,6 +525,8 @@ function mutation(mutationFn, options = {}) {
     runId++;
     abortController?.abort();
     abortController = null;
+    terminalStatus = "idle";
+    terminalError = void 0;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -449,7 +542,7 @@ function mutation(mutationFn, options = {}) {
     isIdle,
     mutate: (variables) => {
       execute(variables).catch((err) => {
-        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (isAbortError(err)) return;
         if (typeof console !== "undefined") {
           console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
         }
@@ -522,10 +615,17 @@ function infiniteQuery(key, fetcher, options) {
           setIsFetchingNext(false);
           setIsFetchingPrev(false);
         });
-        onSuccess?.(newPages);
+        runCallback("infiniteQuery onSuccess", () => onSuccess?.(newPages));
       } catch (err) {
         if (disposed || myRun !== runId) return;
-        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (isAbortError(err)) {
+          batch(() => {
+            setIsFetching(false);
+            setIsFetchingNext(false);
+            setIsFetchingPrev(false);
+          });
+          return;
+        }
         const errorObj = err instanceof Error ? err : new Error(String(err));
         batch(() => {
           setError(errorObj);
@@ -533,7 +633,7 @@ function infiniteQuery(key, fetcher, options) {
           setIsFetchingNext(false);
           setIsFetchingPrev(false);
         });
-        onError?.(errorObj);
+        runCallback("infiniteQuery onError", () => onError?.(errorObj));
       }
     })();
     inFlight = promise;
@@ -715,7 +815,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       setLoading(true);
       setError(void 0);
     });
-    options.onStart?.();
+    runCallback("resource onStart", () => options.onStart?.());
     try {
       const result = await withRetry(() => fetcher(sourceValue, { signal: signal2, prev }), options.retry, void 0, signal2);
       if (version !== fetchVersion || disposed) return;
@@ -724,10 +824,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
         setData(result);
         setLoading(false);
       });
-      options.onSuccess?.(result);
+      runCallback("resource onSuccess", () => options.onSuccess?.(result));
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
-      if (err instanceof DOMException && err.name === "AbortError") {
+      if (isAbortError(err)) {
         if (version === fetchVersion) setLoading(false);
         return;
       }
@@ -736,10 +836,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
         setError(errorObj);
         setLoading(false);
       });
-      options.onError?.(errorObj);
+      runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
       if (version === fetchVersion) {
-        options.onSettled?.();
+        runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
   }
@@ -927,13 +1027,14 @@ async function offlineStore(options) {
     return data().filter(filter);
   }
   async function sync() {
-    if (!adapter || isSyncing() || closed) return;
+    const syncAdapter2 = adapter;
+    if (!syncAdapter2 || isSyncing() || closed) return;
     setIsSyncing(true);
     try {
       const snapshot = await idbGetAllWithKeys(db, "_changes");
       if (closed) return;
       if (snapshot.length > 0) {
-        const result = await adapter.push(snapshot.map((e) => e.value));
+        const result = await syncAdapter2.push(snapshot.map((e) => e.value));
         if (closed) return;
         if (result.ok) {
           await idbDeleteKeys(
@@ -946,20 +1047,18 @@ async function offlineStore(options) {
           console.warn(`[offlineStore] push rejected by adapter${result.error ? `: ${result.error}` : ""}`);
         }
       }
-      const remoteItems = await adapter.pull(lastSynced());
+      const remoteItems = await syncAdapter2.pull(lastSynced());
       if (closed) return;
       const pendingChanges = await idbGetAll(db, "_changes");
       if (closed) return;
-      const pendingKeys = /* @__PURE__ */ new Set();
+      const pendingByKey = /* @__PURE__ */ new Map();
       for (const c of pendingChanges) {
         const k = c.item[keyPath];
-        if (k != null) pendingKeys.add(k);
+        if (k != null) pendingByKey.set(k, c);
       }
-      const safeRemote = remoteItems.filter((item) => {
-        const k = item[keyPath];
-        return k == null || !pendingKeys.has(k);
-      });
-      await idbPutMany(db, "items", safeRemote);
+      const resolved = await resolveRemoteItems(syncAdapter2, remoteItems, pendingByKey);
+      if (closed) return;
+      await idbPutMany(db, "items", resolved);
       if (closed) return;
       const now = Date.now();
       await idbPut(db, "_meta", now, "lastSynced");
@@ -972,6 +1071,42 @@ async function offlineStore(options) {
       setIsSyncing(false);
     }
   }
+  async function resolveRemoteItems(activeAdapter, remoteItems, pendingByKey) {
+    const strategy = activeAdapter.conflictStrategy ?? "client-wins";
+    const out = [];
+    for (const remote of remoteItems) {
+      const key = remote[keyPath];
+      const pending = key == null ? void 0 : pendingByKey.get(key);
+      if (!pending) {
+        out.push(remote);
+        continue;
+      }
+      if (strategy === "server-wins") {
+        out.push(remote);
+        continue;
+      }
+      if (strategy === "manual") {
+        if (!activeAdapter.resolveConflict) {
+          if (typeof console !== "undefined") {
+            console.warn(
+              '[offlineStore] conflictStrategy is "manual" but the adapter has no resolveConflict(); keeping the local record for this key (client-wins).'
+            );
+          }
+          continue;
+        }
+        try {
+          const local = pending.type === "delete" ? void 0 : await idbGet(db, "items", key);
+          const choice = await activeAdapter.resolveConflict({ key, local, remote, pending });
+          if (choice !== void 0) out.push(choice);
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[offlineStore] resolveConflict threw; keeping the local record", err);
+          }
+        }
+      }
+    }
+    return out;
+  }
   function attach(newAdapter) {
     adapter = newAdapter;
   }