sibujs 3.4.1 → 4.0.1

package/dist/{chunk-BQLVTAUZ.js → chunk-JYXQCELN.js}

@@ -1,10 +1,10 @@
 import {
   devWarn,
-  isDev
-} from "./chunk-COY6PUD2.js";
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/reactivity/track-core.ts
-var _isDev = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -12,6 +12,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -96,8 +97,27 @@ function safeInvoke(sub) {
   try {
     sub();
   } catch (err) {
-    if (_isDev) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s = sub;
+    reportError(err, { phase: s._errorPhase ?? "effect", name: s.__name, node: s._errorNode });
+  }
+}
+function depsChanged(sub) {
+  let node = sub.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
   }
+  return false;
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
@@ -179,7 +199,7 @@ function track(effectFn, subscriber) {
   const sub = subscriber;
   return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s = subscriber;
     if (s._disposed || s._reentrant) return;
@@ -195,13 +215,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -213,9 +237,12 @@ function recordDependency(signal) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub._hasComputedDep = true;
   const node = allocNode(signal, sub, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub, node);
@@ -234,9 +261,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -258,19 +286,21 @@ function tickRepeat(sub) {
   return s._runs > maxSubscriberRepeats;
 }
 function cycleError(sub) {
-  if (typeof console !== "undefined") {
-    const name = sub.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i = 0;
@@ -280,11 +310,14 @@ function drainQueue() {
       break;
     }
     const sub = pendingQueue[i++];
+    pendingSet.delete(sub);
+    if (quarantined.size > 0 && quarantined.has(sub)) continue;
+    if (sub._hasComputedDep === true && !depsChanged(sub)) continue;
     if (tickRepeat(sub)) {
       cycleError(sub);
-      break;
+      quarantined.add(sub);
+      continue;
     }
-    pendingSet.delete(sub);
     safeInvoke(sub);
   }
 }
@@ -299,6 +332,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -392,6 +426,7 @@ function notifySubscribers(signal) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -418,14 +453,14 @@ function forEachSubscriber(signal, visit) {
 }
 
 // src/reactivity/track.ts
-var _isDev2 = isDev();
-var _runtimeVersion = true ? "3.4.1" : "dev";
+var _isDev = isDev();
+var _runtimeVersion = true ? "4.0.1" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
   const existing = g[REGISTRY_KEY];
   if (existing) {
-    if (_isDev2 && !existing.__dupWarned) {
+    if (_isDev && !existing.__dupWarned) {
       existing.__dupWarned = true;
       devWarn(
         `Multiple instances of the reactive runtime detected on this page (active: ${existing.version}, duplicate: ${_runtimeVersion}). Reactivity still works \u2014 all copies share the first one \u2014 but de-duplicate sibujs in your bundler (e.g. Vite optimizeDeps.exclude: ['sibujs'] or resolve.dedupe: ['sibujs']).`

package/dist/{chunk-WEZ5SP7L.js → chunk-PHB3MCK4.js}

@@ -1,22 +1,24 @@
+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 {
-  dispose
-} from "./chunk-5VGSK6D2.js";
+  dispose,
+  replaceChildrenSafely
+} from "./chunk-DHDZ7IVN.js";
 import {
   signal
-} from "./chunk-335KJEN2.js";
+} from "./chunk-TVURNWDK.js";
 import {
   devWarn,
-  isDev
-} from "./chunk-COY6PUD2.js";
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/performance/scheduler.ts
 var Priority = {
@@ -265,7 +267,7 @@ var DOMPool = class {
       this.pools.set(tag, pool);
     }
     if (pool.length >= this.maxSize) return;
-    element.innerHTML = "";
+    replaceChildrenSafely(element);
     element.className = "";
     element.removeAttribute("style");
     element.removeAttribute("id");
@@ -396,8 +398,9 @@ function normalizedStore(schema) {
     ids: [],
     entities: {}
   });
+  const idOf = (entity) => String(entity[idKey]);
   function add(entity) {
-    const id = String(entity[idKey]);
+    const id = idOf(entity);
     setState((prev) => {
       const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
       return {
@@ -411,7 +414,7 @@ function normalizedStore(schema) {
       const nextIds = [...prev.ids];
       const nextEntities = { ...prev.entities };
       for (const entity of entities) {
-        const id = String(entity[idKey]);
+        const id = idOf(entity);
         if (!nextIds.includes(id)) {
           nextIds.push(id);
         }
@@ -533,7 +536,14 @@ function createChunkRegistry(config = {}) {
   } = config;
   const cache = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
-  const preloaded = /* @__PURE__ */ new Set();
+  const preloaded = /* @__PURE__ */ new Map();
+  function notify(name, run) {
+    try {
+      run();
+    } catch (err) {
+      reportError(err, { phase: "async", name: `chunkRegistry(${name})` });
+    }
+  }
   function evict() {
     while (cache.size >= maxCacheSize) {
       let lru = null;
@@ -588,30 +598,47 @@ function createChunkRegistry(config = {}) {
       cached.lastAccess = Date.now();
       return cached.value;
     }
-    const pendingLoad = pending.get(id);
-    if (pendingLoad) return pendingLoad;
-    onLoadStart?.(id);
-    const loadPromise = loadWithRetry(id, loader).then((value) => {
-      evict();
-      const now = Date.now();
-      cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
-      pending.delete(id);
-      onLoadEnd?.(id);
-      return value;
-    }).catch((err) => {
-      pending.delete(id);
-      const error = err instanceof Error ? err : new Error(String(err));
-      onLoadError?.(id, error);
-      throw error;
+    const existing = pending.get(id);
+    if (existing) return existing.promise;
+    let resolveOuter;
+    let rejectOuter;
+    const outcome = new Promise((resolve, reject) => {
+      resolveOuter = resolve;
+      rejectOuter = reject;
+    });
+    const entry = { promise: outcome };
+    pending.set(id, entry);
+    const owns = () => pending.get(id) === entry;
+    notify("onLoadStart", () => onLoadStart?.(id));
+    void loadWithRetry(id, loader).then(
+      (value) => {
+        if (owns()) {
+          pending.delete(id);
+          evict();
+          const now = Date.now();
+          cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
+        }
+        notify("onLoadEnd", () => onLoadEnd?.(id));
+        resolveOuter(value);
+      },
+      (err) => {
+        if (owns()) pending.delete(id);
+        const error = err instanceof Error ? err : new Error(String(err));
+        notify("onLoadError", () => onLoadError?.(id, error));
+        rejectOuter(error);
+      }
+    ).catch((internal) => {
+      reportError(internal, { phase: "async", name: "chunkRegistry(settlement)" });
+      rejectOuter(internal);
     });
-    pending.set(id, loadPromise);
-    return loadPromise;
+    return outcome;
   }
   function preloadFn(id, loader) {
     if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
-    preloaded.add(id);
+    const marker = {};
+    preloaded.set(id, marker);
     loadFn(id, loader).catch(() => {
-      preloaded.delete(id);
+      if (preloaded.get(id) === marker) preloaded.delete(id);
     });
   }
   return {
@@ -645,21 +672,33 @@ function createChunkRegistry(config = {}) {
       return void 0;
     },
     /**
-     * Invalidate a cached chunk.
+     * Invalidate a cached chunk, and supersede any load still in flight for it.
+     *
+     * In-flight work is not cancelled — the loader API takes no abort signal, so
+     * claiming cancellation would be a lie. It is *superseded*: it still settles
+     * for whoever called `load()`, but it can no longer write to the cache, and
+     * a subsequent `load(id, …)` starts fresh work rather than adopting it.
      */
     invalidate(id) {
       cache.delete(id);
       preloaded.delete(id);
+      pending.delete(id);
     },
     /**
-     * Clear all cached chunks.
+     * Clear all cached chunks, and supersede every load still in flight.
+     *
+     * Same barrier as `invalidate`, applied to every key at once.
      */
     clear() {
       cache.clear();
       preloaded.clear();
+      pending.clear();
     },
     /**
      * Get cache statistics.
+     *
+     * Describes currently OWNED state: superseded loads are already absent from
+     * `pending`, so the counts never include work whose result will be discarded.
      */
     stats() {
       return {

package/dist/chunk-PHRH66Y7.js

@@ -0,0 +1,147 @@
+import {
+  isEventHandlerAttr,
+  isHtmlContentAttribute,
+  sanitizeAttributeString
+} from "./chunk-5INI7D2L.js";
+import {
+  reactiveBinding
+} from "./chunk-JYXQCELN.js";
+import {
+  devWarn,
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
+
+// src/utils/setSafeAttribute.ts
+var _isDev = isDev();
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
+function isHtmlElement(el) {
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+}
+function setProp(el, key, val) {
+  el[key] = val;
+}
+function namespaceFor(el, name) {
+  if (el.namespaceURI !== SVG_NS) return null;
+  const lower = name.toLowerCase();
+  if (lower.startsWith("xlink:")) return XLINK_NS;
+  if (lower.startsWith("xml:")) return XML_NS;
+  return null;
+}
+function setSafeAttribute(el, name, value, options = {}) {
+  const ns = namespaceFor(el, name);
+  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
+  if (isEventHandlerAttr(name)) {
+    if (_isDev) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  if (value == null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
+  if (isHtmlContentAttribute(name)) {
+    if (_isDev) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const html = isHtmlElement(el);
+  const idlName = html ? name.toLowerCase() : name;
+  if (typeof value === "boolean") {
+    if (html && BOOLEAN_IDL_ATTRS.has(idlName) && idlName in el) {
+      setProp(el, idlName, value);
+    } else if (value) {
+      if (ns) el.setAttributeNS(ns, name, "");
+      else el.setAttribute(name, "");
+    } else if (ns) {
+      el.removeAttributeNS(ns, localName);
+    } else {
+      el.removeAttribute(name);
+    }
+    return true;
+  }
+  const str = String(value);
+  if (options.syncValueProperty !== false && html && (idlName === "value" || idlName === "checked") && idlName in el) {
+    setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
+    return true;
+  }
+  const safe = sanitizeAttributeString(name, str);
+  const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
+  if (current === safe) return true;
+  if (ns) el.setAttributeNS(ns, name, safe);
+  else el.setAttribute(name, safe);
+  return true;
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  if (isEventHandlerAttr(attr)) {
+    setSafeAttribute(el, attr, "", { label: `bindAttribute("${attr}")` });
+    return () => {
+    };
+  }
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch (err) {
+      reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
+      return;
+    }
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
+  }
+  return reactiveBinding(commit, el);
+}
+function bindDynamic(el, nameGetter, valueGetter) {
+  let prevName = null;
+  function commit() {
+    let name;
+    try {
+      name = typeof nameGetter === "function" ? nameGetter() : nameGetter;
+    } catch (err) {
+      reportError(err, { phase: "binding", name: "bindDynamic (name getter)", node: el });
+      return;
+    }
+    let value;
+    try {
+      value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
+    } catch (err) {
+      reportError(err, { phase: "binding", name: "bindDynamic (value getter)", node: el });
+      return;
+    }
+    if (prevName !== null && prevName !== name) {
+      el.removeAttribute(prevName);
+      prevName = null;
+    }
+    if (!setSafeAttribute(el, name, value, { label: "bindDynamic" })) return;
+    prevName = name;
+  }
+  const teardown = reactiveBinding(commit, el);
+  return () => {
+    teardown();
+    if (prevName !== null) {
+      el.removeAttribute(prevName);
+    }
+  };
+}
+
+export {
+  setSafeAttribute,
+  bindAttribute,
+  bindDynamic
+};