sibujs 3.4.1 → 4.0.1

package/dist/{chunk-CV7FAQ2R.js → chunk-UNAYBND2.js}

@@ -1,9 +1,9 @@
 import {
   registerDisposer
-} from "./chunk-5VGSK6D2.js";
+} from "./chunk-DHDZ7IVN.js";
 import {
   signal
-} from "./chunk-335KJEN2.js";
+} from "./chunk-TVURNWDK.js";
 
 // src/ui/transition.ts
 function transition(element, options = {}) {
@@ -335,7 +335,9 @@ function TransitionGroup(options) {
 // src/ui/viewTransition.ts
 function viewTransition(callback) {
   const [isTransitioning, setIsTransitioning] = signal(false);
+  let inflight = 0;
   async function start() {
+    inflight++;
     setIsTransitioning(true);
     try {
       if (typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
@@ -345,7 +347,11 @@ function viewTransition(callback) {
         await callback();
       }
     } finally {
-      setIsTransitioning(false);
+      inflight--;
+      if (inflight <= 0) {
+        inflight = 0;
+        setIsTransitioning(false);
+      }
     }
   }
   return { start, isTransitioning };

package/dist/chunk-VPP2FONR.js

@@ -0,0 +1,142 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+    // The bare `__SIBU_DEV__` is a bundler define that only exists in
+    // production builds; under the test runner it is always undefined, so
+    // this branch is unreachable here.
+    /* v8 ignore next 2 */
+    typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+  );
+}
+var _isDev = isDev();
+function devAssert(condition, message) {
+  if (_isDev && !condition) {
+    throw new Error(`[SibuJS] ${message}`);
+  }
+}
+function devWarn(message) {
+  if (_isDev) {
+    console.warn(`[SibuJS] ${message}`);
+  }
+}
+
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[ERROR_STATE_KEY] = created;
+  return created;
+}
+function setRuntimeErrorHandler(handler) {
+  const s = state();
+  const prev = s.handler;
+  s.handler = handler;
+  return prev;
+}
+function getRuntimeErrorHandler() {
+  return state().handler;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+
+export {
+  __require,
+  __export,
+  isDev,
+  devAssert,
+  devWarn,
+  setRuntimeErrorHandler,
+  getRuntimeErrorHandler,
+  normalizeError,
+  reportError
+};

package/dist/{chunk-X4JS367G.js → chunk-XDOMTQHM.js}

@@ -1,14 +1,15 @@
 import {
   isSSR
-} from "./chunk-S3NFJO6L.js";
+} from "./chunk-TIRZCERI.js";
 import {
   cleanup,
   retrack,
   untracked
-} from "./chunk-BQLVTAUZ.js";
+} from "./chunk-JYXQCELN.js";
 import {
-  devAssert
-} from "./chunk-COY6PUD2.js";
+  devAssert,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -37,7 +38,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -50,11 +51,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-      console.error(
-        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-      );
-    }
+    reportError(
+      new Error(
+        `effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      ),
+      { phase: "effect" }
+    );
   }
 }
 function disposeEffect(ctx) {
@@ -131,6 +133,8 @@ function effect(effectFn, options) {
   sub.depsTail = null;
   sub._epoch = 0;
   sub._structDirty = false;
+  sub._hasComputedDep = false;
+  sub._errorPhase = "effect";
   sub._runEpoch = 0;
   sub._runs = 0;
   ctx.subscriber = sub;

package/dist/chunk-XET2RUJF.js

@@ -0,0 +1,61 @@
+import {
+  isSSR
+} from "./chunk-TIRZCERI.js";
+import {
+  signal
+} from "./chunk-TVURNWDK.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-VPP2FONR.js";
+
+// src/core/rendering/context.ts
+var _isDev = isDev();
+function context(defaultValue) {
+  const [getValue, setValue] = signal(defaultValue);
+  const warnIfSSR = (method) => {
+    if (!_isDev || !isSSR()) return;
+    devWarn(
+      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
+    );
+  };
+  const ctx = {
+    provide(value) {
+      warnIfSSR("provide");
+      const previous = getValue();
+      setValue(value);
+      return () => setValue(previous);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      warnIfSSR("set");
+      setValue(value);
+    },
+    withContext(value, fn) {
+      warnIfSSR("withContext");
+      const previous = getValue();
+      setValue(value);
+      try {
+        const result = fn();
+        if (_isDev && result !== null && typeof result?.then === "function") {
+          devWarn(
+            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
+          );
+        }
+        return result;
+      } finally {
+        setValue(previous);
+      }
+    }
+  };
+  return ctx;
+}
+
+export {
+  context
+};