sibujs 1.4.0 → 2.0.0

package/dist/{chunk-TSOKIX5Z.js → chunk-MIUAXB7K.js}

@@ -1,6 +1,13 @@
+import {
+  effect
+} from "./chunk-HB24TBAF.js";
 import {
   signal
-} from "./chunk-WZSPOOER.js";
+} from "./chunk-CC65Y57T.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-LMLD24FC.js";
 
 // src/performance/scheduler.ts
 var Priority = {
@@ -13,7 +20,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) {
@@ -48,30 +57,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();
     });
   }
@@ -99,6 +116,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;
@@ -107,7 +133,6 @@ function flushScheduler() {
     }
   }
   isProcessing = false;
-  frameId = null;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -135,15 +160,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);
@@ -172,6 +194,7 @@ function uniqueId(suffix) {
 }
 
 // src/performance/domRecycler.ts
+var _isDev = isDev();
 var DOMPool = class {
   constructor(maxSize = 50) {
     this.pools = /* @__PURE__ */ new Map();
@@ -191,8 +214,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 (_isDev && 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) {
@@ -228,7 +261,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;
@@ -458,31 +495,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);
@@ -490,49 +541,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);
       }
     },
     /**
@@ -549,6 +599,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;
@@ -558,6 +609,7 @@ function createChunkRegistry(config = {}) {
      */
     invalidate(id) {
       cache.delete(id);
+      preloaded.delete(id);
     },
     /**
      * Clear all cached chunks.
@@ -630,7 +682,7 @@ export {
   setIdPrefix,
   uniqueId,
   DOMPool,
-  domPool,
+  getDOMPool,
   preloadResource,
   prefetch,
   preloadImage,