sibujs 4.4.0 → 4.6.0

package/dist/{chunk-6GSIXTWX.js → chunk-PK6FK2G2.js}

@@ -1,25 +1,25 @@
-import {
-  context
-} from "./chunk-7NBDXVHS.js";
 import {
   derived
-} from "./chunk-W2EQ7X2L.js";
+} from "./chunk-QE4TTDU3.js";
 import {
   sanitizeUrl
-} from "./chunk-IXKSNWV5.js";
+} from "./chunk-2INLLLMZ.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-7GIHSAWB.js";
+} from "./chunk-XC4MEKGA.js";
 import {
   getRequestScopedCache
-} from "./chunk-5DXA2J44.js";
+} from "./chunk-7XHATCIH.js";
 import {
   batch,
   signal
-} from "./chunk-NVNJH22U.js";
+} from "./chunk-D33YTSX5.js";
+import {
+  reportError
+} from "./chunk-NYNYSPK7.js";
 
 // src/data/abort.ts
 function isAbortError(error) {
@@ -389,6 +389,8 @@ function query(key, fetcher, options = {}) {
     if (disposed) return;
     disposed = true;
     effectCleanup();
+    loading.dispose();
+    isStale.dispose();
     if (intervalTimer) clearInterval(intervalTimer);
     detachFromEntry();
     if (focusHandler && typeof globalThis.removeEventListener === "function") {
@@ -474,7 +476,7 @@ function mutation(mutationFn, options = {}) {
     abortController = new AbortController();
     const signal2 = abortController.signal;
     const myRun = ++runId;
-    let context2;
+    let context;
     batch(() => {
       setLoading(true);
       setError(void 0);
@@ -482,7 +484,7 @@ function mutation(mutationFn, options = {}) {
     });
     try {
       if (options.onMutate) {
-        context2 = await options.onMutate(variables);
+        context = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
@@ -493,8 +495,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("success");
       });
-      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context));
       return result;
     } catch (err) {
       if (isAbortError(err)) {
@@ -516,8 +518,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("error");
       });
-      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context));
       throw errorObj;
     }
   }
