sibujs 1.4.0 → 2.0.0

package/dist/performance.cjs

@@ -30,8 +30,8 @@ __export(performance_exports, {
   deferredValue: () => deferredValue,
   denormalize: () => denormalize,
   devOnly: () => devOnly,
-  domPool: () => domPool,
   flushScheduler: () => flushScheduler,
+  getDOMPool: () => getDOMPool,
   hoistable: () => hoistable,
   lazyChunk: () => lazyChunk,
   noSideEffect: () => noSideEffect,
@@ -52,6 +52,7 @@ __export(performance_exports, {
   startTransition: () => startTransition,
   staticTemplate: () => staticTemplate,
   transitionState: () => transitionState,
+  trustHTML: () => trustHTML,
   uniqueId: () => uniqueId,
   yieldToMain: () => yieldToMain
 });
@@ -68,7 +69,9 @@ var Priority = {
 var taskIdCounter = 0;
 var taskQueue = [];
 var isProcessing = false;
-var frameId = null;
+var scheduledKind = null;
+var scheduledHandle = null;
+var microtaskScheduled = false;
 function insertTask(task) {
   let i = taskQueue.length;
   while (i > 0 && taskQueue[i - 1].priority > task.priority) {
@@ -103,30 +106,38 @@ function processQueue() {
   }
 }
 function scheduleFrame() {
-  if (frameId !== null) return;
+  if (scheduledKind !== null || microtaskScheduled) return;
   const nextTask = taskQueue.find((t) => !t.cancelled);
   if (!nextTask) return;
   if (nextTask.priority <= Priority.USER_BLOCKING) {
+    microtaskScheduled = true;
+    scheduledKind = "microtask";
     queueMicrotask(() => {
-      frameId = null;
+      microtaskScheduled = false;
+      scheduledKind = null;
       processQueue();
     });
-    frameId = -1;
   } else if (nextTask.priority === Priority.IDLE) {
     if (typeof requestIdleCallback !== "undefined") {
-      frameId = requestIdleCallback(() => {
-        frameId = null;
+      scheduledKind = "idle";
+      scheduledHandle = requestIdleCallback(() => {
+        scheduledKind = null;
+        scheduledHandle = null;
         processQueue();
       });
     } else {
-      frameId = setTimeout(() => {
-        frameId = null;
+      scheduledKind = "timeout";
+      scheduledHandle = setTimeout(() => {
+        scheduledKind = null;
+        scheduledHandle = null;
         processQueue();
       }, 50);
     }
   } else {
-    frameId = requestAnimationFrame(() => {
-      frameId = null;
+    scheduledKind = "frame";
+    scheduledHandle = requestAnimationFrame(() => {
+      scheduledKind = null;
+      scheduledHandle = null;
       processQueue();
     });
   }
@@ -154,6 +165,15 @@ function scheduleUpdate(priority, callback) {
   };
 }
 function flushScheduler() {
+  if (scheduledHandle !== null) {
+    if (scheduledKind === "frame") cancelAnimationFrame(scheduledHandle);
+    else if (scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") {
+      cancelIdleCallback(scheduledHandle);
+    } else if (scheduledKind === "timeout") clearTimeout(scheduledHandle);
+  }
+  scheduledHandle = null;
+  scheduledKind = null;
+  microtaskScheduled = false;
   while (taskQueue.length > 0) {
     const task = taskQueue.shift();
     if (!task) break;
@@ -162,7 +182,6 @@ function flushScheduler() {
     }
   }
   isProcessing = false;
-  frameId = null;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -189,21 +208,28 @@ function isDev() {
   return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : 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(`[Sibu] ${message}`);
+    console.warn(`[SibuJS] ${message}`);
   }
 }
 
 // src/reactivity/track.ts
 var _isDev2 = isDev();
 var subscriberStack = new Array(32);
+var stackCapacity = 32;
+var stackTop = -1;
 var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
 var SUBS = "__s";
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
 function safeInvoke(sub) {
   try {
     sub();
@@ -211,6 +237,24 @@ function safeInvoke(sub) {
     if (_isDev2) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  ++stackTop;
+  if (stackTop >= stackCapacity) {
+    stackCapacity *= 2;
+    subscriberStack.length = stackCapacity;
+  }
+  subscriberStack[stackTop] = subscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+  }
+  return () => cleanup(subscriber);
+}
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
@@ -231,7 +275,6 @@ function recordDependency(signal2) {
   let subs = signal2[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal2, subs);
     signal2[SUBS] = subs;
   }
   subs.add(currentSubscriber);
@@ -241,42 +284,46 @@ function recordDependency(signal2) {
     signal2.__f = void 0;
   }
 }
+var maxDrainIterations = 1e5;
 function propagateDirty(sub) {
   sub();
-  let sig = sub._sig;
-  while (sig) {
+  const rootSig = sub._sig;
+  if (!rootSig) return;
+  const stack = propagateStack;
+  const baseLen = stack.length;
+  stack.push(rootSig);
+  while (stack.length > baseLen) {
+    const sig = stack.pop();
     const first = sig.__f;
     if (first) {
       if (first._c) {
         const nSig = first._sig;
-        nSig._d = true;
-        sig = nSig;
-        continue;
-      }
-      if (!pendingSet.has(first)) {
+        if (!nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        }
+      } else if (!pendingSet.has(first)) {
         pendingSet.add(first);
         pendingQueue.push(first);
       }
-      break;
+      continue;
     }
     const subs = sig[SUBS];
-    if (!subs) break;
-    let nextSig;
+    if (!subs) continue;
     for (const s of subs) {
       if (s._c) {
-        s();
         const nSig = s._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s);
+        if (nSig && !nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        } else if (!nSig) {
+          s();
         }
       } else if (!pendingSet.has(s)) {
         pendingSet.add(s);
         pendingQueue.push(s);
       }
     }
-    sig = nextSig;
   }
 }
 function notifySubscribers(signal2) {
@@ -300,13 +347,23 @@ function notifySubscribers(signal2) {
       }
       let i = 0;
       while (i < pendingQueue.length) {
+        if (i >= maxDrainIterations) {
+          if (typeof console !== "undefined") {
+            console.error(
+              `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+            );
+          }
+          break;
+        }
         safeInvoke(pendingQueue[i]);
         i++;
       }
     } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
       notifyDepth--;
+      if (notifyDepth === 0) {
+        pendingQueue.length = 0;
+        pendingSet.clear();
+      }
     }
     return;
   }
@@ -326,32 +383,196 @@ function notifySubscribers(signal2) {
   notifyDepth++;
   try {
     let directCount = 0;
+    let hasComputedSub = false;
     for (const sub of subs) {
+      if (sub._c) hasComputedSub = true;
       pendingQueue[directCount++] = sub;
     }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (pendingQueue[i2]._c) {
-        propagateDirty(pendingQueue[i2]);
+    if (!hasComputedSub) {
+      for (let i2 = 0; i2 < directCount; i2++) {
+        safeInvoke(pendingQueue[i2]);
       }
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (!pendingQueue[i2]._c) {
-        if (!pendingSet.has(pendingQueue[i2])) {
-          safeInvoke(pendingQueue[i2]);
+    } else {
+      for (let i2 = 0; i2 < directCount; i2++) {
+        if (pendingQueue[i2]._c) {
+          propagateDirty(pendingQueue[i2]);
+        }
+      }
+      for (let i2 = 0; i2 < directCount; i2++) {
+        const sub = pendingQueue[i2];
+        if (!sub._c && !pendingSet.has(sub)) {
+          pendingSet.add(sub);
+          safeInvoke(sub);
         }
       }
     }
     let i = directCount;
     while (i < pendingQueue.length) {
+      if (i - directCount >= maxDrainIterations) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
       safeInvoke(pendingQueue[i]);
       i++;
     }
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
+function cleanup(subscriber) {
+  const sub = subscriber;
+  const singleDep = sub._dep;
+  if (singleDep !== void 0) {
+    const subs = singleDep[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (singleDep.__f === subscriber) {
+        singleDep.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && singleDep.__f === void 0) {
+        singleDep.__f = subs.values().next().value;
+      }
+    }
+    sub._dep = void 0;
+    return;
+  }
+  const deps = sub._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && signal2.__f === void 0) {
+        signal2.__f = subs.values().next().value;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/ssr-context.ts
+var als = null;
+try {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const req = Function("return typeof require==='function'?require:null")();
+    if (req) {
+      const mod = req("node:async_hooks");
+      als = new mod.AsyncLocalStorage();
+    }
+  }
+} catch {
+  als = null;
+}
+var fallbackStore = { ssr: false, suspenseIdCounter: 0 };
+function getSSRStore() {
+  if (als) {
+    const s = als.getStore();
+    if (s) return s;
+  }
+  return fallbackStore;
+}
+function isSSR() {
+  return getSSRStore().ssr;
+}
+
+// src/core/signals/effect.ts
+var _g = globalThis;
+function effect(effectFn, options) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  const onError = options?.onError;
+  let userCleanups = [];
+  const onCleanup = (fn) => {
+    userCleanups.push(fn);
+  };
+  const runUserCleanups = () => {
+    if (userCleanups.length === 0) return;
+    const list = userCleanups;
+    userCleanups = [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      try {
+        list[i]();
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS effect] onCleanup threw:", err);
+        }
+      }
+    }
+  };
+  const invokeBody = () => effectFn(onCleanup);
+  const wrappedFn = onError ? () => {
+    try {
+      invokeBody();
+    } catch (err) {
+      onError(err);
+    }
+  } : invokeBody;
+  let cleanupHandle = () => {
+  };
+  let running = false;
+  const subscriber = () => {
+    if (running) {
+      if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+        console.warn(
+          "[SibuJS] effect re-entered itself while running \u2014 the triggering update will be ignored. Wrap mutual writes in `batch()` or split the effect to avoid this."
+        );
+      }
+      return;
+    }
+    running = true;
+    try {
+      runUserCleanups();
+      cleanupHandle();
+      cleanupHandle = track(wrappedFn, subscriber);
+    } finally {
+      running = false;
+    }
+  };
+  running = true;
+  try {
+    cleanupHandle = track(wrappedFn, subscriber);
+  } finally {
+    running = false;
+  }
+  const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("effect:create", { effectFn });
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (h) {
+      try {
+        h.emit("effect:destroy", { effectFn });
+      } catch {
+      }
+    }
+    try {
+      runUserCleanups();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+      }
+    }
+    try {
+      cleanupHandle();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] dispose threw:", err);
+      }
+    }
+  };
+}
 
 // src/reactivity/batch.ts
 var batchDepth = 0;
@@ -363,7 +584,7 @@ function enqueueBatchedSignal(signal2) {
 }
 
 // src/core/signals/signal.ts
-var _g = globalThis;
+var _g2 = globalThis;
 var _isDev3 = isDev();
 function signal(initial, options) {
   const state = { value: initial };
@@ -384,7 +605,7 @@ function signal(initial, options) {
     if (_isDev3) {
       const oldValue = state.value;
       state.value = newValue;
-      const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+      const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
       if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
     } else {
       state.value = newValue;
@@ -394,7 +615,7 @@ function signal(initial, options) {
     }
   }
   if (_isDev3) {
-    const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
     if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
   }
   return [get, set];
@@ -406,15 +627,12 @@ function startTransition(callback) {
 }
 function deferredValue(getter) {
   const [deferred, setDeferred] = signal(getter());
-  const sync = () => {
-    const current = getter();
-    setDeferred(current);
-  };
-  scheduleUpdate(Priority.LOW, sync);
-  return () => {
-    scheduleUpdate(Priority.LOW, sync);
-    return deferred();
-  };
+  let latest = deferred();
+  effect(() => {
+    latest = getter();
+    scheduleUpdate(Priority.LOW, () => setDeferred(latest));
+  });
+  return deferred;
 }
 function transitionState() {
   const [isPending, setIsPending] = signal(false);
@@ -443,6 +661,7 @@ function uniqueId(suffix) {
 }
 
 // src/performance/domRecycler.ts
+var _isDev4 = isDev();
 var DOMPool = class {
   constructor(maxSize = 50) {
     this.pools = /* @__PURE__ */ new Map();
@@ -462,8 +681,18 @@ var DOMPool = class {
   /**
    * Return an element to the pool for reuse.
    * Clears attributes, children, and event listeners.
+   *
+   * Contract: the caller MUST detach the element from the DOM (and run any
+   * `dispose()` on bound reactive subscriptions) BEFORE calling `release()`.
+   * Releasing a connected element leaves it visible while it is mutated and
+   * is almost certainly a bug.
    */
   release(element) {
+    if (_isDev4 && element.isConnected) {
+      devWarn(
+        "DOMPool.release() called on a still-connected element. Detach it from the DOM first (remove() / dispose())."
+      );
+    }
     const tag = element.tagName.toLowerCase();
     let pool = this.pools.get(tag);
     if (!pool) {
@@ -499,7 +728,11 @@ var DOMPool = class {
     return result;
   }
 };
-var domPool = new DOMPool();
+var _defaultPool = null;
+function getDOMPool() {
+  if (_defaultPool === null) _defaultPool = new DOMPool();
+  return _defaultPool;
+}
 var preloadedResources = /* @__PURE__ */ new Set();
 function preloadResource(url, type = "fetch") {
   if (preloadedResources.has(url)) return;
@@ -562,6 +795,13 @@ function noSideEffect(fn) {
   return fn;
 }
 
+// src/platform/ssr.ts
+var _isDev5 = isDev();
+function trustHTML(html) {
+  return html;
+}
+var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
+
 // src/performance/compiled.ts
 function staticTemplate(html) {
   const template = document.createElement("template");
@@ -729,31 +969,45 @@ function createChunkRegistry(config = {}) {
   const pending = /* @__PURE__ */ new Map();
   const preloaded = /* @__PURE__ */ new Set();
   function evict() {
-    if (cache.size < maxCacheSize) return;
-    let oldest = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldest = key;
+    while (cache.size >= maxCacheSize) {
+      let lru = null;
+      let lruTime = Infinity;
+      for (const [key, entry] of cache) {
+        if (entry.lastAccess < lruTime) {
+          lruTime = entry.lastAccess;
+          lru = key;
+        }
       }
+      if (!lru) return;
+      cache.delete(lru);
     }
-    if (oldest) cache.delete(oldest);
   }
   function isValid(entry) {
     if (cacheTTL === 0) return true;
     return Date.now() - entry.timestamp < cacheTTL;
   }
   async function loadWithRetry(id, loader, attempt = 0) {
+    let timeoutHandle = null;
     try {
-      const result = await (timeout > 0 ? Promise.race([
-        loader(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)), timeout)
-        )
-      ]) : loader());
+      const result = await (timeout > 0 ? new Promise((resolve, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)),
+          timeout
+        );
+        loader().then(
+          (v) => {
+            if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+            resolve(v);
+          },
+          (e) => {
+            if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+            reject(e);
+          }
+        );
+      }) : loader());
       return result;
     } catch (err) {
+      if (timeoutHandle !== null) clearTimeout(timeoutHandle);
       if (attempt < retries) {
         await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
         return loadWithRetry(id, loader, attempt + 1);
@@ -761,49 +1015,48 @@ function createChunkRegistry(config = {}) {
       throw err;
     }
   }
+  async function loadFn(id, loader) {
+    const cached = cache.get(id);
+    if (cached && isValid(cached)) {
+      cached.accessCount++;
+      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;
+    });
+    pending.set(id, loadPromise);
+    return loadPromise;
+  }
+  function preloadFn(id, loader) {
+    if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
+    preloaded.add(id);
+    loadFn(id, loader).catch(() => {
+      preloaded.delete(id);
+    });
+  }
   return {
-    /**
-     * Load a chunk by ID. Uses cache if available, otherwise loads via the provided loader.
-     */
-    async load(id, loader) {
-      const cached = cache.get(id);
-      if (cached && isValid(cached)) {
-        cached.accessCount++;
-        return cached.value;
-      }
-      const pendingLoad = pending.get(id);
-      if (pendingLoad) return pendingLoad;
-      onLoadStart?.(id);
-      const loadPromise = loadWithRetry(id, loader).then((value) => {
-        evict();
-        cache.set(id, { value, timestamp: Date.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;
-      });
-      pending.set(id, loadPromise);
-      return loadPromise;
-    },
-    /**
-     * Preload a chunk without blocking. Silently caches for later use.
-     */
-    preload(id, loader) {
-      if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
-      preloaded.add(id);
-      this.load(id, loader).catch(() => {
-      });
-    },
+    load: loadFn,
+    preload: preloadFn,
     /**
      * Preload multiple chunks in parallel.
      */
     preloadAll(entries) {
       for (const entry of entries) {
-        this.preload(entry.id, entry.loader);
+        preloadFn(entry.id, entry.loader);
       }
     },
     /**
@@ -820,6 +1073,7 @@ function createChunkRegistry(config = {}) {
       const entry = cache.get(id);
       if (entry && isValid(entry)) {
         entry.accessCount++;
+        entry.lastAccess = Date.now();
         return entry.value;
       }
       return void 0;
@@ -829,6 +1083,7 @@ function createChunkRegistry(config = {}) {
      */
     invalidate(id) {
       cache.delete(id);
+      preloaded.delete(id);
     },
     /**
      * Clear all cached chunks.
@@ -898,8 +1153,8 @@ function preloadModules(urls) {
   deferredValue,
   denormalize,
   devOnly,
-  domPool,
   flushScheduler,
+  getDOMPool,
   hoistable,
   lazyChunk,
   noSideEffect,
@@ -920,6 +1175,7 @@ function preloadModules(urls) {
   startTransition,
   staticTemplate,
   transitionState,
+  trustHTML,
   uniqueId,
   yieldToMain
 });