sibujs 3.1.0 → 3.2.0

package/dist/{chunk-PMSDFTK3.js → chunk-VOCE4NNK.js}

@@ -1,19 +1,22 @@
 import {
   context
-} from "./chunk-EFOAE5NC.js";
+} from "./chunk-YFDGQWDA.js";
 import {
   derived
-} from "./chunk-SC437AMI.js";
+} from "./chunk-JYXOEYI4.js";
 import {
   sanitizeUrl
-} from "./chunk-UCS6AMJ7.js";
+} from "./chunk-HMJFCBRR.js";
 import {
   effect
-} from "./chunk-ZIBE2SAT.js";
+} from "./chunk-FDY42FIU.js";
+import {
+  getRequestScopedCache
+} from "./chunk-GOJMFRBL.js";
 import {
   batch,
   signal
-} from "./chunk-RK4BQG25.js";
+} from "./chunk-C427DVQF.js";
 
 // src/data/retry.ts
 function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
@@ -76,9 +79,12 @@ async function withRetry(fn, options, onRetry, signal2) {
 }
 
 // src/data/query.ts
-var queryCache = /* @__PURE__ */ new Map();
-function getOrCreateEntry(key, initialData) {
-  let entry = queryCache.get(key);
+var globalQueryCache = /* @__PURE__ */ new Map();
+function getActiveQueryCache() {
+  return getRequestScopedCache("query") ?? globalQueryCache;
+}
+function getOrCreateEntry(cache, key, initialData) {
+  let entry = cache.get(key);
   if (!entry) {
     entry = {
       data: initialData,
@@ -90,7 +96,7 @@ function getOrCreateEntry(key, initialData) {
       listeners: /* @__PURE__ */ new Set(),
       refetchers: /* @__PURE__ */ new Set()
     };
-    queryCache.set(key, entry);
+    cache.set(key, entry);
   }
   return entry;
 }
@@ -110,6 +116,7 @@ function query(key, fetcher, options = {}) {
     select
   } = options;
   const resolveKey = typeof key === "function" ? key : () => key;
+  const cache = getActiveQueryCache();
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
@@ -121,16 +128,16 @@ function query(key, fetcher, options = {}) {
   const isStale = derived(() => {
     data();
     if (!currentKey) return true;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
   async function doFetch() {
     if (disposed || !currentKey || !enabled) return;
     const key2 = currentKey;
-    let entry = queryCache.get(key2);
+    let entry = cache.get(key2);
     if (!entry) {
-      entry = getOrCreateEntry(key2);
+      entry = getOrCreateEntry(cache, key2);
       entry.listeners.add(onCacheUpdate);
       entry.refetchers.add(doFetch);
     }
@@ -205,7 +212,7 @@ function query(key, fetcher, options = {}) {
   }
   function onCacheUpdate() {
     if (disposed || !currentKey) return;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry) {
       batch(() => {
         setData(void 0);
@@ -225,7 +232,7 @@ function query(key, fetcher, options = {}) {
   const effectCleanup = effect(() => {
     const key2 = resolveKey();
     if (currentKey !== null && currentKey !== key2) {
-      const oldEntry = queryCache.get(currentKey);
+      const oldEntry = cache.get(currentKey);
       if (oldEntry) {
         oldEntry.listeners.delete(onCacheUpdate);
         oldEntry.refetchers.delete(doFetch);
@@ -233,13 +240,13 @@ function query(key, fetcher, options = {}) {
         if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
           const oldKey = currentKey;
           if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
-          oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
+          oldEntry.gcTimer = setTimeout(() => cache.delete(oldKey), cacheTime);
         }
       }
     }
     const keyChanged = currentKey !== key2;
     currentKey = key2;
-    const entry = getOrCreateEntry(key2, initialData);
+    const entry = getOrCreateEntry(cache, key2, initialData);
     if (keyChanged) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
@@ -293,7 +300,7 @@ function query(key, fetcher, options = {}) {
     effectCleanup();
     if (intervalTimer) clearInterval(intervalTimer);
     if (currentKey) {
-      const entry = queryCache.get(currentKey);
+      const entry = cache.get(currentKey);
       if (entry) {
         entry.listeners.delete(onCacheUpdate);
         entry.refetchers.delete(doFetch);
@@ -301,7 +308,7 @@ function query(key, fetcher, options = {}) {
         if (entry.subscribers <= 0 && cacheTime >= 0) {
           const key2 = currentKey;
           if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
-          entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
+          entry.gcTimer = setTimeout(() => cache.delete(key2), cacheTime);
         }
       }
     }
@@ -324,7 +331,7 @@ function query(key, fetcher, options = {}) {
 }
 function invalidateQueries(keyOrPredicate) {
   const predicate = typeof keyOrPredicate === "function" ? keyOrPredicate : (k) => k === keyOrPredicate;
-  for (const [key, entry] of queryCache.entries()) {
+  for (const [key, entry] of getActiveQueryCache().entries()) {
     if (predicate(key)) {
       entry.dataUpdatedAt = 0;
       for (const refetcher of entry.refetchers) refetcher();
@@ -332,10 +339,10 @@ function invalidateQueries(keyOrPredicate) {
   }
 }
 function getQueryData(key) {
-  return queryCache.get(key)?.data;
+  return getActiveQueryCache().get(key)?.data;
 }
 function setQueryData(key, data) {
-  const entry = queryCache.get(key);
+  const entry = getActiveQueryCache().get(key);
   if (!entry) return;
   const newData = typeof data === "function" ? data(entry.data) : data;
   entry.data = newData;
@@ -345,14 +352,15 @@ function setQueryData(key, data) {
 function clearQueryCache() {
   const activeListeners = [];
   const activeRefetchers = [];
-  for (const entry of queryCache.values()) {
+  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);
     }
   }
-  queryCache.clear();
+  activeCache.clear();
   for (const listener of activeListeners) listener();
   for (const refetcher of activeRefetchers) {
     refetcher().catch((err) => {
@@ -363,10 +371,11 @@ function clearQueryCache() {
   }
 }
 function __resetQueryCache() {
-  for (const entry of queryCache.values()) {
+  const activeCache = getActiveQueryCache();
+  for (const entry of activeCache.values()) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
   }
-  queryCache.clear();
+  activeCache.clear();
 }
 
 // src/data/mutation.ts
@@ -378,7 +387,11 @@ function mutation(mutationFn, options = {}) {
   const isSuccess = derived(() => status() === "success");
   const isIdle = derived(() => status() === "idle");
   let runId = 0;
+  let abortController = null;
   async function execute(variables) {
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal2 = abortController.signal;
     const myRun = ++runId;
     let context2;
     batch(() => {
@@ -390,7 +403,7 @@ function mutation(mutationFn, options = {}) {
       if (options.onMutate) {
         context2 = await options.onMutate(variables);
       }
-      const result = await withRetry(() => mutationFn(variables), options.retry);
+      const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
       batch(() => {
         setData(result);
@@ -402,6 +415,7 @@ function mutation(mutationFn, options = {}) {
       return result;
     } catch (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;
       batch(() => {
         setError(errorObj);
@@ -415,6 +429,8 @@ function mutation(mutationFn, options = {}) {
   }
   function reset() {
     runId++;
+    abortController?.abort();
+    abortController = null;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -430,6 +446,7 @@ function mutation(mutationFn, options = {}) {
     isIdle,
     mutate: (variables) => {
       execute(variables).catch((err) => {
+        if (err instanceof DOMException && err.name === "AbortError") return;
         if (typeof console !== "undefined") {
           console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
         }
@@ -446,6 +463,7 @@ function infiniteQuery(key, fetcher, options) {
     getNextPageParam,
     getPreviousPageParam,
     initialPageParam = 0,
+    maxPages,
     enabled = true,
     retry: retryOptions,
     onSuccess,
@@ -469,8 +487,9 @@ function infiniteQuery(key, fetcher, options) {
   let abortController = null;
   let disposed = false;
   let runId = 0;
-  async function fetchPage(pageParam, direction) {
-    if (disposed) return;
+  let inFlight = null;
+  function fetchPage(pageParam, direction) {
+    if (disposed) return Promise.resolve();
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
@@ -481,39 +500,44 @@ function infiniteQuery(key, fetcher, options) {
       if (direction === "prev") setIsFetchingPrev(true);
       setError(void 0);
     });
-    try {
-      const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
-      if (disposed || myRun !== runId) return;
-      const currentPages = pages();
-      let newPages;
-      if (direction === "prev") {
-        newPages = [page, ...currentPages];
-      } else {
-        newPages = [...currentPages, page];
+    const promise = (async () => {
+      try {
+        const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
+        if (disposed || myRun !== runId) return;
+        const currentPages = pages();
+        let newPages = direction === "prev" ? [page, ...currentPages] : [...currentPages, page];
+        if (maxPages != null && maxPages > 0 && newPages.length > maxPages) {
+          newPages = direction === "prev" ? newPages.slice(0, maxPages) : newPages.slice(newPages.length - maxPages);
+        }
+        const nextParam = getNextPageParam(newPages[newPages.length - 1], newPages);
+        const prevParam = getPreviousPageParam?.(newPages[0], newPages);
+        batch(() => {
+          setPages(newPages);
+          setNextPageParam(nextParam);
+          setPrevPageParam(prevParam);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onSuccess?.(newPages);
+      } catch (err) {
+        if (disposed || myRun !== runId) return;
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        batch(() => {
+          setError(errorObj);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onError?.(errorObj);
       }
-      const nextParam = getNextPageParam(page, newPages);
-      const prevParam = getPreviousPageParam?.(newPages[0], newPages);
-      batch(() => {
-        setPages(newPages);
-        setNextPageParam(nextParam);
-        setPrevPageParam(prevParam);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onSuccess?.(newPages);
-    } catch (err) {
-      if (disposed || myRun !== runId) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      batch(() => {
-        setError(errorObj);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onError?.(errorObj);
-    }
+    })();
+    inFlight = promise;
+    void promise.finally(() => {
+      if (inFlight === promise) inFlight = null;
+    });
+    return promise;
   }
   const effectCleanup = effect(() => {
     resolveKey();
@@ -528,11 +552,13 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (inFlight) return inFlight;
     const param = nextPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "next");
   }
   function fetchPreviousPage() {
+    if (inFlight) return inFlight;
     const param = prevPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "prev");
@@ -571,13 +597,17 @@ function infiniteQuery(key, fetcher, options) {
 function previous(getter) {
   const [previous2, setPrevious] = signal(void 0);
   let current = getter();
-  effect(() => {
+  const stop = effect(() => {
     const next = getter();
     if (!Object.is(next, current)) {
       setPrevious(current);
       current = next;
     }
   });
+  Object.defineProperty(previous2, "dispose", {
+    value: stop,
+    enumerable: false
+  });
   return previous2;
 }
 
@@ -585,7 +615,7 @@ function previous(getter) {
 function debounce(getter, delay) {
   const [debounced, setDebounced] = signal(getter());
   let timer = null;
-  effect(() => {
+  const stop = effect(() => {
     const value = getter();
     if (timer !== null) clearTimeout(timer);
     timer = setTimeout(() => {
@@ -593,6 +623,16 @@ function debounce(getter, delay) {
       timer = null;
     }, delay);
   });
+  Object.defineProperty(debounced, "dispose", {
+    value: () => {
+      stop();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return debounced;
 }
 
@@ -602,7 +642,8 @@ function throttle(getter, interval) {
   let cooldown = false;
   let pending = null;
   let lastEmitted = getter();
-  effect(() => {
+  let timer = null;
+  const stop = effect(() => {
     const value = getter();
     if (!cooldown) {
       if (!Object.is(value, lastEmitted)) {
@@ -610,7 +651,8 @@ function throttle(getter, interval) {
         lastEmitted = value;
         cooldown = true;
         pending = null;
-        setTimeout(() => {
+        timer = setTimeout(() => {
+          timer = null;
           cooldown = false;
           if (pending !== null) {
             const trailingValue = pending.value;
@@ -624,6 +666,16 @@ function throttle(getter, interval) {
       pending = { value };
     }
   });
+  Object.defineProperty(throttled, "dispose", {
+    value: () => {
+      stop();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return throttled;
 }
 
@@ -752,28 +804,45 @@ function idbGet(db, store, key) {
     req.onerror = () => reject(req.error);
   });
 }
-function idbPut(db, store, item) {
+function idbPut(db, store, item, key) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).put(item);
+    if (key !== void 0) tx.objectStore(store).put(item, key);
+    else tx.objectStore(store).put(item);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbPutWithChange(db, item, change) {
+function coalesceAndAddChange(tx, change, keyPath) {
+  const store = tx.objectStore("_changes");
+  const targetKey = change.item[keyPath];
+  const cursorReq = store.openCursor();
+  cursorReq.onsuccess = () => {
+    const cursor = cursorReq.result;
+    if (cursor) {
+      const existing = cursor.value;
+      const k = existing.item[keyPath];
+      if (targetKey != null && k === targetKey) cursor.delete();
+      cursor.continue();
+    } else {
+      store.put(change);
+    }
+  };
+}
+function idbPutWithChange(db, item, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").put(item);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbDeleteWithChange(db, key, change) {
+function idbDeleteWithChange(db, key, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").delete(key);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
@@ -833,13 +902,18 @@ async function offlineStore(options) {
     setPendingCount(changes.length);
   }
   async function put(item) {
-    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() });
+    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() }, keyPath);
     await refreshData();
   }
   async function remove(key) {
     const existing = await idbGet(db, "items", key);
     if (existing) {
-      await idbDeleteWithChange(db, key, { type: "delete", item: existing, timestamp: Date.now() });
+      await idbDeleteWithChange(
+        db,
+        key,
+        { type: "delete", item: existing, timestamp: Date.now() },
+        keyPath
+      );
       await refreshData();
     }
   }
@@ -865,6 +939,8 @@ async function offlineStore(options) {
             snapshot.map((e) => e.key)
           );
           if (closed) return;
+        } else if (typeof console !== "undefined") {
+          console.warn(`[offlineStore] push rejected by adapter${result.error ? `: ${result.error}` : ""}`);
         }
       }
       const remoteItems = await adapter.pull(lastSynced());
@@ -883,7 +959,7 @@ async function offlineStore(options) {
       await idbPutMany(db, "items", safeRemote);
       if (closed) return;
       const now = Date.now();
-      await idbPut(db, "_meta", now);
+      await idbPut(db, "_meta", now, "lastSynced");
       if (closed) return;
       setLastSynced(now);
       await refreshData();
@@ -951,14 +1027,20 @@ function loaderData() {
 async function preloadRoute(route, context2, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
+  let onAbort = null;
   if (callerSignal) {
     if (callerSignal.aborted) {
       controller.abort();
     } else {
-      callerSignal.addEventListener("abort", () => controller.abort(), { once: true });
+      onAbort = () => controller.abort();
+      callerSignal.addEventListener("abort", onAbort, { once: true });
     }
   }
-  return route.loader(context2, { signal: controller.signal });
+  try {
+    return await route.loader(context2, { signal: controller.signal });
+  } finally {
+    if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
+  }
 }
 
 // src/ui/socket.ts

package/dist/{chunk-WKUXSE7V.js → chunk-X67UYC74.js}

@@ -1,19 +1,21 @@
 import {
   bindAttribute
-} from "./chunk-2ZJ7TSW4.js";
+} from "./chunk-RLUJL2MV.js";
 import {
+  dispose,
   registerDisposer
 } from "./chunk-2UPRY23K.js";
 import {
+  isEventHandlerAttr,
   isUrlAttribute,
   sanitizeCSSValue,
   sanitizeSrcset,
   sanitizeUrl
-} from "./chunk-UCS6AMJ7.js";
+} from "./chunk-HMJFCBRR.js";
 import {
   reactiveBinding,
   track
-} from "./chunk-3U4ZVXVD.js";
+} from "./chunk-Z2FWAE4B.js";
 import {
   devWarn,
   isDev
@@ -34,6 +36,7 @@ function bindChildNode(placeholder, getter) {
     if (result == null || typeof result === "boolean") {
       for (let i = 0; i < lastNodes.length; i++) {
         const node = lastNodes[i];
+        dispose(node);
         if (node.parentNode) node.parentNode.removeChild(node);
       }
       lastNodes.length = 0;
@@ -75,18 +78,16 @@ function bindChildNode(placeholder, getter) {
     for (let i = 0; i < lastNodes.length; i++) {
       const node = lastNodes[i];
       if (reused?.has(node)) continue;
+      dispose(node);
       if (node.parentNode) node.parentNode.removeChild(node);
     }
-    const anchor = placeholder.nextSibling;
+    let prev = placeholder;
     for (let i = 0; i < newNodes.length; i++) {
       const node = newNodes[i];
-      if (reused?.has(node) && node.parentNode === parent) {
-        if (node.nextSibling !== anchor) {
-          parent.insertBefore(node, anchor);
-        }
-      } else {
-        parent.insertBefore(node, anchor);
+      if (prev.nextSibling !== node) {
+        parent.insertBefore(node, prev.nextSibling);
       }
+      prev = node;
     }
     lastNodes = newNodes;
   }
@@ -328,7 +329,7 @@ var tagFactory = (tag, ns) => {
           const value = props[key];
           if (value == null) continue;
           const lkey = key.toLowerCase();
-          if (lkey[0] === "o" && lkey[1] === "n") continue;
+          if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
           } else if (typeof value === "boolean") {

package/dist/{chunk-EFOAE5NC.js → chunk-YFDGQWDA.js}

@@ -1,6 +1,6 @@
 import {
   signal
-} from "./chunk-RK4BQG25.js";
+} from "./chunk-C427DVQF.js";
 
 // src/core/rendering/context.ts
 function context(defaultValue) {

package/dist/{chunk-3U4ZVXVD.js → chunk-Z2FWAE4B.js}

@@ -179,7 +179,7 @@ function track(effectFn, subscriber) {
 function reactiveBinding(commit) {
   const run = () => {
     const s = subscriber;
-    if (s._reentrant) return;
+    if (s._disposed || s._reentrant) return;
     s._reentrant = true;
     try {
       retrack(commit, subscriber);
@@ -195,8 +195,12 @@ function reactiveBinding(commit) {
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
+  subscriber._disposed = false;
   run();
-  return subscriber._dispose ?? (subscriber._dispose = () => cleanup(subscriber));
+  return subscriber._dispose ?? (subscriber._dispose = () => {
+    subscriber._disposed = true;
+    cleanup(subscriber);
+  });
 }
 function recordDependency(signal) {
   if (!currentSubscriber) return;