@@ -655,18 +657,21 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = nextPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "next");
   }
   function fetchPreviousPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = prevPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "prev");
   }
   async function refetch() {
+    if (disposed) return;
     batch(() => {
       setPages([]);
       setNextPageParam(initialPageParam);
@@ -678,6 +683,10 @@ function infiniteQuery(key, fetcher, options) {
     disposed = true;
     abortController?.abort();
     effectCleanup();
+    data.dispose();
+    loading.dispose();
+    hasNextPage.dispose();
+    hasPreviousPage.dispose();
   }
   return {
     data,
@@ -746,25 +755,26 @@ function throttle(getter, interval) {
   let pending = null;
   let lastEmitted = getter();
   let timer = null;
+  function emit(value) {
+    setThrottled(value);
+    lastEmitted = value;
+    cooldown = true;
+    pending = null;
+    timer = setTimeout(endWindow, interval);
+  }
+  function endWindow() {
+    timer = null;
+    if (pending !== null && !Object.is(pending.value, lastEmitted)) {
+      emit(pending.value);
+      return;
+    }
+    pending = null;
+    cooldown = false;
+  }
   const stop = effect(() => {
     const value = getter();
     if (!cooldown) {
-      if (!Object.is(value, lastEmitted)) {
-        setThrottled(value);
-        lastEmitted = value;
-        cooldown = true;
-        pending = null;
-        timer = setTimeout(() => {
-          timer = null;
-          cooldown = false;
-          if (pending !== null) {
-            const trailingValue = pending.value;
-            pending = null;
-            setThrottled(trailingValue);
-            lastEmitted = trailingValue;
-          }
-        }, interval);
-      }
+      if (!Object.is(value, lastEmitted)) emit(value);
     } else {
       pending = { value };
     }
@@ -838,7 +848,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       });
       runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
-      if (version === fetchVersion) {
+      if (!disposed && version === fetchVersion) {
         runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
@@ -1145,15 +1155,54 @@ function syncAdapter(config) {
 }
 
 // src/data/routeLoader.ts
-var LoaderContext = context(null);
-function executeLoader(loader, context2, options) {
-  const res = resource(({ signal: signal2 }) => loader(context2, { signal: signal2 }), options);
-  LoaderContext.provide(res);
+var _clientScope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.v2"), () => ({ stack: [] }));
+var _disposed = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.disposed.v1"), () => /* @__PURE__ */ new WeakSet());
+function currentScope() {
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return _clientScope;
+  let scope = cache.get("scope");
+  if (!scope) {
+    scope = { stack: [] };
+    cache.set("scope", scope);
+  }
+  return scope;
+}
+function executeLoader(loader, context, options) {
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const disposeResource = res.dispose;
+  res.dispose = () => {
+    _disposed.add(res);
+    disposeResource();
+  };
   return res;
 }
+function renderWithLoader(loader, render) {
+  if (_disposed.has(loader)) {
+    throw new Error("renderWithLoader: the loader resource has been disposed");
+  }
+  const scope = currentScope();
+  const entry = loader;
+  scope.stack.push(entry);
+  try {
+    return render();
+  } finally {
+    const index = scope.stack.lastIndexOf(entry);
+    if (index !== -1) scope.stack.splice(index, 1);
+  }
+}
+function withLoader(loader, context, render, options) {
+  const res = executeLoader(loader, context, options);
+  try {
+    return { view: renderWithLoader(res, render), resource: res };
+  } catch (err) {
+    res.dispose();
+    throw err;
+  }
+}
 function loaderData() {
-  const resource2 = LoaderContext.get();
-  if (!resource2) {
+  const scope = currentScope();
+  const resource2 = scope.stack[scope.stack.length - 1];
+  if (!resource2 || _disposed.has(resource2)) {
     throw new Error("loaderData must be used inside a route with a loader");
   }
   return {
@@ -1162,7 +1211,7 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2, callerSignal) {
+async function preloadRoute(route, context, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
   let onAbort = null;
@@ -1175,7 +1224,7 @@ async function preloadRoute(route, context2, callerSignal) {
     }
   }
   try {
-    return await route.loader(context2, { signal: controller.signal });
+    return await route.loader(context, { signal: controller.signal });
   } finally {
     if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
   }
@@ -1203,34 +1252,73 @@ function socket(url, options) {
   let heartbeatTimer = null;
   let disposed = false;
   let manuallyClosed = false;
+  let lifecycle = 0;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
   function connect() {
     if (disposed) return;
+    const generation = lifecycle;
+    const invalidated = () => disposed || generation !== lifecycle;
     if (typeof WebSocket === "undefined") {
       setStatus("closed");
       return;
     }
-    const safeUrl = validateWsUrl(getUrl());
+    let rawUrl;
+    try {
+      rawUrl = getUrl();
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    const safeUrl = validateWsUrl(rawUrl);
     if (safeUrl === null) {
       setStatus("closed");
       return;
     }
     setStatus("connecting");
-    ws = new WebSocket(safeUrl, protocols);
-    ws.onopen = () => {
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    let instance;
+    try {
+      instance = new WebSocket(safeUrl, protocols);
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      instance.close();
+      setStatus("closed");
+      return;
+    }
+    ws = instance;
+    instance.onopen = () => {
+      if (ws !== instance) return;
+      const openGeneration = lifecycle;
       setStatus("open");
+      if (disposed || openGeneration !== lifecycle || ws !== instance) return;
       reconnectCount = 0;
       startHeartbeat();
     };
-    ws.onmessage = (event) => {
+    instance.onmessage = (event) => {
+      if (ws !== instance) return;
       setData(event.data);
     };
-    ws.onclose = () => {
+    instance.onclose = () => {
+      if (ws !== instance) return;
+      ws = null;
+      const closeGeneration = lifecycle;
       setStatus("closed");
       stopHeartbeat();
-      const wasManual = manuallyClosed;
+      const wasManual = manuallyClosed || closeGeneration !== lifecycle;
       manuallyClosed = false;
       if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
         const cap = 3e4;
@@ -1244,7 +1332,7 @@ function socket(url, options) {
         }, jittered);
       }
     };
-    ws.onerror = () => {
+    instance.onerror = () => {
     };
   }
   function startHeartbeat() {
@@ -1268,13 +1356,23 @@ function socket(url, options) {
     }
   }
   function close() {
+    lifecycle++;
     manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
     stopHeartbeat();
-    if (ws) {
+    if (!ws) {
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState === WebSocket.CLOSED) {
+      ws = null;
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState !== WebSocket.CLOSING) {
       setStatus("closing");
       ws.close();
     }
@@ -1305,6 +1403,7 @@ function stream(url, options) {
   let disposed = false;
   let reconnectTimer = null;
   let attempts = 0;
+  let closeGeneration = 0;
   function connect() {
     if (disposed) return;
     if (typeof EventSource === "undefined") {
@@ -1316,44 +1415,64 @@ function stream(url, options) {
       setStatus("closed");
       return;
     }
+    const generation = closeGeneration;
     setStatus("connecting");
-    source = new EventSource(safeUrl, {
+    if (disposed || generation !== closeGeneration) return;
+    const instance = new EventSource(safeUrl, {
       withCredentials: options?.withCredentials ?? false
     });
-    source.onopen = () => {
+    if (disposed || generation !== closeGeneration) {
+      instance.close();
+      return;
+    }
+    source = instance;
+    const live = () => !disposed && source === instance;
+    instance.onopen = () => {
+      if (!live()) return;
       setStatus("open");
       attempts = 0;
     };
-    source.onmessage = (evt) => {
+    instance.onmessage = (evt) => {
+      if (!live()) return;
       setData(evt.data);
       setEvent(evt.type);
     };
-    source.onerror = () => {
-      if (source && source.readyState === EventSource.CLOSED) {
-        setStatus("closed");
-        source = null;
-        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();
-          }, jittered);
-        }
+    instance.onerror = () => {
+      if (!live() || instance.readyState !== EventSource.CLOSED) return;
+      detach(instance);
+      source = null;
+      const generation2 = closeGeneration;
+      setStatus("closed");
+      if (disposed || generation2 !== closeGeneration) return;
+      if (autoReconnect && 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();
+        }, jittered);
       }
     };
   }
+  function detach(instance) {
+    instance.onopen = null;
+    instance.onmessage = null;
+    instance.onerror = null;
+  }
   function close() {
+    closeGeneration++;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
-    if (source) {
-      source.close();
-      setStatus("closed");
+    const instance = source;
+    if (instance) {
       source = null;
+      detach(instance);
+      instance.close();
     }
+    setStatus("closed");
   }
   function dispose() {
     disposed = true;
@@ -1381,6 +1500,8 @@ export {
   offlineStore,
   syncAdapter,
   executeLoader,
+  renderWithLoader,
+  withLoader,
   loaderData,
   preloadRoute,
   socket,

package/dist/{chunk-W2EQ7X2L.js → chunk-QE4TTDU3.js}

@@ -1,12 +1,13 @@
 import {
+  cleanup,
   isTrackingSuspended,
   recordDependency,
   retrack,
   track
-} from "./chunk-3BTTCZ5J.js";
+} from "./chunk-5Q4R7HCL.js";
 import {
   devAssert
-} from "./chunk-2WLZ6757.js";
+} from "./chunk-NYNYSPK7.js";
 
 // src/core/signals/derived.ts
 function derived(getter, options) {
@@ -16,10 +17,14 @@ function derived(getter, options) {
   const cs = {};
   cs._d = false;
   cs._init = false;
+  cs._f = false;
   cs._g = getter;
   cs.__v = 0;
+  let evaluating = false;
+  let disposed = false;
+  let pendingError;
   const markDirty = () => {
-    if (cs._d) return;
+    if (cs._d || disposed) return;
     cs._d = true;
   };
   markDirty._c = 1;
@@ -42,33 +47,53 @@ function derived(getter, options) {
     }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  let evaluating = false;
   const validate = () => {
-    if (!cs._d) return;
+    if (!cs._d || disposed || pendingError !== void 0) return;
     const oldValue = cs._v;
     evaluating = true;
     try {
       retrack(recompute, markDirty);
       if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } catch (err) {
+      pendingError = { error: err };
+      cs.__v++;
+      if (disposed) cs._d = true;
+      else cs._f = true;
     } finally {
       evaluating = false;
+      if (disposed) cleanup(markDirty);
     }
-    if (hook && !Object.is(oldValue, cs._v)) {
+    if (hook && !disposed && !Object.is(oldValue, cs._v)) {
       hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
     }
   };
   cs._validate = validate;
+  const throwPending = () => {
+    const { error } = pendingError;
+    pendingError = void 0;
+    if (disposed) cs._d = false;
+    throw error;
+  };
   function computedGetter() {
     if (evaluating) {
       throw new Error(
         `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
       );
     }
-    if (isTrackingSuspended()) {
-      if (cs._d) validate();
+    if (isTrackingSuspended() || disposed) {
+      if (cs._d) {
+        validate();
+        if (pendingError !== void 0) throwPending();
+      }
       return cs._v;
     }
-    if (cs._d) validate();
+    if (cs._d) {
+      validate();
+      if (pendingError !== void 0) {
+        recordDependency(cs);
+        throwPending();
+      }
+    }
     recordDependency(cs);
     return cs._v;
   }
@@ -77,6 +102,19 @@ function derived(getter, options) {
     cs.__name = debugName;
   }
   computedGetter.__signal = cs;
+  computedGetter.dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    cs._d = pendingError !== void 0;
+    cleanup(markDirty);
+    const h = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (h) {
+      try {
+        h.emit("computed:destroy", { signal: cs, getter: computedGetter });
+      } catch {
+      }
+    }
+  };
   if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
   return computedGetter;
 }